blob: 328a382e880ea6a3b3e814333739ed4c4c546833 [file] [log] [blame]
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001/*
2 * Copyright (C) 2007 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
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -080017// TODO(b/129481165): remove the #pragma below and fix conversion issues
18#pragma clang diagnostic push
19#pragma clang diagnostic ignored "-Wconversion"
Marin Shalamanovbed7fd32020-12-21 20:02:20 +010020#pragma clang diagnostic ignored "-Wextra"
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -080021
Alec Mourie7d1d4a2019-02-05 01:13:46 +000022//#define LOG_NDEBUG 0
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080023#define ATRACE_TAG ATRACE_TAG_GRAPHICS
24
Alec Mouri5f487d42020-02-06 09:26:19 -080025#include "SurfaceFlinger.h"
Dominik Laskowski83b88212018-12-11 13:34:06 -080026
Xiang Wang99f6f3c2023-05-22 13:12:16 -070027#include <aidl/android/hardware/power/Boost.h>
Dominik Laskowski298b08e2022-02-15 13:45:02 -080028#include <android-base/parseint.h>
Ana Krulecb9afd792020-06-11 13:16:15 -070029#include <android-base/properties.h>
Dominik Laskowski298b08e2022-02-15 13:45:02 -080030#include <android-base/stringprintf.h>
31#include <android-base/strings.h>
Alec Mouri5f487d42020-02-06 09:26:19 -080032#include <android/configuration.h>
Huihong Luo6fac5232021-11-22 16:05:23 -080033#include <android/gui/IDisplayEventConnection.h>
Huihong Luoa79ddf42022-02-17 00:01:38 -080034#include <android/gui/StaticDisplayInfo.h>
Alec Mouri5f487d42020-02-06 09:26:19 -080035#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
36#include <android/hardware/configstore/1.1/ISurfaceFlingerConfigs.h>
37#include <android/hardware/configstore/1.1/types.h>
Steven Thomas62a4cf82020-01-31 12:04:03 -080038#include <android/native_window.h>
Chris Ye0783e992020-06-02 21:34:49 -070039#include <android/os/IInputFlinger.h>
Mathias Agopianc5b2c0b2009-05-19 19:08:10 -070040#include <binder/IPCThreadState.h>
41#include <binder/IServiceManager.h>
Mathias Agopian99b49842011-06-27 16:05:52 -070042#include <binder/PermissionCache.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070043#include <compositionengine/CompositionEngine.h>
Lloyd Piqueab039b52019-02-13 14:22:42 -080044#include <compositionengine/CompositionRefreshArgs.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070045#include <compositionengine/Display.h>
Lloyd Pique3d0c02e2018-10-19 18:38:12 -070046#include <compositionengine/DisplayColorProfile.h>
Patrick Williams7584c6a2022-10-29 02:10:58 +000047#include <compositionengine/DisplayColorProfileCreationArgs.h>
Lloyd Pique9370a482019-10-03 17:58:30 -070048#include <compositionengine/DisplayCreationArgs.h>
Lloyd Piquede196652020-01-22 17:29:58 -080049#include <compositionengine/LayerFECompositionState.h>
Lloyd Piquecc01a452018-12-04 17:24:00 -080050#include <compositionengine/OutputLayer.h>
Lloyd Pique31cb2942018-10-19 17:23:03 -070051#include <compositionengine/RenderSurface.h>
Patrick Williams7584c6a2022-10-29 02:10:58 +000052#include <compositionengine/impl/DisplayColorProfile.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070053#include <compositionengine/impl/OutputCompositionState.h>
John Reckdb1a16b2021-07-09 13:05:52 -040054#include <compositionengine/impl/OutputLayerCompositionState.h>
Alec Mouri5f487d42020-02-06 09:26:19 -080055#include <configstore/Utils.h>
56#include <cutils/compiler.h>
57#include <cutils/properties.h>
Dominik Laskowskib363c4c2022-08-02 14:03:41 -070058#include <ftl/algorithm.h>
Dominik Laskowski5d7de5f2022-11-03 12:38:32 -040059#include <ftl/concat.h>
Dominik Laskowski298b08e2022-02-15 13:45:02 -080060#include <ftl/fake_guard.h>
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -080061#include <ftl/future.h>
Dominik Laskowskib363c4c2022-08-02 14:03:41 -070062#include <ftl/unit.h>
Huihong Luo3bdef862022-03-03 11:57:19 -080063#include <gui/AidlStatusUtil.h>
Jamie Gennis1a4d8832012-08-02 20:11:05 -070064#include <gui/BufferQueue.h>
Ady Abrahama3b08ef2019-07-15 18:43:10 -070065#include <gui/DebugEGLImageTracker.h>
Alec Mouri0a9c7b82018-11-16 13:05:25 -080066#include <gui/IProducerListener.h>
Kalle Raitaa099a242017-01-11 11:17:29 -080067#include <gui/LayerDebugInfo.h>
Lloyd Pique4603f3c2020-02-11 12:06:56 -080068#include <gui/LayerMetadata.h>
Steven Thomas62a4cf82020-01-31 12:04:03 -080069#include <gui/LayerState.h>
Mathias Agopiane3c697f2013-02-14 17:11:02 -080070#include <gui/Surface.h>
Brian Johnson51d8d5d2023-07-28 10:18:47 -070071#include <gui/SurfaceComposerClient.h>
rnlee60f46b52021-05-21 15:14:07 -070072#include <gui/TraceUtils.h>
Steven Moreland7c8af942020-07-08 18:35:51 +000073#include <hidl/ServiceManagement.h>
Alec Mouri5f487d42020-02-06 09:26:19 -080074#include <layerproto/LayerProtoParser.h>
75#include <log/log.h>
76#include <private/android_filesystem_config.h>
77#include <private/gui/SyncFeatures.h>
Wei Wang976a6452021-06-11 15:26:00 -070078#include <processgroup/processgroup.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070079#include <renderengine/RenderEngine.h>
Vishnu Nairdbbe3852022-01-12 20:22:11 -080080#include <renderengine/impl/ExternalTexture.h>
Dominik Laskowskib418dd72023-06-13 17:31:04 -040081#include <scheduler/FrameTargeter.h>
Alec Mouri5f487d42020-02-06 09:26:19 -080082#include <sys/types.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070083#include <ui/ColorSpace.h>
Alec Mouricdf6cbc2021-11-01 17:21:15 -070084#include <ui/DataspaceUtils.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070085#include <ui/DebugUtils.h>
Marin Shalamanov045b7002021-01-07 16:56:24 +010086#include <ui/DisplayId.h>
Marin Shalamanova7fe3042021-01-29 21:02:08 +010087#include <ui/DisplayMode.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070088#include <ui/DisplayStatInfo.h>
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -080089#include <ui/DisplayState.h>
Marin Shalamanov228f46b2021-01-28 21:11:45 +010090#include <ui/DynamicDisplayInfo.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070091#include <ui/GraphicBufferAllocator.h>
Vishnu Nairafd527a2022-10-18 08:56:10 -070092#include <ui/LayerStack.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070093#include <ui/PixelFormat.h>
Marin Shalamanov228f46b2021-01-28 21:11:45 +010094#include <ui/StaticDisplayInfo.h>
Brian Johnson51d8d5d2023-07-28 10:18:47 -070095#include <unistd.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080096#include <utils/StopWatch.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070097#include <utils/String16.h>
98#include <utils/String8.h>
Yusuke Sato0a688f52015-07-30 23:05:39 -070099#include <utils/Timers.h>
Lloyd Pique70d91362018-10-18 16:02:55 -0700100#include <utils/misc.h>
Alec Mouri5f487d42020-02-06 09:26:19 -0800101#include <algorithm>
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -0800102#include <cerrno>
Alec Mouri5f487d42020-02-06 09:26:19 -0800103#include <cinttypes>
104#include <cmath>
105#include <cstdint>
106#include <functional>
Xiang Wang839fe5b2022-04-04 17:39:38 +0000107#include <memory>
Alec Mouri5f487d42020-02-06 09:26:19 -0800108#include <mutex>
109#include <optional>
Vishnu Nair81750622023-03-08 15:02:06 -0800110#include <string>
Michael Wright44753b12020-07-08 13:48:11 +0100111#include <type_traits>
Alec Mouri5f487d42020-02-06 09:26:19 -0800112#include <unordered_map>
Vishnu Nair40fff5c2022-11-04 02:46:28 +0000113#include <vector>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800114
Chavi Weingartenc78f53c2023-04-14 18:50:53 +0000115#include <gui/LayerStatePermissions.h>
Alec Mouriff793872022-01-13 17:45:06 -0800116#include <ui/DisplayIdentification.h>
Vishnu Nair03ccbd62021-12-01 17:21:16 -0800117#include "BackgroundExecutor.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +0200118#include "Client.h"
Brian Lindahl439afad2022-11-14 11:16:55 -0700119#include "ClientCache.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +0200120#include "Colorizer.h"
Robert Carr578038f2018-03-09 12:25:24 -0800121#include "DisplayDevice.h"
Steven Thomasb02664d2017-07-26 18:48:28 -0700122#include "DisplayHardware/ComposerHal.h"
Mathias Agopiana4912602012-07-12 14:25:33 -0700123#include "DisplayHardware/FramebufferSurface.h"
Mathias Agopiana350ff92010-08-10 17:14:02 -0700124#include "DisplayHardware/HWComposer.h"
Marin Shalamanovd3b5c5d2021-02-11 18:26:14 +0100125#include "DisplayHardware/Hal.h"
Xiang Wang839fe5b2022-04-04 17:39:38 +0000126#include "DisplayHardware/PowerAdvisor.h"
Jesse Hall99c7dbb2013-03-14 14:29:29 -0700127#include "DisplayHardware/VirtualDisplaySurface.h"
Marin Shalamanovf6b5d182020-06-12 02:08:51 +0200128#include "DisplayRenderArea.h"
Mathias Agopianff2ed702013-09-01 21:36:12 -0700129#include "Effects/Daltonizer.h"
rnleea2ecd832021-07-29 13:58:30 -0700130#include "FlagManager.h"
Alec Mouriadebf5c2021-01-05 12:57:36 -0800131#include "FpsReporter.h"
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700132#include "FrameTimeline/FrameTimeline.h"
Mikael Pessa90092f42019-08-26 17:22:04 -0700133#include "FrameTracer/FrameTracer.h"
Vishnu Naircb8be502022-10-12 19:03:23 +0000134#include "FrontEnd/LayerCreationArgs.h"
Vishnu Nair07e2a482022-10-18 19:18:16 +0000135#include "FrontEnd/LayerHandle.h"
Vishnu Nair81750622023-03-08 15:02:06 -0800136#include "FrontEnd/LayerLifecycleManager.h"
Vishnu Nair7aa0eb72023-01-24 03:59:27 +0000137#include "FrontEnd/LayerSnapshot.h"
John Reck88270902021-03-18 11:27:35 -0400138#include "HdrLayerInfoReporter.h"
Alec Mouri5f487d42020-02-06 09:26:19 -0800139#include "Layer.h"
chaviw0a398992021-08-13 10:13:01 -0500140#include "LayerProtoHelper.h"
Marin Shalamanovf6b5d182020-06-12 02:08:51 +0200141#include "LayerRenderArea.h"
Alec Mouri5f487d42020-02-06 09:26:19 -0800142#include "LayerVector.h"
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800143#include "MutexUtils.h"
Alec Mouri5f487d42020-02-06 09:26:19 -0800144#include "NativeWindowSurface.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700145#include "RegionSamplingThread.h"
Ana Krulecfefcb582018-08-07 14:22:37 -0700146#include "Scheduler/EventThread.h"
Ady Abraham5def7332020-05-29 16:13:47 -0700147#include "Scheduler/LayerHistory.h"
Ana Krulec98b5b242018-08-10 15:03:23 -0700148#include "Scheduler/Scheduler.h"
Ady Abrahamc581d3c2020-08-06 17:34:27 -0700149#include "Scheduler/VsyncConfiguration.h"
Dominik Laskowski1c99a002023-01-20 17:10:36 -0500150#include "Scheduler/VsyncModulator.h"
Patrick Williams7584c6a2022-10-29 02:10:58 +0000151#include "ScreenCaptureOutput.h"
Alec Mouri5f487d42020-02-06 09:26:19 -0800152#include "StartPropertySetThread.h"
153#include "SurfaceFlingerProperties.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800154#include "TimeStats/TimeStats.h"
Galia Peycheva8f04b302021-04-27 13:25:38 +0200155#include "TunnelModeEnabledReporter.h"
Dominik Laskowskie70461a2022-08-30 14:42:01 -0700156#include "Utils/Dumper.h"
chaviw60c9d3e2021-06-04 12:52:17 -0500157#include "WindowInfosListenerInvoker.h"
David Sodman7e4ae112018-02-09 15:02:28 -0800158
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500159#include <aidl/android/hardware/graphics/common/DisplayDecorationSupport.h>
Leon Scroggins III5967aec2021-12-29 11:14:22 -0500160#include <aidl/android/hardware/graphics/composer3/DisplayCapability.h>
Alec Mourifcedb9c2022-04-11 20:02:17 +0000161#include <aidl/android/hardware/graphics/composer3/RenderIntent.h>
Leon Scroggins III5967aec2021-12-29 11:14:22 -0500162
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700163#undef NO_THREAD_SAFETY_ANALYSIS
164#define NO_THREAD_SAFETY_ANALYSIS \
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800165 _Pragma("GCC error \"Prefer <ftl/fake_guard.h> or MutexUtils.h helpers.\"")
Leon Scroggins III5967aec2021-12-29 11:14:22 -0500166
Tianhao Yao67dd7122022-02-22 17:48:33 +0000167// To enable layer borders in the system, change the below flag to true.
168#undef DOES_CONTAIN_BORDER
169#define DOES_CONTAIN_BORDER false
170
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800171namespace android {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700172
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700173using namespace std::chrono_literals;
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700174using namespace std::string_literals;
Dominik Laskowski03cfce82022-11-02 12:13:29 -0400175using namespace std::string_view_literals;
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700176
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800177using namespace hardware::configstore;
178using namespace hardware::configstore::V1_0;
179using namespace sysprop;
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000180using ftl::Flags;
181using namespace ftl::flag_operators;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -0800182
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800183using aidl::android::hardware::graphics::common::DisplayDecorationSupport;
184using aidl::android::hardware::graphics::composer3::Capability;
185using aidl::android::hardware::graphics::composer3::DisplayCapability;
Vishnu Nair9cf89262022-02-26 09:17:49 -0800186using CompositionStrategyPredictionState = android::compositionengine::impl::
187 OutputCompositionState::CompositionStrategyPredictionState;
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800188
Yiwei Zhang5434a782018-12-05 18:06:32 -0800189using base::StringAppendF;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700190using display::PhysicalDisplay;
191using display::PhysicalDisplays;
Vishnu Nairaf6d2972022-11-18 06:26:38 +0000192using frontend::TransactionHandler;
Prabir Pradhan48f8cb92021-08-26 14:05:36 -0700193using gui::DisplayInfo;
Huihong Luod3d8f8e2022-03-08 14:48:46 -0800194using gui::GameMode;
Huihong Luo6fac5232021-11-22 16:05:23 -0800195using gui::IDisplayEventConnection;
chaviw60c9d3e2021-06-04 12:52:17 -0500196using gui::IWindowInfosListener;
Huihong Luod3d8f8e2022-03-08 14:48:46 -0800197using gui::LayerMetadata;
chaviw98318de2021-05-19 16:45:23 -0500198using gui::WindowInfo;
Huihong Luo3bdef862022-03-03 11:57:19 -0800199using gui::aidl_utils::binderStatusFromStatusT;
Dominik Laskowski1c99a002023-01-20 17:10:36 -0500200using scheduler::VsyncModulator;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700201using ui::Dataspace;
Daniel Solomon42d04562019-01-20 21:03:19 -0800202using ui::DisplayPrimaries;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700203using ui::RenderIntent;
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900204
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400205using KernelIdleTimerController = scheduler::RefreshRateSelector::KernelIdleTimerController;
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800206
Peiyong Line9d809e2020-04-14 13:10:48 -0700207namespace hal = android::hardware::graphics::composer::hal;
208
Steven Thomasb02664d2017-07-26 18:48:28 -0700209namespace {
Peiyong Linfca547f2018-07-09 13:03:33 -0700210
Marc Kassisbdf7e4b2022-11-04 17:26:48 +0100211static constexpr int FOUR_K_WIDTH = 3840;
212static constexpr int FOUR_K_HEIGHT = 2160;
213
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100214// TODO(b/141333600): Consolidate with DisplayMode::Builder::getDefaultDensity.
Dominik Laskowskid125d0e2020-05-08 12:36:39 -0700215constexpr float FALLBACK_DENSITY = ACONFIGURATION_DENSITY_TV;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800216
Lloyd Pique30db6402023-06-26 18:56:51 +0000217float getDensityFromProperty(const char* property, bool required) {
218 char value[PROPERTY_VALUE_MAX];
219 const float density = property_get(property, value, nullptr) > 0 ? std::atof(value) : 0.f;
220 if (!density && required) {
221 ALOGE("%s must be defined as a build property", property);
222 return FALLBACK_DENSITY;
223 }
224 return density;
225}
226
Peiyong Lin9d846a52018-11-05 13:18:20 -0800227// Currently we only support V0_SRGB and DISPLAY_P3 as composition preference.
228bool validateCompositionDataspace(Dataspace dataspace) {
229 return dataspace == Dataspace::V0_SRGB || dataspace == Dataspace::DISPLAY_P3;
230}
231
ramindani32cf0602022-03-02 02:30:29 +0000232std::chrono::milliseconds getIdleTimerTimeout(DisplayId displayId) {
Ady Abraham6d885932021-09-03 18:05:48 -0700233 const auto displayIdleTimerMsKey = [displayId] {
234 std::stringstream ss;
235 ss << "debug.sf.set_idle_timer_ms_" << displayId.value;
236 return ss.str();
237 }();
238
ramindani32cf0602022-03-02 02:30:29 +0000239 const int32_t displayIdleTimerMs = base::GetIntProperty(displayIdleTimerMsKey, 0);
240 if (displayIdleTimerMs > 0) {
241 return std::chrono::milliseconds(displayIdleTimerMs);
242 }
243
244 const int32_t setIdleTimerMs = base::GetIntProperty("debug.sf.set_idle_timer_ms", 0);
245 const int32_t millis = setIdleTimerMs ? setIdleTimerMs : sysprop::set_idle_timer_ms(0);
246 return std::chrono::milliseconds(millis);
247}
248
249bool getKernelIdleTimerSyspropConfig(DisplayId displayId) {
Ady Abraham6d885932021-09-03 18:05:48 -0700250 const auto displaySupportKernelIdleTimerKey = [displayId] {
251 std::stringstream ss;
252 ss << "debug.sf.support_kernel_idle_timer_" << displayId.value;
253 return ss.str();
254 }();
255
Ady Abraham6d885932021-09-03 18:05:48 -0700256 const auto displaySupportKernelIdleTimer =
257 base::GetBoolProperty(displaySupportKernelIdleTimerKey, false);
ramindani32cf0602022-03-02 02:30:29 +0000258 return displaySupportKernelIdleTimer || sysprop::support_kernel_idle_timer(false);
Ady Abraham6d885932021-09-03 18:05:48 -0700259}
260
Marc Kassisbdf7e4b2022-11-04 17:26:48 +0100261bool isAbove4k30(const ui::DisplayMode& outMode) {
262 using fps_approx_ops::operator>;
263 Fps refreshRate = Fps::fromValue(outMode.refreshRate);
264 return outMode.resolution.getWidth() >= FOUR_K_WIDTH &&
265 outMode.resolution.getHeight() >= FOUR_K_HEIGHT && refreshRate > 30_Hz;
266}
267
268void excludeDolbyVisionIf4k30Present(const std::vector<ui::Hdr>& displayHdrTypes,
269 ui::DisplayMode& outMode) {
270 if (isAbove4k30(outMode) &&
271 std::any_of(displayHdrTypes.begin(), displayHdrTypes.end(),
272 [](ui::Hdr type) { return type == ui::Hdr::DOLBY_VISION_4K30; })) {
273 for (ui::Hdr type : displayHdrTypes) {
274 if (type != ui::Hdr::DOLBY_VISION_4K30 && type != ui::Hdr::DOLBY_VISION) {
275 outMode.supportedHdrTypes.push_back(type);
276 }
277 }
278 } else {
279 for (ui::Hdr type : displayHdrTypes) {
280 if (type != ui::Hdr::DOLBY_VISION_4K30) {
281 outMode.supportedHdrTypes.push_back(type);
282 }
283 }
284 }
285}
286
287HdrCapabilities filterOut4k30(const HdrCapabilities& displayHdrCapabilities) {
288 std::vector<ui::Hdr> hdrTypes;
289 for (ui::Hdr type : displayHdrCapabilities.getSupportedHdrTypes()) {
290 if (type != ui::Hdr::DOLBY_VISION_4K30) {
291 hdrTypes.push_back(type);
292 }
293 }
294 return {hdrTypes, displayHdrCapabilities.getDesiredMaxLuminance(),
295 displayHdrCapabilities.getDesiredMaxAverageLuminance(),
296 displayHdrCapabilities.getDesiredMinLuminance()};
297}
298
Vishnu Nair1391de22023-03-05 19:56:14 -0800299uint32_t getLayerIdFromSurfaceControl(sp<SurfaceControl> surfaceControl) {
300 if (!surfaceControl) {
301 return UNASSIGNED_LAYER_ID;
302 }
303 return LayerHandle::getLayerId(surfaceControl->getHandle());
304}
305
Steven Thomasb02664d2017-07-26 18:48:28 -0700306} // namespace anonymous
307
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800308// ---------------------------------------------------------------------------
309
Mathias Agopian99b49842011-06-27 16:05:52 -0700310const String16 sHardwareTest("android.permission.HARDWARE_TEST");
311const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER");
Hongwei Wang46213ea2020-12-04 17:17:31 -0800312const String16 sRotateSurfaceFlinger("android.permission.ROTATE_SURFACE_FLINGER");
Mathias Agopian99b49842011-06-27 16:05:52 -0700313const String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER");
John Reck88270902021-03-18 11:27:35 -0400314const String16 sControlDisplayBrightness("android.permission.CONTROL_DISPLAY_BRIGHTNESS");
Mathias Agopian99b49842011-06-27 16:05:52 -0700315const String16 sDump("android.permission.DUMP");
chaviwf5bb97b2021-04-28 15:35:37 -0500316const String16 sCaptureBlackoutContent("android.permission.CAPTURE_BLACKOUT_CONTENT");
Leon Scroggins9a20f722021-12-28 14:43:12 +0000317const String16 sInternalSystemWindow("android.permission.INTERNAL_SYSTEM_WINDOW");
Vishnu Nair884549f2022-12-01 17:20:59 -0800318const String16 sWakeupSurfaceFlinger("android.permission.WAKEUP_SURFACE_FLINGER");
chaviwf5bb97b2021-04-28 15:35:37 -0500319
Amy Hsuc8cdfef2020-05-07 13:06:25 +0800320const char* KERNEL_IDLE_TIMER_PROP = "graphics.display.kernel_idle_timer.enabled";
Mathias Agopian99b49842011-06-27 16:05:52 -0700321
Vishnu Nair4fb00ed2022-06-03 10:25:09 -0700322static const int MAX_TRACING_MEMORY = 1024 * 1024 * 1024; // 1GB
323
Mathias Agopian99b49842011-06-27 16:05:52 -0700324// ---------------------------------------------------------------------------
Lloyd Pique30db6402023-06-26 18:56:51 +0000325int64_t SurfaceFlinger::dispSyncPresentTimeOffset;
326bool SurfaceFlinger::useHwcForRgbToYuv;
327bool SurfaceFlinger::hasSyncFramework;
328int64_t SurfaceFlinger::maxFrameBufferAcquiredBuffers;
329int64_t SurfaceFlinger::minAcquiredBuffers = 1;
330uint32_t SurfaceFlinger::maxGraphicsWidth;
331uint32_t SurfaceFlinger::maxGraphicsHeight;
332bool SurfaceFlinger::useContextPriority;
333Dataspace SurfaceFlinger::defaultCompositionDataspace = Dataspace::V0_SRGB;
334ui::PixelFormat SurfaceFlinger::defaultCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
335Dataspace SurfaceFlinger::wideColorGamutCompositionDataspace = Dataspace::V0_SRGB;
336ui::PixelFormat SurfaceFlinger::wideColorGamutCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
ramindani4d48f902021-09-20 21:07:45 +0000337LatchUnsignaledConfig SurfaceFlinger::enableLatchUnsignaledConfig;
Mathias Agopian99b49842011-06-27 16:05:52 -0700338
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800339std::string decodeDisplayColorSetting(DisplayColorSetting displayColorSetting) {
340 switch(displayColorSetting) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800341 case DisplayColorSetting::kManaged:
Chia-I Wu0d711262018-05-21 15:19:35 -0700342 return std::string("Managed");
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800343 case DisplayColorSetting::kUnmanaged:
Chia-I Wu0d711262018-05-21 15:19:35 -0700344 return std::string("Unmanaged");
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800345 case DisplayColorSetting::kEnhanced:
Chia-I Wu0d711262018-05-21 15:19:35 -0700346 return std::string("Enhanced");
347 default:
348 return std::string("Unknown ") +
349 std::to_string(static_cast<int>(displayColorSetting));
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800350 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800351}
352
Vishnu Nair884549f2022-12-01 17:20:59 -0800353bool callingThreadHasPermission(const String16& permission) {
Hongwei Wang46213ea2020-12-04 17:17:31 -0800354 IPCThreadState* ipc = IPCThreadState::self();
355 const int pid = ipc->getCallingPid();
356 const int uid = ipc->getCallingUid();
357 return uid == AID_GRAPHICS || uid == AID_SYSTEM ||
Vishnu Nair884549f2022-12-01 17:20:59 -0800358 PermissionCache::checkPermission(permission, pid, uid);
Leon Scroggins9a20f722021-12-28 14:43:12 +0000359}
360
Leon Scroggins III85d4b222023-05-09 13:58:18 -0400361ui::Transform::RotationFlags SurfaceFlinger::sActiveDisplayRotationFlags = ui::Transform::ROT_0;
362
Lloyd Pique30db6402023-06-26 18:56:51 +0000363SurfaceFlinger::SurfaceFlinger(Factory& factory, SkipInitializationTag)
364 : mFactory(factory),
365 mPid(getpid()),
Yiwei Zhangf0229a72019-09-09 19:28:02 -0700366 mTimeStats(std::make_shared<impl::TimeStats>()),
Lloyd Pique30db6402023-06-26 18:56:51 +0000367 mFrameTracer(mFactory.createFrameTracer()),
368 mFrameTimeline(mFactory.createFrameTimeline(mTimeStats, mPid)),
369 mCompositionEngine(mFactory.createCompositionEngine()),
370 mHwcServiceName(base::GetProperty("debug.sf.hwc_service_name"s, "default"s)),
Ady Abrahamd11bade2022-08-01 16:18:03 -0700371 mTunnelModeEnabledReporter(sp<TunnelModeEnabledReporter>::make()),
Lloyd Pique30db6402023-06-26 18:56:51 +0000372 mEmulatedDisplayDensity(getDensityFromProperty("qemu.sf.lcd_density", false)),
373 mInternalDisplayDensity(
374 getDensityFromProperty("ro.sf.lcd_density", !mEmulatedDisplayDensity)),
Xiang Wang839fe5b2022-04-04 17:39:38 +0000375 mPowerAdvisor(std::make_unique<Hwc2::impl::PowerAdvisor>(*this)),
Patrick Williams641f7f22022-06-22 19:25:35 +0000376 mWindowInfosListenerInvoker(sp<WindowInfosListenerInvoker>::make()) {
Lloyd Pique30db6402023-06-26 18:56:51 +0000377 ALOGI("Using HWComposer service: %s", mHwcServiceName.c_str());
378}
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800379
Lloyd Pique30db6402023-06-26 18:56:51 +0000380SurfaceFlinger::SurfaceFlinger(Factory& factory) : SurfaceFlinger(factory, SkipInitialization) {
381 ATRACE_CALL();
382 ALOGI("SurfaceFlinger is starting");
383
384 hasSyncFramework = running_without_sync_framework(true);
385
386 dispSyncPresentTimeOffset = present_time_offset_from_vsync_ns(0);
387
388 useHwcForRgbToYuv = force_hwc_copy_for_virtual_displays(false);
389
390 maxFrameBufferAcquiredBuffers = max_frame_buffer_acquired_buffers(2);
391 minAcquiredBuffers =
392 SurfaceFlingerProperties::min_acquired_buffers().value_or(minAcquiredBuffers);
393
394 maxGraphicsWidth = std::max(max_graphics_width(0), 0);
395 maxGraphicsHeight = std::max(max_graphics_height(0), 0);
396
397 mSupportsWideColor = has_wide_color_display(false);
398 mDefaultCompositionDataspace =
399 static_cast<ui::Dataspace>(default_composition_dataspace(Dataspace::V0_SRGB));
400 mWideColorGamutCompositionDataspace = static_cast<ui::Dataspace>(wcg_composition_dataspace(
401 mSupportsWideColor ? Dataspace::DISPLAY_P3 : Dataspace::V0_SRGB));
402 defaultCompositionDataspace = mDefaultCompositionDataspace;
403 wideColorGamutCompositionDataspace = mWideColorGamutCompositionDataspace;
404 defaultCompositionPixelFormat = static_cast<ui::PixelFormat>(
405 default_composition_pixel_format(ui::PixelFormat::RGBA_8888));
406 wideColorGamutCompositionPixelFormat =
407 static_cast<ui::PixelFormat>(wcg_composition_pixel_format(ui::PixelFormat::RGBA_8888));
408
Lloyd Pique30db6402023-06-26 18:56:51 +0000409 mLayerCachingEnabled = [] {
410 const bool enable =
411 android::sysprop::SurfaceFlingerProperties::enable_layer_caching().value_or(false);
412 return base::GetBoolProperty(std::string("debug.sf.enable_layer_caching"), enable);
413 }();
414
415 useContextPriority = use_context_priority(true);
416
417 mInternalDisplayPrimaries = sysprop::getDisplayNativePrimaries();
418
419 // debugging stuff...
420 char value[PROPERTY_VALUE_MAX];
421
422 property_get("ro.build.type", value, "user");
423 mIsUserBuild = strcmp(value, "user") == 0;
424
425 mDebugFlashDelay = base::GetUintProperty("debug.sf.showupdates"s, 0u);
426
427 mBackpressureGpuComposition = base::GetBoolProperty("debug.sf.enable_gl_backpressure"s, true);
428 ALOGI_IF(mBackpressureGpuComposition, "Enabling backpressure for GPU composition");
429
430 property_get("ro.surface_flinger.supports_background_blur", value, "0");
431 bool supportsBlurs = atoi(value);
432 mSupportsBlur = supportsBlurs;
433 ALOGI_IF(!mSupportsBlur, "Disabling blur effects, they are not supported.");
434
435 const size_t defaultListSize = MAX_LAYERS;
436 auto listSize = property_get_int32("debug.sf.max_igbp_list_size", int32_t(defaultListSize));
437 mMaxGraphicBufferProducerListSize = (listSize > 0) ? size_t(listSize) : defaultListSize;
438 mGraphicBufferProducerListSizeLogThreshold =
439 std::max(static_cast<int>(0.95 *
440 static_cast<double>(mMaxGraphicBufferProducerListSize)),
441 1);
442
443 property_get("debug.sf.luma_sampling", value, "1");
444 mLumaSampling = atoi(value);
445
446 property_get("debug.sf.disable_client_composition_cache", value, "0");
447 mDisableClientCompositionCache = atoi(value);
448
449 property_get("debug.sf.predict_hwc_composition_strategy", value, "1");
450 mPredictCompositionStrategy = atoi(value);
451
452 property_get("debug.sf.treat_170m_as_sRGB", value, "0");
453 mTreat170mAsSrgb = atoi(value);
454
455 mIgnoreHwcPhysicalDisplayOrientation =
456 base::GetBoolProperty("debug.sf.ignore_hwc_physical_display_orientation"s, false);
457
458 // We should be reading 'persist.sys.sf.color_saturation' here
459 // but since /data may be encrypted, we need to wait until after vold
460 // comes online to attempt to read the property. The property is
461 // instead read after the boot animation
462
463 if (base::GetBoolProperty("debug.sf.treble_testing_override"s, false)) {
Kalle Raitaa099a242017-01-11 11:17:29 -0800464 // Without the override SurfaceFlinger cannot connect to HIDL
465 // services that are not listed in the manifests. Considered
466 // deriving the setting from the set service name, but it
467 // would be brittle if the name that's not 'default' is used
468 // for production purposes later on.
Lloyd Pique30db6402023-06-26 18:56:51 +0000469 ALOGI("Enabling Treble testing override");
Steven Moreland7c8af942020-07-08 18:35:51 +0000470 android::hardware::details::setTrebleTestingOverride(true);
Kalle Raitaa099a242017-01-11 11:17:29 -0800471 }
Ana Krulec3803b8d2020-02-03 16:35:46 -0800472
Lloyd Pique30db6402023-06-26 18:56:51 +0000473 // TODO (b/270966065) Update the HWC based refresh rate overlay to support spinner
474 mRefreshRateOverlaySpinner = property_get_bool("debug.sf.show_refresh_rate_overlay_spinner", 0);
475 mRefreshRateOverlayRenderRate =
476 property_get_bool("debug.sf.show_refresh_rate_overlay_render_rate", 0);
477 mRefreshRateOverlayShowInMiddle =
478 property_get_bool("debug.sf.show_refresh_rate_overlay_in_middle", 0);
479
480 if (!mIsUserBuild && base::GetBoolProperty("debug.sf.enable_transaction_tracing"s, true)) {
Dominik Laskowski46471e62022-01-14 15:34:03 -0800481 mTransactionTracing.emplace();
Vishnu Nair7891e962021-11-11 12:07:21 -0800482 }
Lloyd Pique30db6402023-06-26 18:56:51 +0000483
484 mIgnoreHdrCameraLayers = ignore_hdr_camera_layers(false);
485
486 mLayerLifecycleManagerEnabled =
Vishnu Nair2a9b1182023-08-08 16:14:02 +0000487 base::GetBoolProperty("persist.debug.sf.enable_layer_lifecycle_manager"s, false);
Lloyd Pique30db6402023-06-26 18:56:51 +0000488 mLegacyFrontEndEnabled = !mLayerLifecycleManagerEnabled ||
489 base::GetBoolProperty("persist.debug.sf.enable_legacy_frontend"s, false);
ramindani4d48f902021-09-20 21:07:45 +0000490}
491
492LatchUnsignaledConfig SurfaceFlinger::getLatchUnsignaledConfig() {
Ady Abrahamd9e8d1b2022-02-25 00:36:10 +0000493 if (base::GetBoolProperty("debug.sf.auto_latch_unsignaled"s, true)) {
Ady Abraham9dada822022-02-03 10:26:59 -0800494 return LatchUnsignaledConfig::AutoSingleLayer;
495 }
496
497 return LatchUnsignaledConfig::Disabled;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800498}
499
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700500SurfaceFlinger::~SurfaceFlinger() = default;
501
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700502void SurfaceFlinger::binderDied(const wp<IBinder>&) {
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800503 // the window manager died on us. prepare its eulogy.
Rob Carr2aa78cb2020-03-10 14:27:49 -0700504 mBootFinished = false;
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800505
Dominik Laskowskib5f40e52022-09-29 13:25:05 -0400506 static_cast<void>(mScheduler->schedule([this]() FTL_FAKE_GUARD(kMainThreadContext) {
507 // Sever the link to inputflinger since it's gone as well.
508 mInputFlinger.clear();
Vishnu Nairb9df4702021-03-01 11:53:15 -0800509
Dominik Laskowskib5f40e52022-09-29 13:25:05 -0400510 initializeDisplays();
511 }));
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800512
Mathias Agopiana67e4182012-06-19 17:26:12 -0700513 startBootAnim();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800514}
515
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700516void SurfaceFlinger::run() {
Dominik Laskowski756b7892021-08-04 12:53:59 -0700517 mScheduler->run();
Robert Carr1db73f62016-12-21 12:58:51 -0800518}
519
Huihong Luo1768cb02022-10-11 11:10:34 -0700520sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName, bool secure,
521 float requestedRefreshRate) {
chaviwd4a61642020-09-01 14:53:46 -0700522 // onTransact already checks for some permissions, but adding an additional check here.
523 // This is to ensure that only system and graphics can request to create a secure
524 // display. Secure displays can show secure content so we add an additional restriction on it.
525 const int uid = IPCThreadState::self()->getCallingUid();
526 if (secure && uid != AID_GRAPHICS && uid != AID_SYSTEM) {
527 ALOGE("Only privileged processes can create a secure display");
528 return nullptr;
529 }
530
Mathias Agopiane57f2922012-08-09 16:29:12 -0700531 class DisplayToken : public BBinder {
532 sp<SurfaceFlinger> flinger;
533 virtual ~DisplayToken() {
534 // no more references, this display must be terminated
535 Mutex::Autolock _l(flinger->mStateLock);
Ady Abrahamd11bade2022-08-01 16:18:03 -0700536 flinger->mCurrentState.displays.removeItem(wp<IBinder>::fromExisting(this));
Mathias Agopiane57f2922012-08-09 16:29:12 -0700537 flinger->setTransactionFlags(eDisplayTransactionNeeded);
538 }
539 public:
Chih-Hung Hsiehc4067912016-05-03 14:03:27 -0700540 explicit DisplayToken(const sp<SurfaceFlinger>& flinger)
Mathias Agopiane57f2922012-08-09 16:29:12 -0700541 : flinger(flinger) {
542 }
543 };
544
Ady Abrahamd11bade2022-08-01 16:18:03 -0700545 sp<BBinder> token = sp<DisplayToken>::make(sp<SurfaceFlinger>::fromExisting(this));
Mathias Agopiane57f2922012-08-09 16:29:12 -0700546
547 Mutex::Autolock _l(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700548 // Display ID is assigned when virtual display is allocated by HWC.
549 DisplayDeviceState state;
550 state.isSecure = secure;
551 state.displayName = displayName;
Huihong Luo1768cb02022-10-11 11:10:34 -0700552 state.requestedRefreshRate = Fps::fromValue(requestedRefreshRate);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700553 mCurrentState.displays.add(token, state);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700554 return token;
555}
556
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700557void SurfaceFlinger::destroyDisplay(const sp<IBinder>& displayToken) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700558 Mutex::Autolock lock(mStateLock);
Jesse Hall6c913be2013-08-08 12:15:49 -0700559
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700560 const ssize_t index = mCurrentState.displays.indexOfKey(displayToken);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700561 if (index < 0) {
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -0800562 ALOGE("%s: Invalid display token %p", __func__, displayToken.get());
Jesse Hall6c913be2013-08-08 12:15:49 -0700563 return;
564 }
565
Dominik Laskowski075d3172018-05-24 15:50:06 -0700566 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700567 if (state.physical) {
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -0800568 ALOGE("%s: Invalid operation on physical display", __func__);
Jesse Hall6c913be2013-08-08 12:15:49 -0700569 return;
570 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700571 mCurrentState.displays.removeItemsAt(index);
Jesse Hall6c913be2013-08-08 12:15:49 -0700572 setTransactionFlags(eDisplayTransactionNeeded);
573}
574
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800575void SurfaceFlinger::enableHalVirtualDisplays(bool enable) {
576 auto& generator = mVirtualDisplayIdGenerators.hal;
577 if (!generator && enable) {
578 ALOGI("Enabling HAL virtual displays");
579 generator.emplace(getHwComposer().getMaxVirtualDisplayCount());
580 } else if (generator && !enable) {
581 ALOGW_IF(generator->inUse(), "Disabling HAL virtual displays while in use");
582 generator.reset();
583 }
584}
585
Dominik Laskowski263eec42021-07-21 23:13:24 -0700586VirtualDisplayId SurfaceFlinger::acquireVirtualDisplay(ui::Size resolution,
587 ui::PixelFormat format) {
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800588 if (auto& generator = mVirtualDisplayIdGenerators.hal) {
589 if (const auto id = generator->generateId()) {
Dominik Laskowski263eec42021-07-21 23:13:24 -0700590 if (getHwComposer().allocateVirtualDisplay(*id, resolution, &format)) {
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800591 return *id;
592 }
593
594 generator->releaseId(*id);
595 } else {
596 ALOGW("%s: Exhausted HAL virtual displays", __func__);
597 }
598
599 ALOGW("%s: Falling back to GPU virtual display", __func__);
600 }
601
602 const auto id = mVirtualDisplayIdGenerators.gpu.generateId();
603 LOG_ALWAYS_FATAL_IF(!id, "Failed to generate ID for GPU virtual display");
604 return *id;
605}
606
607void SurfaceFlinger::releaseVirtualDisplay(VirtualDisplayId displayId) {
608 if (const auto id = HalVirtualDisplayId::tryCast(displayId)) {
609 if (auto& generator = mVirtualDisplayIdGenerators.hal) {
610 generator->releaseId(*id);
611 }
612 return;
613 }
614
615 const auto id = GpuVirtualDisplayId::tryCast(displayId);
616 LOG_ALWAYS_FATAL_IF(!id);
617 mVirtualDisplayIdGenerators.gpu.releaseId(*id);
618}
619
Ady Abrahamed3290f2021-05-17 15:12:14 -0700620std::vector<PhysicalDisplayId> SurfaceFlinger::getPhysicalDisplayIdsLocked() const {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800621 std::vector<PhysicalDisplayId> displayIds;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700622 displayIds.reserve(mPhysicalDisplays.size());
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700623
Dominik Laskowski3c363242022-04-07 10:44:12 -0700624 const auto defaultDisplayId = getDefaultDisplayDeviceLocked()->getPhysicalId();
Ady Abraham2a0066d2021-07-15 20:16:58 -0700625 displayIds.push_back(defaultDisplayId);
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800626
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700627 for (const auto& [id, display] : mPhysicalDisplays) {
Ady Abraham2a0066d2021-07-15 20:16:58 -0700628 if (id != defaultDisplayId) {
Marin Shalamanova524a092020-07-27 21:39:55 +0200629 displayIds.push_back(id);
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800630 }
Mathias Agopiane57f2922012-08-09 16:29:12 -0700631 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700632
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800633 return displayIds;
634}
635
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700636std::optional<PhysicalDisplayId> SurfaceFlinger::getPhysicalDisplayIdLocked(
637 const sp<display::DisplayToken>& displayToken) const {
638 return ftl::find_if(mPhysicalDisplays, PhysicalDisplay::hasToken(displayToken))
639 .transform(&ftl::to_key<PhysicalDisplays>);
640}
641
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800642sp<IBinder> SurfaceFlinger::getPhysicalDisplayToken(PhysicalDisplayId displayId) const {
643 Mutex::Autolock lock(mStateLock);
Marin Shalamanova524a092020-07-27 21:39:55 +0200644 return getPhysicalDisplayTokenLocked(displayId);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700645}
646
Ady Abraham37965d42018-11-01 13:43:32 -0700647status_t SurfaceFlinger::getColorManagement(bool* outGetColorManagement) const {
648 if (!outGetColorManagement) {
649 return BAD_VALUE;
650 }
651 *outGetColorManagement = useColorManagement;
652 return NO_ERROR;
Ady Abraham2a6ab2a2018-10-26 14:25:30 -0700653}
654
Lloyd Pique441d5042018-10-18 16:49:51 -0700655HWComposer& SurfaceFlinger::getHwComposer() const {
656 return mCompositionEngine->getHwComposer();
657}
658
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700659renderengine::RenderEngine& SurfaceFlinger::getRenderEngine() const {
Patrick Williams0a525a42022-10-26 20:20:50 +0000660 return *mRenderEngine;
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700661}
662
Lloyd Pique70d91362018-10-18 16:02:55 -0700663compositionengine::CompositionEngine& SurfaceFlinger::getCompositionEngine() const {
664 return *mCompositionEngine.get();
665}
666
Marin Shalamanov53fc11d2020-11-20 14:00:13 +0100667void SurfaceFlinger::bootFinished() {
Rob Carr2aa78cb2020-03-10 14:27:49 -0700668 if (mBootFinished == true) {
669 ALOGE("Extra call to bootFinished");
670 return;
671 }
672 mBootFinished = true;
Wei Wangf9b05ee2017-07-19 20:59:39 -0700673 if (mStartPropertySetThread->join() != NO_ERROR) {
674 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800675 }
Ady Abrahamfe2a6db2021-06-09 15:41:37 -0700676
677 if (mRenderEnginePrimeCacheFuture.valid()) {
678 mRenderEnginePrimeCacheFuture.get();
679 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800680 const nsecs_t now = systemTime();
681 const nsecs_t duration = now - mBootTime;
Steve Blocka19954a2012-01-04 20:05:49 +0000682 ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700683
Mikael Pessa90092f42019-08-26 17:22:04 -0700684 mFrameTracer->initialize();
Adithya Srinivasan01189672020-10-20 14:23:05 -0700685 mFrameTimeline->onBootFinished();
Robert Carr9b623c32022-03-21 15:55:22 -0700686 getRenderEngine().setEnableTracing(mFlagManager.use_skia_tracing());
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700687
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700688 // wait patiently for the window manager death
689 const String16 name("window");
Cody Heinerbcfa7fa2023-04-17 18:34:30 -0700690 mWindowManager = defaultServiceManager()->waitForService(name);
Steven Morelanda904bb92019-07-02 17:37:23 -0700691 if (mWindowManager != 0) {
Ady Abrahamd11bade2022-08-01 16:18:03 -0700692 mWindowManager->linkToDeath(sp<IBinder::DeathRecipient>::fromExisting(this));
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700693 }
694
695 // stop boot animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700696 // formerly we would just kill the process, but we now ask it to exit so it
697 // can choose where to stop the animation.
698 property_set("service.bootanim.exit", "1");
Yusuke Sato0a688f52015-07-30 23:05:39 -0700699
700 const int LOGTAG_SF_STOP_BOOTANIM = 60110;
701 LOG_EVENT_LONG(LOGTAG_SF_STOP_BOOTANIM,
702 ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
Romain Guy11d63f42017-07-20 12:47:14 -0700703
Cody Heinerbcfa7fa2023-04-17 18:34:30 -0700704 sp<IBinder> input(defaultServiceManager()->waitForService(String16("inputflinger")));
Denis Hsue70cc6c2020-06-17 10:17:30 +0800705
Dominik Laskowski02bb2072022-08-26 15:02:52 -0700706 static_cast<void>(mScheduler->schedule([=]() FTL_FAKE_GUARD(kMainThreadContext) {
Denis Hsue70cc6c2020-06-17 10:17:30 +0800707 if (input == nullptr) {
708 ALOGE("Failed to link to input service");
709 } else {
Chris Ye0783e992020-06-02 21:34:49 -0700710 mInputFlinger = interface_cast<os::IInputFlinger>(input);
Denis Hsue70cc6c2020-06-17 10:17:30 +0800711 }
712
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800713 readPersistentProperties();
Xiang Wang839fe5b2022-04-04 17:39:38 +0000714 mPowerAdvisor->onBootFinished();
Matt Buckley0538cae2022-11-08 23:12:04 +0000715 const bool hintSessionEnabled = mFlagManager.use_adpf_cpu_hint();
716 mPowerAdvisor->enablePowerHintSession(hintSessionEnabled);
717 const bool hintSessionUsed = mPowerAdvisor->usePowerHintSession();
Matt Buckley618c43f2022-08-12 18:09:48 +0000718 ALOGD("Power hint is %s",
Matt Buckley0538cae2022-11-08 23:12:04 +0000719 hintSessionUsed ? "supported" : (hintSessionEnabled ? "unsupported" : "disabled"));
720 if (hintSessionUsed) {
Matt Buckley618c43f2022-08-12 18:09:48 +0000721 std::optional<pid_t> renderEngineTid = getRenderEngine().getRenderEngineTid();
722 std::vector<int32_t> tidList;
723 tidList.emplace_back(gettid());
724 if (renderEngineTid.has_value()) {
725 tidList.emplace_back(*renderEngineTid);
726 }
727 if (!mPowerAdvisor->startPowerHintSession(tidList)) {
728 ALOGW("Cannot start power hint session");
Xiang Wange12b4fa2022-03-25 23:48:40 +0000729 }
Matt Buckleyef51fba2021-10-12 19:30:12 +0000730 }
731
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800732 mBootStage = BootStage::FINISHED;
Ana Krulecbd6654b2019-02-15 15:18:15 -0800733
Dominik Laskowski02bb2072022-08-26 15:02:52 -0700734 if (base::GetBoolProperty("sf.debug.show_refresh_rate_overlay"s, false)) {
735 ftl::FakeGuard guard(mStateLock);
736 enableRefreshRateOverlay(true);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800737 }
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800738 }));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800739}
740
Dan Stoza436ccf32018-06-21 12:10:12 -0700741uint32_t SurfaceFlinger::getNewTexture() {
742 {
743 std::lock_guard lock(mTexturePoolMutex);
744 if (!mTexturePool.empty()) {
745 uint32_t name = mTexturePool.back();
746 mTexturePool.pop_back();
747 ATRACE_INT("TexturePoolSize", mTexturePool.size());
748 return name;
749 }
750
751 // The pool was too small, so increase it for the future
752 ++mTexturePoolSize;
753 }
754
755 // The pool was empty, so we need to get a new texture name directly using a
756 // blocking call to the main thread
Robert Carrcdd7df92021-04-12 15:32:09 -0700757 auto genTextures = [this] {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700758 uint32_t name = 0;
759 getRenderEngine().genTextures(1, &name);
760 return name;
Robert Carrcdd7df92021-04-12 15:32:09 -0700761 };
762 if (std::this_thread::get_id() == mMainThreadId) {
763 return genTextures();
764 } else {
Dominik Laskowski756b7892021-08-04 12:53:59 -0700765 return mScheduler->schedule(genTextures).get();
Robert Carrcdd7df92021-04-12 15:32:09 -0700766 }
Dan Stoza436ccf32018-06-21 12:10:12 -0700767}
768
Mathias Agopian3f844832013-08-07 21:24:32 -0700769void SurfaceFlinger::deleteTextureAsync(uint32_t texture) {
Dan Stoza67765d82019-05-07 14:58:27 -0700770 std::lock_guard lock(mTexturePoolMutex);
771 // We don't change the pool size, so the fix-up logic in postComposition will decide whether
772 // to actually delete this or not based on mTexturePoolSize
773 mTexturePool.push_back(texture);
774 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700775}
776
Leon Scroggins IIIc77162c2021-11-16 17:13:08 -0500777static std::optional<renderengine::RenderEngine::RenderEngineType>
778chooseRenderEngineTypeViaSysProp() {
779 char prop[PROPERTY_VALUE_MAX];
780 property_get(PROPERTY_DEBUG_RENDERENGINE_BACKEND, prop, "");
781
782 if (strcmp(prop, "gles") == 0) {
783 return renderengine::RenderEngine::RenderEngineType::GLES;
784 } else if (strcmp(prop, "threaded") == 0) {
785 return renderengine::RenderEngine::RenderEngineType::THREADED;
786 } else if (strcmp(prop, "skiagl") == 0) {
787 return renderengine::RenderEngine::RenderEngineType::SKIA_GL;
788 } else if (strcmp(prop, "skiaglthreaded") == 0) {
789 return renderengine::RenderEngine::RenderEngineType::SKIA_GL_THREADED;
Ian Elliott1f0911e2022-09-09 16:31:47 -0600790 } else if (strcmp(prop, "skiavk") == 0) {
791 return renderengine::RenderEngine::RenderEngineType::SKIA_VK;
792 } else if (strcmp(prop, "skiavkthreaded") == 0) {
793 return renderengine::RenderEngine::RenderEngineType::SKIA_VK_THREADED;
Leon Scroggins IIIc77162c2021-11-16 17:13:08 -0500794 } else {
795 ALOGE("Unrecognized RenderEngineType %s; ignoring!", prop);
796 return {};
797 }
798}
799
Wei Wangf9b05ee2017-07-19 20:59:39 -0700800// Do not call property_set on main thread which will be blocked by init
801// Use StartPropertySetThread instead.
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700802void SurfaceFlinger::init() FTL_FAKE_GUARD(kMainThreadContext) {
Parth Sane343626c2023-04-06 16:17:04 +0000803 ATRACE_CALL();
Mathias Agopiana4912602012-07-12 14:25:33 -0700804 ALOGI( "SurfaceFlinger's main thread ready to run. "
805 "Initializing graphics H/W...");
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700806 addTransactionReadyFilters();
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700807 Mutex::Autolock lock(mStateLock);
Kevin DuBois413287f2019-02-25 08:46:47 -0800808
Steven Thomasb02664d2017-07-26 18:48:28 -0700809 // Get a RenderEngine for the given display / config (can't fail)
Peiyong Lin0256f722018-08-31 15:45:10 -0700810 // TODO(b/77156734): We need to stop casting and use HAL types when possible.
Alec Mourida4cf3b2019-02-12 15:33:01 -0800811 // Sending maxFrameBufferAcquiredBuffers as the cache size is tightly tuned to single-display.
Lloyd Pique30db6402023-06-26 18:56:51 +0000812 auto builder = renderengine::RenderEngineCreationArgs::Builder()
813 .setPixelFormat(static_cast<int32_t>(defaultCompositionPixelFormat))
814 .setImageCacheSize(maxFrameBufferAcquiredBuffers)
815 .setUseColorManagerment(useColorManagement)
816 .setEnableProtectedContext(enable_protected_contents(false))
817 .setPrecacheToneMapperShaderOnly(false)
818 .setSupportsBackgroundBlur(mSupportsBlur)
819 .setContextPriority(
820 useContextPriority
821 ? renderengine::RenderEngine::ContextPriority::REALTIME
822 : renderengine::RenderEngine::ContextPriority::MEDIUM);
Leon Scroggins IIIc77162c2021-11-16 17:13:08 -0500823 if (auto type = chooseRenderEngineTypeViaSysProp()) {
824 builder.setRenderEngineType(type.value());
825 }
Patrick Williams0a525a42022-10-26 20:20:50 +0000826 mRenderEngine = renderengine::RenderEngine::create(builder.build());
827 mCompositionEngine->setRenderEngine(mRenderEngine.get());
Garfield Tan9c9c1912021-07-19 12:02:16 -0700828 mMaxRenderTargetSize =
829 std::min(getRenderEngine().getMaxTextureSize(), getRenderEngine().getMaxViewportDims());
Wei Wang976a6452021-06-11 15:26:00 -0700830
831 // Set SF main policy after initializing RenderEngine which has its own policy.
832 if (!SetTaskProfiles(0, {"SFMainPolicy"})) {
833 ALOGW("Failed to set main task profile");
834 }
835
Alec Mourie4034bb2019-11-19 12:45:54 -0800836 mCompositionEngine->setTimeStats(mTimeStats);
Lloyd Pique30db6402023-06-26 18:56:51 +0000837 mCompositionEngine->setHwComposer(getFactory().createHWComposer(mHwcServiceName));
Yichi Chen3401b562022-01-17 15:42:35 +0800838 mCompositionEngine->getHwComposer().setCallback(*this);
Alec Mouria90a5702021-04-16 16:36:21 +0000839 ClientCache::getInstance().setRenderEngine(&getRenderEngine());
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800840
Ady Abraham9dada822022-02-03 10:26:59 -0800841 enableLatchUnsignaledConfig = getLatchUnsignaledConfig();
842
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800843 if (base::GetBoolProperty("debug.sf.enable_hwc_vds"s, false)) {
844 enableHalVirtualDisplays(true);
845 }
846
Dominik Laskowski68399272022-09-15 07:54:46 -0700847 // Process hotplug for displays connected at boot.
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700848 LOG_ALWAYS_FATAL_IF(!configureLocked(),
849 "Initial display configuration failed: HWC did not hotplug");
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700850
Dominik Laskowski68399272022-09-15 07:54:46 -0700851 // Commit primary display.
852 sp<const DisplayDevice> display;
853 if (const auto indexOpt = mCurrentState.getDisplayIndex(getPrimaryDisplayIdLocked())) {
854 const auto& displays = mCurrentState.displays;
855
856 const auto& token = displays.keyAt(*indexOpt);
857 const auto& state = displays.valueAt(*indexOpt);
858
859 processDisplayAdded(token, state);
860 mDrawingState.displays.add(token, state);
861
862 display = getDefaultDisplayDeviceLocked();
863 }
864
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700865 LOG_ALWAYS_FATAL_IF(!display, "Failed to configure the primary display");
866 LOG_ALWAYS_FATAL_IF(!getHwComposer().isConnected(display->getPhysicalId()),
867 "Primary display is disconnected");
Jesse Hall692c7232012-11-08 15:41:56 -0800868
Dominik Laskowski68399272022-09-15 07:54:46 -0700869 // TODO(b/241285876): The Scheduler needlessly depends on creating the CompositionEngine part of
870 // the DisplayDevice, hence the above commit of the primary display. Remove that special case by
871 // initializing the Scheduler after configureLocked, once decoupled from DisplayDevice.
872 initScheduler(display);
873 dispatchDisplayHotplugEvent(display->getPhysicalId(), true);
874
875 // Commit secondary display(s).
876 processDisplayChangesLocked();
877
Mathias Agopian92a979a2012-08-02 18:32:23 -0700878 // initialize our drawing state
879 mDrawingState = mCurrentState;
Mathias Agopian86303202012-07-24 22:46:10 -0700880
Dominik Laskowskia39e32f2023-02-08 16:40:13 -0500881 onActiveDisplayChangedLocked(nullptr, *display);
Dominik Laskowskib5f40e52022-09-29 13:25:05 -0400882
883 static_cast<void>(mScheduler->schedule(
884 [this]() FTL_FAKE_GUARD(kMainThreadContext) { initializeDisplays(); }));
Andy McFadden13a082e2012-08-24 10:16:42 -0700885
Xiang Wang839fe5b2022-04-04 17:39:38 +0000886 mPowerAdvisor->init();
Alec Mouridea1ac52021-06-23 18:12:18 -0700887
Steven Thomas137d4bc2019-07-25 16:55:14 -0700888 char primeShaderCache[PROPERTY_VALUE_MAX];
889 property_get("service.sf.prime_shader_cache", primeShaderCache, "1");
890 if (atoi(primeShaderCache)) {
Ady Abrahamfe2a6db2021-06-09 15:41:37 -0700891 if (setSchedFifo(false) != NO_ERROR) {
892 ALOGW("Can't set SCHED_OTHER for primeCache");
893 }
894
895 mRenderEnginePrimeCacheFuture = getRenderEngine().primeCache();
896
897 if (setSchedFifo(true) != NO_ERROR) {
898 ALOGW("Can't set SCHED_OTHER for primeCache");
899 }
Steven Thomas137d4bc2019-07-25 16:55:14 -0700900 }
Dan Stoza4e637772016-07-28 13:31:51 -0700901
Wei Wangf9b05ee2017-07-19 20:59:39 -0700902 // Inform native graphics APIs whether the present timestamp is supported:
Lloyd Pique90c115d2018-09-18 21:39:42 -0700903
904 const bool presentFenceReliable =
Ady Abrahamde549d42022-01-26 19:19:17 -0800905 !getHwComposer().hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE);
Lloyd Pique90c115d2018-09-18 21:39:42 -0700906 mStartPropertySetThread = getFactory().createStartPropertySetThread(presentFenceReliable);
Wei Wangf9b05ee2017-07-19 20:59:39 -0700907
908 if (mStartPropertySetThread->Start() != NO_ERROR) {
909 ALOGE("Run StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800910 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800911
Vishnu Naird1f74982023-06-15 20:16:51 -0700912 if (mTransactionTracing) {
913 TransactionTraceWriter::getInstance().setWriterFunction([&](const std::string& prefix,
914 bool overwrite) {
915 auto writeFn = [&]() {
916 const std::string filename =
917 TransactionTracing::DIR_NAME + prefix + TransactionTracing::FILE_NAME;
Vishnu Nair249fd7f2023-06-22 19:30:24 -0700918 if (overwrite && access(filename.c_str(), F_OK) == 0) {
919 ALOGD("TransactionTraceWriter: file=%s already exists", filename.c_str());
920 return;
Vishnu Naird1f74982023-06-15 20:16:51 -0700921 }
922 mTransactionTracing->flush();
923 mTransactionTracing->writeToFile(filename);
924 };
925 if (std::this_thread::get_id() == mMainThreadId) {
926 writeFn();
927 } else {
928 mScheduler->schedule(writeFn).get();
929 }
930 });
931 }
932
Dan Stoza9e56aa02015-11-02 13:00:03 -0800933 ALOGV("Done initializing");
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700934}
935
Romain Guy11d63f42017-07-20 12:47:14 -0700936void SurfaceFlinger::readPersistentProperties() {
Chia-I Wu28f320b2018-05-03 11:02:56 -0700937 Mutex::Autolock _l(mStateLock);
938
Romain Guy11d63f42017-07-20 12:47:14 -0700939 char value[PROPERTY_VALUE_MAX];
940
941 property_get("persist.sys.sf.color_saturation", value, "1.0");
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800942 mGlobalSaturationFactor = atof(value);
Chia-I Wu28f320b2018-05-03 11:02:56 -0700943 updateColorMatrixLocked();
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800944 ALOGV("Saturation is set to %.2f", mGlobalSaturationFactor);
Romain Guy54f154a2017-10-24 21:40:32 +0100945
946 property_get("persist.sys.sf.native_mode", value, "0");
Chia-I Wu0d711262018-05-21 15:19:35 -0700947 mDisplayColorSetting = static_cast<DisplayColorSetting>(atoi(value));
Peiyong Lina3ea5592019-02-10 14:45:00 -0800948
Dominik Laskowski788945b2022-08-30 12:10:56 -0700949 mForceColorMode =
950 static_cast<ui::ColorMode>(base::GetIntProperty("persist.sys.sf.color_mode"s, 0));
Romain Guy11d63f42017-07-20 12:47:14 -0700951}
952
Mathias Agopiana67e4182012-06-19 17:26:12 -0700953void SurfaceFlinger::startBootAnim() {
Wei Wangb254fa32017-01-31 17:43:23 -0800954 // Start boot animation service by setting a property mailbox
955 // if property setting thread is already running, Start() will be just a NOP
Wei Wangf9b05ee2017-07-19 20:59:39 -0700956 mStartPropertySetThread->Start();
Wei Wangb254fa32017-01-31 17:43:23 -0800957 // Wait until property was set
Wei Wangf9b05ee2017-07-19 20:59:39 -0700958 if (mStartPropertySetThread->join() != NO_ERROR) {
959 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800960 }
Mathias Agopiana67e4182012-06-19 17:26:12 -0700961}
962
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800963// ----------------------------------------------------------------------------
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800964
Brian Anderson6b376712017-04-04 10:51:39 -0700965status_t SurfaceFlinger::getSupportedFrameTimestamps(
966 std::vector<FrameEvent>* outSupported) const {
967 *outSupported = {
968 FrameEvent::REQUESTED_PRESENT,
969 FrameEvent::ACQUIRE,
970 FrameEvent::LATCH,
971 FrameEvent::FIRST_REFRESH_START,
972 FrameEvent::LAST_REFRESH_START,
973 FrameEvent::GPU_COMPOSITION_DONE,
974 FrameEvent::DEQUEUE_READY,
975 FrameEvent::RELEASE,
976 };
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800977
978 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
979
Ady Abrahamde549d42022-01-26 19:19:17 -0800980 if (!getHwComposer().hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
Brian Anderson6b376712017-04-04 10:51:39 -0700981 outSupported->push_back(FrameEvent::DISPLAY_PRESENT);
982 }
983 return NO_ERROR;
984}
985
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800986status_t SurfaceFlinger::getDisplayState(const sp<IBinder>& displayToken, ui::DisplayState* state) {
987 if (!displayToken || !state) {
988 return BAD_VALUE;
989 }
990
991 Mutex::Autolock lock(mStateLock);
992
993 const auto display = getDisplayDeviceLocked(displayToken);
994 if (!display) {
995 return NAME_NOT_FOUND;
996 }
997
998 state->layerStack = display->getLayerStack();
999 state->orientation = display->getOrientation();
1000
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02001001 const Rect layerStackRect = display->getLayerStackSpaceRect();
1002 state->layerStackSpaceRect =
1003 layerStackRect.isValid() ? layerStackRect.getSize() : display->getSize();
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001004
1005 return NO_ERROR;
1006}
1007
Sally Qi6bb12822022-10-05 11:42:30 -07001008status_t SurfaceFlinger::getStaticDisplayInfo(int64_t displayId, ui::StaticDisplayInfo* info) {
1009 if (!info) {
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001010 return BAD_VALUE;
1011 }
1012
1013 Mutex::Autolock lock(mStateLock);
Sally Qi6bb12822022-10-05 11:42:30 -07001014 const auto id = DisplayId::fromValue<PhysicalDisplayId>(static_cast<uint64_t>(displayId));
1015 const auto displayOpt = mPhysicalDisplays.get(*id).and_then(getDisplayDeviceAndSnapshot());
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001016
1017 if (!displayOpt) {
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001018 return NAME_NOT_FOUND;
1019 }
1020
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001021 const auto& [display, snapshotRef] = *displayOpt;
1022 const auto& snapshot = snapshotRef.get();
1023
1024 info->connectionType = snapshot.connectionType();
1025 info->deviceProductInfo = snapshot.deviceProductInfo();
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001026
Lloyd Pique30db6402023-06-26 18:56:51 +00001027 if (mEmulatedDisplayDensity) {
1028 info->density = mEmulatedDisplayDensity;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001029 } else {
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001030 info->density = info->connectionType == ui::DisplayConnectionType::Internal
Lloyd Pique30db6402023-06-26 18:56:51 +00001031 ? mInternalDisplayDensity
Dominik Laskowski55c85402020-01-21 16:25:47 -08001032 : FALLBACK_DENSITY;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001033 }
Dominik Laskowskid125d0e2020-05-08 12:36:39 -07001034 info->density /= ACONFIGURATION_DENSITY_MEDIUM;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001035
1036 info->secure = display->isSecure();
ramindani06e518e2022-03-14 18:47:53 +00001037 info->installOrientation = display->getPhysicalOrientation();
Vishnu Naird0a89652022-01-13 12:05:54 -08001038
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001039 return NO_ERROR;
1040}
1041
Sally Qi6bb12822022-10-05 11:42:30 -07001042void SurfaceFlinger::getDynamicDisplayInfoInternal(ui::DynamicDisplayInfo*& info,
1043 const sp<DisplayDevice>& display,
1044 const display::DisplaySnapshot& snapshot) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001045 const auto& displayModes = snapshot.displayModes();
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001046 info->supportedDisplayModes.clear();
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001047 info->supportedDisplayModes.reserve(displayModes.size());
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001048
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001049 for (const auto& [id, mode] : displayModes) {
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001050 ui::DisplayMode outMode;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001051 outMode.id = static_cast<int32_t>(id.value());
Dan Stoza7f7da322014-05-02 15:26:25 -07001052
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001053 auto [width, height] = mode->getResolution();
1054 auto [xDpi, yDpi] = mode->getDpi();
Yiwei Zhang27de5df2018-08-23 17:04:51 -07001055
ramindani06e518e2022-03-14 18:47:53 +00001056 if (const auto physicalOrientation = display->getPhysicalOrientation();
1057 physicalOrientation == ui::ROTATION_90 || physicalOrientation == ui::ROTATION_270) {
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001058 std::swap(width, height);
1059 std::swap(xDpi, yDpi);
Dan Stoza7f7da322014-05-02 15:26:25 -07001060 }
1061
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001062 outMode.resolution = ui::Size(width, height);
Ady Abraham2139f732019-11-13 18:56:40 -08001063
Huan Songf7eeb102022-03-28 11:02:38 -07001064 outMode.xDpi = xDpi;
1065 outMode.yDpi = yDpi;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001066
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001067 const nsecs_t period = mode->getVsyncPeriod();
1068 outMode.refreshRate = Fps::fromPeriodNsecs(period).getValue();
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001069
Ady Abraham8287e852020-08-12 14:44:58 -07001070 const auto vsyncConfigSet =
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001071 mVsyncConfiguration->getConfigsForRefreshRate(Fps::fromValue(outMode.refreshRate));
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001072 outMode.appVsyncOffset = vsyncConfigSet.late.appOffset;
1073 outMode.sfVsyncOffset = vsyncConfigSet.late.sfOffset;
1074 outMode.group = mode->getGroup();
Dan Stoza9e56aa02015-11-02 13:00:03 -08001075
Andy McFadden91b2ca82014-06-13 14:04:23 -07001076 // This is how far in advance a buffer must be queued for
1077 // presentation at a given time. If you want a buffer to appear
1078 // on the screen at time N, you must submit the buffer before
1079 // (N - presentationDeadline).
1080 //
1081 // Normally it's one full refresh period (to give SF a chance to
1082 // latch the buffer), but this can be reduced by configuring a
Ady Abraham8cb21882020-08-26 18:22:05 -07001083 // VsyncController offset. Any additional delays introduced by the hardware
Andy McFadden91b2ca82014-06-13 14:04:23 -07001084 // composer or panel must be accounted for here.
1085 //
1086 // We add an additional 1ms to allow for processing time and
1087 // differences between the ideal and actual refresh rate.
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001088 outMode.presentationDeadline = period - outMode.sfVsyncOffset + 1000000;
Marc Kassisbdf7e4b2022-11-04 17:26:48 +01001089 excludeDolbyVisionIf4k30Present(display->getHdrCapabilities().getSupportedHdrTypes(),
1090 outMode);
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001091 info->supportedDisplayModes.push_back(outMode);
Mathias Agopian8b736f12012-08-13 17:54:26 -07001092 }
1093
Lloyd Pique30db6402023-06-26 18:56:51 +00001094 info->supportedColorModes = snapshot.filterColorModes(mSupportsWideColor);
Dominik Laskowski788945b2022-08-30 12:10:56 -07001095
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001096 const PhysicalDisplayId displayId = snapshot.displayId();
1097
Ady Abraham67434eb2022-12-01 17:48:12 -08001098 const auto mode = display->refreshRateSelector().getActiveMode();
1099 info->activeDisplayModeId = mode.modePtr->getId().value();
1100 info->renderFrameRate = mode.fps.getValue();
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001101 info->activeColorMode = display->getCompositionDisplay()->getState().colorMode;
Marc Kassisbdf7e4b2022-11-04 17:26:48 +01001102 info->hdrCapabilities = filterOut4k30(display->getHdrCapabilities());
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001103
Marin Shalamanovb173f752021-02-16 19:38:36 +01001104 info->autoLowLatencyModeSupported =
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001105 getHwComposer().hasDisplayCapability(displayId,
Leon Scroggins III5967aec2021-12-29 11:14:22 -05001106 DisplayCapability::AUTO_LOW_LATENCY_MODE);
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001107 info->gameContentTypeSupported =
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001108 getHwComposer().supportsContentType(displayId, hal::ContentType::GAME);
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001109
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001110 info->preferredBootDisplayMode = static_cast<ui::DisplayModeId>(-1);
Kriti Dangac0a74d2022-03-16 11:52:35 +01001111
1112 if (getHwComposer().hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001113 if (const auto hwcId = getHwComposer().getPreferredBootDisplayMode(displayId)) {
1114 if (const auto modeId = snapshot.translateModeId(*hwcId)) {
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001115 info->preferredBootDisplayMode = modeId->value();
1116 }
1117 }
1118 }
Sally Qi6bb12822022-10-05 11:42:30 -07001119}
Kriti Dang646f8ec2022-01-18 14:35:02 +01001120
Sally Qi6bb12822022-10-05 11:42:30 -07001121status_t SurfaceFlinger::getDynamicDisplayInfoFromId(int64_t physicalDisplayId,
1122 ui::DynamicDisplayInfo* info) {
1123 if (!info) {
1124 return BAD_VALUE;
1125 }
1126
1127 Mutex::Autolock lock(mStateLock);
1128
1129 const auto id_ =
1130 DisplayId::fromValue<PhysicalDisplayId>(static_cast<uint64_t>(physicalDisplayId));
1131 const auto displayOpt = mPhysicalDisplays.get(*id_).and_then(getDisplayDeviceAndSnapshot());
1132
1133 if (!displayOpt) {
1134 return NAME_NOT_FOUND;
1135 }
1136
1137 const auto& [display, snapshotRef] = *displayOpt;
1138 getDynamicDisplayInfoInternal(info, display, snapshotRef.get());
1139 return NO_ERROR;
1140}
1141
1142status_t SurfaceFlinger::getDynamicDisplayInfoFromToken(const sp<IBinder>& displayToken,
1143 ui::DynamicDisplayInfo* info) {
1144 if (!displayToken || !info) {
1145 return BAD_VALUE;
1146 }
1147
1148 Mutex::Autolock lock(mStateLock);
1149
1150 const auto displayOpt = ftl::find_if(mPhysicalDisplays, PhysicalDisplay::hasToken(displayToken))
1151 .transform(&ftl::to_mapped_ref<PhysicalDisplays>)
1152 .and_then(getDisplayDeviceAndSnapshot());
1153
1154 if (!displayOpt) {
1155 return NAME_NOT_FOUND;
1156 }
1157
1158 const auto& [display, snapshotRef] = *displayOpt;
1159 getDynamicDisplayInfoInternal(info, display, snapshotRef.get());
Dan Stoza7f7da322014-05-02 15:26:25 -07001160 return NO_ERROR;
1161}
Jamie Gennisdd3cb842012-10-19 18:19:11 -07001162
Leon Scroggins III67388622023-02-06 20:36:20 -05001163status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>& displayToken,
1164 DisplayStatInfo* outStats) {
Dominik Laskowski5d164f22022-07-07 07:56:07 -07001165 if (!outStats) {
Lajos Molnar67d8bd62014-09-11 14:58:45 -07001166 return BAD_VALUE;
1167 }
1168
Leon Scroggins III67388622023-02-06 20:36:20 -05001169 std::optional<PhysicalDisplayId> displayIdOpt;
1170 {
1171 Mutex::Autolock lock(mStateLock);
Leon Scroggins III4235ea02023-04-17 15:14:20 -04001172 if (displayToken) {
1173 displayIdOpt = getPhysicalDisplayIdLocked(displayToken);
1174 if (!displayIdOpt) {
1175 ALOGW("%s: Invalid physical display token %p", __func__, displayToken.get());
1176 return NAME_NOT_FOUND;
1177 }
1178 } else {
1179 // TODO (b/277364366): Clients should be updated to pass in the display they
1180 // want, rather than us picking an arbitrary one (the active display, in this
1181 // case).
1182 displayIdOpt = mActiveDisplayId;
1183 }
Leon Scroggins III67388622023-02-06 20:36:20 -05001184 }
1185
Leon Scroggins III4235ea02023-04-17 15:14:20 -04001186 const auto schedule = mScheduler->getVsyncSchedule(displayIdOpt);
1187 if (!schedule) {
1188 ALOGE("%s: Missing VSYNC schedule for display %s!", __func__,
1189 to_string(*displayIdOpt).c_str());
Leon Scroggins III67388622023-02-06 20:36:20 -05001190 return NAME_NOT_FOUND;
1191 }
Leon Scroggins III67388622023-02-06 20:36:20 -05001192 outStats->vsyncTime = schedule->vsyncDeadlineAfter(TimePoint::now()).ns();
1193 outStats->vsyncPeriod = schedule->period().ns();
Lajos Molnar67d8bd62014-09-11 14:58:45 -07001194 return NO_ERROR;
1195}
1196
Dominik Laskowskifc378b02022-12-02 14:56:05 -05001197void SurfaceFlinger::setDesiredActiveMode(display::DisplayModeRequest&& request, bool force) {
Leon Scroggins III67388622023-02-06 20:36:20 -05001198 const auto displayId = request.mode.modePtr->getPhysicalDisplayId();
Dominik Laskowskifdac5652023-06-29 12:01:13 -04001199 ATRACE_NAME(ftl::Concat(__func__, ' ', displayId.value).c_str());
1200
Leon Scroggins III67388622023-02-06 20:36:20 -05001201 const auto display = getDisplayDeviceLocked(displayId);
Ady Abraham3efa3942021-06-24 19:01:25 -07001202 if (!display) {
Ady Abraham690f4612021-07-01 23:24:03 -07001203 ALOGW("%s: display is no longer valid", __func__);
Ady Abraham3efa3942021-06-24 19:01:25 -07001204 return;
1205 }
1206
Ady Abraham67434eb2022-12-01 17:48:12 -08001207 const auto mode = request.mode;
1208 const bool emitEvent = request.emitEvent;
Dominik Laskowski530d6bd2022-10-10 16:55:54 -04001209
Dominik Laskowskifc378b02022-12-02 14:56:05 -05001210 switch (display->setDesiredActiveMode(DisplayDevice::ActiveModeInfo(std::move(request)),
1211 force)) {
Ady Abrahamace3d052022-11-17 16:25:05 -08001212 case DisplayDevice::DesiredActiveModeAction::InitiateDisplayModeSwitch:
Ady Abraham95a37e22023-01-18 22:57:28 -08001213 // Set the render rate as setDesiredActiveMode updated it.
Leon Scroggins III67388622023-02-06 20:36:20 -05001214 mScheduler->setRenderRate(displayId,
1215 display->refreshRateSelector().getActiveMode().fps);
Ady Abraham95a37e22023-01-18 22:57:28 -08001216
1217 // Schedule a new frame to initiate the display mode switch.
Ady Abrahamace3d052022-11-17 16:25:05 -08001218 scheduleComposite(FrameHint::kNone);
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001219
Ady Abrahamace3d052022-11-17 16:25:05 -08001220 // Start receiving vsync samples now, so that we can detect a period
1221 // switch.
Leon Scroggins III67388622023-02-06 20:36:20 -05001222 mScheduler->resyncToHardwareVsync(displayId, true /* allowToEnable */,
1223 mode.modePtr->getFps());
1224
Ady Abrahamace3d052022-11-17 16:25:05 -08001225 // As we called to set period, we will call to onRefreshRateChangeCompleted once
1226 // VsyncController model is locked.
Leon Scroggins III67388622023-02-06 20:36:20 -05001227 mScheduler->modulateVsync(displayId, &VsyncModulator::onRefreshRateChangeInitiated);
Dominik Laskowskifdac5652023-06-29 12:01:13 -04001228
1229 if (displayId == mActiveDisplayId) {
1230 updatePhaseConfiguration(mode.fps);
1231 }
1232
Ady Abrahamace3d052022-11-17 16:25:05 -08001233 mScheduler->setModeChangePending(true);
1234 break;
1235 case DisplayDevice::DesiredActiveModeAction::InitiateRenderRateSwitch:
Leon Scroggins III67388622023-02-06 20:36:20 -05001236 mScheduler->setRenderRate(displayId, mode.fps);
Dominik Laskowskifdac5652023-06-29 12:01:13 -04001237
1238 if (displayId == mActiveDisplayId) {
1239 updatePhaseConfiguration(mode.fps);
1240 mRefreshRateStats->setRefreshRate(mode.fps);
Ady Abraham67434eb2022-12-01 17:48:12 -08001241 }
Ady Abrahamace3d052022-11-17 16:25:05 -08001242
Dominik Laskowskifdac5652023-06-29 12:01:13 -04001243 if (emitEvent) {
1244 dispatchDisplayModeChangeEvent(displayId, mode);
1245 }
Ady Abrahamace3d052022-11-17 16:25:05 -08001246 break;
1247 case DisplayDevice::DesiredActiveModeAction::None:
1248 break;
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001249 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001250}
1251
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001252status_t SurfaceFlinger::setActiveModeFromBackdoor(const sp<display::DisplayToken>& displayToken,
1253 DisplayModeId modeId) {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001254 ATRACE_CALL();
Ady Abraham838de062019-02-04 10:24:03 -08001255
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001256 if (!displayToken) {
1257 return BAD_VALUE;
1258 }
Ady Abraham838de062019-02-04 10:24:03 -08001259
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001260 const char* const whence = __func__;
Dominik Laskowski36dced82022-09-02 09:24:00 -07001261 auto future = mScheduler->schedule([=]() FTL_FAKE_GUARD(kMainThreadContext) -> status_t {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001262 const auto displayOpt =
1263 FTL_FAKE_GUARD(mStateLock,
1264 ftl::find_if(mPhysicalDisplays,
1265 PhysicalDisplay::hasToken(displayToken))
1266 .transform(&ftl::to_mapped_ref<PhysicalDisplays>)
1267 .and_then(getDisplayDeviceAndSnapshot()));
1268 if (!displayOpt) {
1269 ALOGE("%s: Invalid physical display token %p", whence, displayToken.get());
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001270 return NAME_NOT_FOUND;
Marin Shalamanov5801c942020-12-17 17:00:13 +01001271 }
1272
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001273 const auto& [display, snapshotRef] = *displayOpt;
1274 const auto& snapshot = snapshotRef.get();
Marin Shalamanov5801c942020-12-17 17:00:13 +01001275
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001276 const auto fpsOpt = snapshot.displayModes().get(modeId).transform(
1277 [](const DisplayModePtr& mode) { return mode->getFps(); });
1278
1279 if (!fpsOpt) {
1280 ALOGE("%s: Invalid mode %d for display %s", whence, modeId.value(),
1281 to_string(snapshot.displayId()).c_str());
Marin Shalamanov5801c942020-12-17 17:00:13 +01001282 return BAD_VALUE;
1283 }
1284
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001285 const Fps fps = *fpsOpt;
Dominik Laskowski36dced82022-09-02 09:24:00 -07001286
Marin Shalamanov5801c942020-12-17 17:00:13 +01001287 // Keep the old switching type.
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001288 const bool allowGroupSwitching =
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001289 display->refreshRateSelector().getCurrentPolicy().allowGroupSwitching;
Marin Shalamanov5801c942020-12-17 17:00:13 +01001290
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001291 const scheduler::RefreshRateSelector::DisplayManagerPolicy policy{modeId,
Ady Abraham285f8c12022-10-11 17:12:14 -07001292 {fps, fps},
1293 allowGroupSwitching};
Dominik Laskowski36dced82022-09-02 09:24:00 -07001294
1295 return setDesiredDisplayModeSpecsInternal(display, policy);
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001296 });
1297
1298 return future.get();
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001299}
1300
Dominik Laskowskifdac5652023-06-29 12:01:13 -04001301void SurfaceFlinger::finalizeDisplayModeChange(DisplayDevice& display) {
1302 const auto displayId = display.getPhysicalId();
1303 ATRACE_NAME(ftl::Concat(__func__, ' ', displayId.value).c_str());
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001304
Dominik Laskowskifdac5652023-06-29 12:01:13 -04001305 const auto upcomingModeInfo = display.getUpcomingActiveMode();
Ady Abrahamace3d052022-11-17 16:25:05 -08001306 if (!upcomingModeInfo.modeOpt) {
Ady Abrahamfaac6da2021-07-15 10:04:40 -07001307 // There is no pending mode change. This can happen if the active
1308 // display changed and the mode change happened on a different display.
1309 return;
1310 }
1311
Dominik Laskowskifdac5652023-06-29 12:01:13 -04001312 if (display.getActiveMode().modePtr->getResolution() !=
Ady Abrahamace3d052022-11-17 16:25:05 -08001313 upcomingModeInfo.modeOpt->modePtr->getResolution()) {
Dominik Laskowskifdac5652023-06-29 12:01:13 -04001314 auto& state = mCurrentState.displays.editValueFor(display.getDisplayToken());
Marin Shalamanov993ddf42021-05-26 16:54:40 +02001315 // We need to generate new sequenceId in order to recreate the display (and this
1316 // way the framebuffer).
1317 state.sequenceId = DisplayDeviceState{}.sequenceId;
Ady Abrahamace3d052022-11-17 16:25:05 -08001318 state.physical->activeMode = upcomingModeInfo.modeOpt->modePtr.get();
Marin Shalamanov993ddf42021-05-26 16:54:40 +02001319 processDisplayChangesLocked();
1320
1321 // processDisplayChangesLocked will update all necessary components so we're done here.
1322 return;
1323 }
Alec Mouri8de697e2020-03-19 10:52:01 -07001324
Dominik Laskowskifdac5652023-06-29 12:01:13 -04001325 const auto& activeMode = *upcomingModeInfo.modeOpt;
1326 display.finalizeModeChange(activeMode.modePtr->getId(), activeMode.modePtr->getFps(),
1327 activeMode.fps);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001328
Dominik Laskowskifdac5652023-06-29 12:01:13 -04001329 if (displayId == mActiveDisplayId) {
1330 mRefreshRateStats->setRefreshRate(activeMode.fps);
1331 updatePhaseConfiguration(activeMode.fps);
1332 }
Dominik Laskowski22488f62019-03-28 09:53:04 -07001333
Dominik Laskowski530d6bd2022-10-10 16:55:54 -04001334 if (upcomingModeInfo.event != scheduler::DisplayModeEvent::None) {
Dominik Laskowskifdac5652023-06-29 12:01:13 -04001335 dispatchDisplayModeChangeEvent(displayId, activeMode);
Ady Abraham447052e2019-02-13 16:07:27 -08001336 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001337}
1338
Ady Abraham690f4612021-07-01 23:24:03 -07001339void SurfaceFlinger::clearDesiredActiveModeState(const sp<DisplayDevice>& display) {
1340 display->clearDesiredActiveModeState();
Dominik Laskowskie591b552022-09-09 10:44:56 -07001341 if (display->getPhysicalId() == mActiveDisplayId) {
Dominik Laskowskifdac5652023-06-29 12:01:13 -04001342 // TODO(b/255635711): Check for pending mode changes on other displays.
Ady Abraham690f4612021-07-01 23:24:03 -07001343 mScheduler->setModeChangePending(false);
1344 }
Ady Abraham53852a52019-05-28 18:07:44 -07001345}
1346
Ady Abraham690f4612021-07-01 23:24:03 -07001347void SurfaceFlinger::desiredActiveModeChangeDone(const sp<DisplayDevice>& display) {
Leon Scroggins III67388622023-02-06 20:36:20 -05001348 const auto desiredActiveMode = display->getDesiredActiveMode();
1349 const auto& modeOpt = desiredActiveMode->modeOpt;
1350 const auto displayId = modeOpt->modePtr->getPhysicalDisplayId();
1351 const auto displayFps = modeOpt->modePtr->getFps();
1352 const auto renderFps = modeOpt->fps;
Ady Abraham690f4612021-07-01 23:24:03 -07001353 clearDesiredActiveModeState(display);
Leon Scroggins III67388622023-02-06 20:36:20 -05001354 mScheduler->resyncToHardwareVsync(displayId, true /* allowToEnable */, displayFps);
1355 mScheduler->setRenderRate(displayId, renderFps);
Dominik Laskowskifdac5652023-06-29 12:01:13 -04001356
1357 if (displayId == mActiveDisplayId) {
1358 updatePhaseConfiguration(renderFps);
1359 }
Marin Shalamanov5801c942020-12-17 17:00:13 +01001360}
1361
Dominik Laskowskifdac5652023-06-29 12:01:13 -04001362void SurfaceFlinger::initiateDisplayModeChanges() {
Alec Mourife3dc942019-02-12 14:19:18 -08001363 ATRACE_CALL();
Ady Abraham690f4612021-07-01 23:24:03 -07001364
Marin Shalamanovdd594312021-11-09 16:37:37 +01001365 std::optional<PhysicalDisplayId> displayToUpdateImmediately;
1366
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001367 for (const auto& [id, physical] : mPhysicalDisplays) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001368 const auto display = getDisplayDeviceLocked(id);
1369 if (!display) continue;
1370
Ady Abraham690f4612021-07-01 23:24:03 -07001371 // Store the local variable to release the lock.
1372 const auto desiredActiveMode = display->getDesiredActiveMode();
1373 if (!desiredActiveMode) {
Dominik Laskowskie591b552022-09-09 10:44:56 -07001374 // No desired active mode pending to be applied.
Ady Abraham690f4612021-07-01 23:24:03 -07001375 continue;
1376 }
1377
Dominik Laskowskifdac5652023-06-29 12:01:13 -04001378 if (!display->isPoweredOn()) {
1379 // Display is no longer powered on, so abort the mode change.
Ady Abraham690f4612021-07-01 23:24:03 -07001380 clearDesiredActiveModeState(display);
1381 continue;
1382 }
1383
Ady Abrahamace3d052022-11-17 16:25:05 -08001384 const auto desiredModeId = desiredActiveMode->modeOpt->modePtr->getId();
Dominik Laskowskifdac5652023-06-29 12:01:13 -04001385 const auto displayModePtrOpt = physical.snapshot().displayModes().get(desiredModeId);
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001386
Ady Abrahamace3d052022-11-17 16:25:05 -08001387 if (!displayModePtrOpt) {
Ady Abraham690f4612021-07-01 23:24:03 -07001388 ALOGW("Desired display mode is no longer supported. Mode ID = %d",
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001389 desiredModeId.value());
Ady Abraham690f4612021-07-01 23:24:03 -07001390 clearDesiredActiveModeState(display);
1391 continue;
1392 }
1393
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001394 ALOGV("%s changing active mode to %d(%s) for display %s", __func__, desiredModeId.value(),
Ady Abrahamace3d052022-11-17 16:25:05 -08001395 to_string(displayModePtrOpt->get()->getFps()).c_str(),
1396 to_string(display->getId()).c_str());
Ady Abraham690f4612021-07-01 23:24:03 -07001397
Ady Abrahamace3d052022-11-17 16:25:05 -08001398 if (display->getActiveMode() == desiredActiveMode->modeOpt) {
Marin Shalamanov85b2bdf2021-11-03 14:31:21 +01001399 // we are already in the requested mode, there is nothing left to do
Ady Abraham690f4612021-07-01 23:24:03 -07001400 desiredActiveModeChangeDone(display);
1401 continue;
1402 }
1403
1404 // Desired active mode was set, it is different than the mode currently in use, however
1405 // allowed modes might have changed by the time we process the refresh.
1406 // Make sure the desired mode is still allowed
Ady Abrahamace3d052022-11-17 16:25:05 -08001407 const auto displayModeAllowed =
1408 display->refreshRateSelector().isModeAllowed(*desiredActiveMode->modeOpt);
Ady Abraham690f4612021-07-01 23:24:03 -07001409 if (!displayModeAllowed) {
Marin Shalamanovdd00c002021-11-04 16:54:38 +01001410 clearDesiredActiveModeState(display);
Ady Abraham690f4612021-07-01 23:24:03 -07001411 continue;
1412 }
1413
1414 // TODO(b/142753666) use constrains
1415 hal::VsyncPeriodChangeConstraints constraints;
1416 constraints.desiredTimeNanos = systemTime();
1417 constraints.seamlessRequired = false;
1418 hal::VsyncPeriodChangeTimeline outTimeline;
1419
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001420 const auto status =
1421 display->initiateModeChange(*desiredActiveMode, constraints, &outTimeline);
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001422
Ady Abraham690f4612021-07-01 23:24:03 -07001423 if (status != NO_ERROR) {
1424 // initiateModeChange may fail if a hotplug event is just about
1425 // to be sent. We just log the error in this case.
1426 ALOGW("initiateModeChange failed: %d", status);
1427 continue;
1428 }
Dominik Laskowski36dced82022-09-02 09:24:00 -07001429
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001430 display->refreshRateSelector().onModeChangeInitiated();
Ady Abraham690f4612021-07-01 23:24:03 -07001431 mScheduler->onNewVsyncPeriodChangeTimeline(outTimeline);
1432
Marin Shalamanovdd594312021-11-09 16:37:37 +01001433 if (outTimeline.refreshRequired) {
Dominik Laskowskidd5827a2022-03-17 12:44:23 -07001434 scheduleComposite(FrameHint::kNone);
Marin Shalamanovdd594312021-11-09 16:37:37 +01001435 } else {
Dominik Laskowskifdac5652023-06-29 12:01:13 -04001436 // TODO(b/255635711): Remove `displayToUpdateImmediately` to `finalizeDisplayModeChange`
1437 // for all displays. This was only needed when the loop iterated over `mDisplays` rather
1438 // than `mPhysicalDisplays`.
Marin Shalamanovdd594312021-11-09 16:37:37 +01001439 displayToUpdateImmediately = display->getPhysicalId();
1440 }
1441 }
1442
1443 if (displayToUpdateImmediately) {
Marin Shalamanovdd594312021-11-09 16:37:37 +01001444 const auto display = getDisplayDeviceLocked(*displayToUpdateImmediately);
Dominik Laskowskifdac5652023-06-29 12:01:13 -04001445 finalizeDisplayModeChange(*display);
1446
Marin Shalamanovdd594312021-11-09 16:37:37 +01001447 const auto desiredActiveMode = display->getDesiredActiveMode();
Ady Abrahamace3d052022-11-17 16:25:05 -08001448 if (desiredActiveMode && display->getActiveMode() == desiredActiveMode->modeOpt) {
Marin Shalamanovdd594312021-11-09 16:37:37 +01001449 desiredActiveModeChangeDone(display);
1450 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001451 }
Mathias Agopianc666cae2012-07-25 18:56:13 -07001452}
Dominik Laskowski075d3172018-05-24 15:50:06 -07001453
Alec Mouridea1ac52021-06-23 18:12:18 -07001454void SurfaceFlinger::disableExpensiveRendering() {
Dominik Laskowski4d5052d2022-03-23 10:35:47 -07001455 const char* const whence = __func__;
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001456 auto future = mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) {
Dominik Laskowski4d5052d2022-03-23 10:35:47 -07001457 ATRACE_NAME(whence);
Xiang Wang839fe5b2022-04-04 17:39:38 +00001458 if (mPowerAdvisor->isUsingExpensiveRendering()) {
Dominik Laskowskibc6c8602022-01-11 08:53:24 -08001459 for (const auto& [_, display] : mDisplays) {
1460 constexpr bool kDisable = false;
Xiang Wang839fe5b2022-04-04 17:39:38 +00001461 mPowerAdvisor->setExpensiveRenderingExpected(display->getId(), kDisable);
Alec Mouridea1ac52021-06-23 18:12:18 -07001462 }
1463 }
Dominik Laskowski756b7892021-08-04 12:53:59 -07001464 });
1465
1466 future.wait();
Alec Mouridea1ac52021-06-23 18:12:18 -07001467}
1468
Daniel Solomon42d04562019-01-20 21:03:19 -08001469status_t SurfaceFlinger::getDisplayNativePrimaries(const sp<IBinder>& displayToken,
Dominik Laskowski3c363242022-04-07 10:44:12 -07001470 ui::DisplayPrimaries& primaries) {
Daniel Solomon42d04562019-01-20 21:03:19 -08001471 if (!displayToken) {
1472 return BAD_VALUE;
1473 }
1474
Dominik Laskowski3c363242022-04-07 10:44:12 -07001475 Mutex::Autolock lock(mStateLock);
1476
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001477 const auto display = ftl::find_if(mPhysicalDisplays, PhysicalDisplay::hasToken(displayToken))
1478 .transform(&ftl::to_mapped_ref<PhysicalDisplays>);
Dominik Laskowski3c363242022-04-07 10:44:12 -07001479 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001480 return NAME_NOT_FOUND;
Daniel Solomon42d04562019-01-20 21:03:19 -08001481 }
1482
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001483 if (!display.transform(&PhysicalDisplay::isInternal).value()) {
Dominik Laskowski3c363242022-04-07 10:44:12 -07001484 return INVALID_OPERATION;
1485 }
1486
1487 // TODO(b/229846990): For now, assume that all internal displays have the same primaries.
Lloyd Pique30db6402023-06-26 18:56:51 +00001488 primaries = mInternalDisplayPrimaries;
Daniel Solomon42d04562019-01-20 21:03:19 -08001489 return NO_ERROR;
1490}
1491
Dominik Laskowski788945b2022-08-30 12:10:56 -07001492status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& displayToken, ui::ColorMode mode) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001493 if (!displayToken) {
1494 return BAD_VALUE;
1495 }
1496
Dominik Laskowski788945b2022-08-30 12:10:56 -07001497 const char* const whence = __func__;
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001498 auto future = mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) -> status_t {
Dominik Laskowski788945b2022-08-30 12:10:56 -07001499 const auto displayOpt =
1500 ftl::find_if(mPhysicalDisplays, PhysicalDisplay::hasToken(displayToken))
1501 .transform(&ftl::to_mapped_ref<PhysicalDisplays>)
1502 .and_then(getDisplayDeviceAndSnapshot());
1503
1504 if (!displayOpt) {
1505 ALOGE("%s: Invalid physical display token %p", whence, displayToken.get());
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001506 return NAME_NOT_FOUND;
1507 }
1508
Dominik Laskowski788945b2022-08-30 12:10:56 -07001509 const auto& [display, snapshotRef] = *displayOpt;
1510 const auto& snapshot = snapshotRef.get();
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001511
Lloyd Pique30db6402023-06-26 18:56:51 +00001512 const auto modes = snapshot.filterColorModes(mSupportsWideColor);
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001513 const bool exists = std::find(modes.begin(), modes.end(), mode) != modes.end();
1514
Dominik Laskowski788945b2022-08-30 12:10:56 -07001515 if (mode < ui::ColorMode::NATIVE || !exists) {
1516 ALOGE("%s: Invalid color mode %s (%d) for display %s", whence,
1517 decodeColorMode(mode).c_str(), mode, to_string(snapshot.displayId()).c_str());
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001518 return BAD_VALUE;
1519 }
1520
1521 display->getCompositionDisplay()->setColorProfile(
Alec Mouri88790f32023-07-21 01:25:14 +00001522 {mode, Dataspace::UNKNOWN, RenderIntent::COLORIMETRIC});
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001523
1524 return NO_ERROR;
1525 });
1526
Dominik Laskowski0a5f9212021-08-05 17:00:04 -07001527 // TODO(b/195698395): Propagate error.
1528 future.wait();
1529 return NO_ERROR;
Michael Wright28f24d02016-07-12 13:30:53 -07001530}
Mathias Agopianc666cae2012-07-25 18:56:13 -07001531
Kriti Dang7defaf32021-11-15 11:55:43 +01001532status_t SurfaceFlinger::getBootDisplayModeSupport(bool* outSupport) const {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001533 auto future = mScheduler->schedule(
1534 [this] { return getHwComposer().hasCapability(Capability::BOOT_DISPLAY_CONFIG); });
1535
1536 *outSupport = future.get();
1537 return NO_ERROR;
Kriti Dang7defaf32021-11-15 11:55:43 +01001538}
1539
Sally Qibb866c12022-10-17 11:31:20 -07001540status_t SurfaceFlinger::getOverlaySupport(gui::OverlayProperties* outProperties) const {
1541 const auto& aidlProperties = getHwComposer().getOverlaySupport();
1542 // convert aidl OverlayProperties to gui::OverlayProperties
1543 outProperties->combinations.reserve(aidlProperties.combinations.size());
1544 for (const auto& combination : aidlProperties.combinations) {
1545 std::vector<int32_t> pixelFormats;
1546 pixelFormats.reserve(combination.pixelFormats.size());
1547 std::transform(combination.pixelFormats.cbegin(), combination.pixelFormats.cend(),
1548 std::back_inserter(pixelFormats),
1549 [](const auto& val) { return static_cast<int32_t>(val); });
Sally Qi4119e222023-01-13 14:52:18 -08001550 std::vector<int32_t> standards;
1551 standards.reserve(combination.standards.size());
1552 std::transform(combination.standards.cbegin(), combination.standards.cend(),
1553 std::back_inserter(standards),
1554 [](const auto& val) { return static_cast<int32_t>(val); });
1555 std::vector<int32_t> transfers;
1556 transfers.reserve(combination.transfers.size());
1557 std::transform(combination.transfers.cbegin(), combination.transfers.cend(),
1558 std::back_inserter(transfers),
1559 [](const auto& val) { return static_cast<int32_t>(val); });
1560 std::vector<int32_t> ranges;
1561 ranges.reserve(combination.ranges.size());
1562 std::transform(combination.ranges.cbegin(), combination.ranges.cend(),
1563 std::back_inserter(ranges),
Sally Qibb866c12022-10-17 11:31:20 -07001564 [](const auto& val) { return static_cast<int32_t>(val); });
1565 gui::OverlayProperties::SupportedBufferCombinations outCombination;
1566 outCombination.pixelFormats = std::move(pixelFormats);
Sally Qi4119e222023-01-13 14:52:18 -08001567 outCombination.standards = std::move(standards);
1568 outCombination.transfers = std::move(transfers);
1569 outCombination.ranges = std::move(ranges);
Sally Qibb866c12022-10-17 11:31:20 -07001570 outProperties->combinations.emplace_back(outCombination);
1571 }
Sally Qi8b4cb552022-12-14 16:24:31 -08001572 outProperties->supportMixedColorSpaces = aidlProperties.supportMixedColorSpaces;
Sally Qi0cbd08b2022-08-17 12:12:28 -07001573 return NO_ERROR;
1574}
1575
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001576status_t SurfaceFlinger::setBootDisplayMode(const sp<display::DisplayToken>& displayToken,
1577 DisplayModeId modeId) {
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001578 const char* const whence = __func__;
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001579 auto future = mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) -> status_t {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001580 const auto snapshotOpt =
1581 ftl::find_if(mPhysicalDisplays, PhysicalDisplay::hasToken(displayToken))
1582 .transform(&ftl::to_mapped_ref<PhysicalDisplays>)
1583 .transform(&PhysicalDisplay::snapshotRef);
1584
1585 if (!snapshotOpt) {
1586 ALOGE("%s: Invalid physical display token %p", whence, displayToken.get());
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001587 return NAME_NOT_FOUND;
1588 }
Kriti Dangf50d6772022-02-18 15:09:12 +01001589
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001590 const auto& snapshot = snapshotOpt->get();
1591 const auto hwcIdOpt = snapshot.displayModes().get(modeId).transform(
1592 [](const DisplayModePtr& mode) { return mode->getHwcId(); });
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001593
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001594 if (!hwcIdOpt) {
1595 ALOGE("%s: Invalid mode %d for display %s", whence, modeId.value(),
1596 to_string(snapshot.displayId()).c_str());
Kriti Dang7defaf32021-11-15 11:55:43 +01001597 return BAD_VALUE;
1598 }
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001599
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001600 return getHwComposer().setBootDisplayMode(snapshot.displayId(), *hwcIdOpt);
Kriti Dang7defaf32021-11-15 11:55:43 +01001601 });
1602 return future.get();
1603}
1604
1605status_t SurfaceFlinger::clearBootDisplayMode(const sp<IBinder>& displayToken) {
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001606 const char* const whence = __func__;
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001607 auto future = mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) -> status_t {
Kriti Dang7defaf32021-11-15 11:55:43 +01001608 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
1609 return getHwComposer().clearBootDisplayMode(*displayId);
1610 } else {
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001611 ALOGE("%s: Invalid display token %p", whence, displayToken.get());
Kriti Dang7defaf32021-11-15 11:55:43 +01001612 return BAD_VALUE;
1613 }
1614 });
1615 return future.get();
1616}
1617
Kriti Dang674b9372022-11-18 10:58:44 +01001618status_t SurfaceFlinger::getHdrConversionCapabilities(
1619 std::vector<gui::HdrConversionCapability>* hdrConversionCapabilities) const {
1620 bool hdrOutputConversionSupport;
1621 getHdrOutputConversionSupport(&hdrOutputConversionSupport);
1622 if (hdrOutputConversionSupport == false) {
1623 ALOGE("hdrOutputConversion is not supported by this device.");
1624 return INVALID_OPERATION;
1625 }
1626 const auto aidlConversionCapability = getHwComposer().getHdrConversionCapabilities();
1627 for (auto capability : aidlConversionCapability) {
1628 gui::HdrConversionCapability tempCapability;
Kriti Dang3c243dc2023-03-07 15:00:13 +01001629 tempCapability.sourceType = static_cast<int>(capability.sourceType);
1630 tempCapability.outputType = static_cast<int>(capability.outputType);
Kriti Dang674b9372022-11-18 10:58:44 +01001631 tempCapability.addsLatency = capability.addsLatency;
1632 hdrConversionCapabilities->push_back(tempCapability);
1633 }
1634 return NO_ERROR;
1635}
1636
1637status_t SurfaceFlinger::setHdrConversionStrategy(
Kriti Dangd432bb52023-02-09 18:21:04 +01001638 const gui::HdrConversionStrategy& hdrConversionStrategy,
1639 int32_t* outPreferredHdrOutputType) {
Kriti Dang674b9372022-11-18 10:58:44 +01001640 bool hdrOutputConversionSupport;
1641 getHdrOutputConversionSupport(&hdrOutputConversionSupport);
1642 if (hdrOutputConversionSupport == false) {
1643 ALOGE("hdrOutputConversion is not supported by this device.");
1644 return INVALID_OPERATION;
1645 }
1646 auto future = mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) mutable -> status_t {
1647 using AidlHdrConversionStrategy =
1648 aidl::android::hardware::graphics::common::HdrConversionStrategy;
1649 using GuiHdrConversionStrategyTag = gui::HdrConversionStrategy::Tag;
1650 AidlHdrConversionStrategy aidlConversionStrategy;
Kriti Dangd432bb52023-02-09 18:21:04 +01001651 status_t status;
1652 aidl::android::hardware::graphics::common::Hdr aidlPreferredHdrOutputType;
Kriti Dang674b9372022-11-18 10:58:44 +01001653 switch (hdrConversionStrategy.getTag()) {
1654 case GuiHdrConversionStrategyTag::passthrough: {
1655 aidlConversionStrategy.set<AidlHdrConversionStrategy::Tag::passthrough>(
1656 hdrConversionStrategy.get<GuiHdrConversionStrategyTag::passthrough>());
Kriti Dangd432bb52023-02-09 18:21:04 +01001657 status = getHwComposer().setHdrConversionStrategy(aidlConversionStrategy,
1658 &aidlPreferredHdrOutputType);
1659 *outPreferredHdrOutputType = static_cast<int32_t>(aidlPreferredHdrOutputType);
1660 return status;
Kriti Dang674b9372022-11-18 10:58:44 +01001661 }
1662 case GuiHdrConversionStrategyTag::autoAllowedHdrTypes: {
1663 auto autoHdrTypes =
1664 hdrConversionStrategy
1665 .get<GuiHdrConversionStrategyTag::autoAllowedHdrTypes>();
1666 std::vector<aidl::android::hardware::graphics::common::Hdr> aidlAutoHdrTypes;
1667 for (auto type : autoHdrTypes) {
1668 aidlAutoHdrTypes.push_back(
1669 static_cast<aidl::android::hardware::graphics::common::Hdr>(type));
1670 }
1671 aidlConversionStrategy.set<AidlHdrConversionStrategy::Tag::autoAllowedHdrTypes>(
1672 aidlAutoHdrTypes);
Kriti Dangd432bb52023-02-09 18:21:04 +01001673 status = getHwComposer().setHdrConversionStrategy(aidlConversionStrategy,
1674 &aidlPreferredHdrOutputType);
1675 *outPreferredHdrOutputType = static_cast<int32_t>(aidlPreferredHdrOutputType);
1676 return status;
Kriti Dang674b9372022-11-18 10:58:44 +01001677 }
1678 case GuiHdrConversionStrategyTag::forceHdrConversion: {
1679 auto forceHdrConversion =
1680 hdrConversionStrategy
1681 .get<GuiHdrConversionStrategyTag::forceHdrConversion>();
1682 aidlConversionStrategy.set<AidlHdrConversionStrategy::Tag::forceHdrConversion>(
1683 static_cast<aidl::android::hardware::graphics::common::Hdr>(
1684 forceHdrConversion));
Kriti Dangd432bb52023-02-09 18:21:04 +01001685 status = getHwComposer().setHdrConversionStrategy(aidlConversionStrategy,
1686 &aidlPreferredHdrOutputType);
1687 *outPreferredHdrOutputType = static_cast<int32_t>(aidlPreferredHdrOutputType);
1688 return status;
Kriti Dang674b9372022-11-18 10:58:44 +01001689 }
1690 }
1691 });
1692 return future.get();
1693}
1694
1695status_t SurfaceFlinger::getHdrOutputConversionSupport(bool* outSupport) const {
1696 auto future = mScheduler->schedule([this] {
1697 return getHwComposer().hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG);
1698 });
1699
1700 *outSupport = future.get();
1701 return NO_ERROR;
1702}
1703
Galia Peycheva5492cb52019-10-30 14:13:16 +01001704void SurfaceFlinger::setAutoLowLatencyMode(const sp<IBinder>& displayToken, bool on) {
Dominik Laskowski756b7892021-08-04 12:53:59 -07001705 const char* const whence = __func__;
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001706 static_cast<void>(mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001707 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
1708 getHwComposer().setAutoLowLatencyMode(*displayId, on);
1709 } else {
Dominik Laskowski756b7892021-08-04 12:53:59 -07001710 ALOGE("%s: Invalid display token %p", whence, displayToken.get());
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001711 }
1712 }));
Galia Peycheva5492cb52019-10-30 14:13:16 +01001713}
1714
Galia Peycheva5492cb52019-10-30 14:13:16 +01001715void SurfaceFlinger::setGameContentType(const sp<IBinder>& displayToken, bool on) {
Dominik Laskowski756b7892021-08-04 12:53:59 -07001716 const char* const whence = __func__;
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001717 static_cast<void>(mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001718 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
Peiyong Line9d809e2020-04-14 13:10:48 -07001719 const auto type = on ? hal::ContentType::GAME : hal::ContentType::NONE;
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001720 getHwComposer().setContentType(*displayId, type);
1721 } else {
Dominik Laskowski756b7892021-08-04 12:53:59 -07001722 ALOGE("%s: Invalid display token %p", whence, displayToken.get());
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001723 }
1724 }));
Galia Peycheva5492cb52019-10-30 14:13:16 +01001725}
1726
Kriti Dang49ad4132021-01-08 11:49:56 +01001727status_t SurfaceFlinger::overrideHdrTypes(const sp<IBinder>& displayToken,
1728 const std::vector<ui::Hdr>& hdrTypes) {
1729 Mutex::Autolock lock(mStateLock);
1730
1731 auto display = getDisplayDeviceLocked(displayToken);
1732 if (!display) {
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001733 ALOGE("%s: Invalid display token %p", __func__, displayToken.get());
Kriti Dang49ad4132021-01-08 11:49:56 +01001734 return NAME_NOT_FOUND;
1735 }
1736
1737 display->overrideHdrTypes(hdrTypes);
1738 dispatchDisplayHotplugEvent(display->getPhysicalId(), true /* connected */);
1739 return NO_ERROR;
1740}
1741
Huihong Luo30aa4372022-10-03 14:54:12 -07001742status_t SurfaceFlinger::onPullAtom(const int32_t atomId, std::vector<uint8_t>* pulledData,
1743 bool* success) {
Tej Singhe2751772021-04-06 22:05:29 -07001744 *success = mTimeStats->onPullAtom(atomId, pulledData);
1745 return NO_ERROR;
1746}
1747
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001748status_t SurfaceFlinger::getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
1749 ui::PixelFormat* outFormat,
1750 ui::Dataspace* outDataspace,
1751 uint8_t* outComponentMask) const {
1752 if (!outFormat || !outDataspace || !outComponentMask) {
1753 return BAD_VALUE;
1754 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001755
1756 Mutex::Autolock lock(mStateLock);
1757
1758 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1759 if (!displayId) {
1760 return NAME_NOT_FOUND;
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001761 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001762
1763 return getHwComposer().getDisplayedContentSamplingAttributes(*displayId, outFormat,
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001764 outDataspace, outComponentMask);
1765}
1766
Kevin DuBois74e53772018-11-19 10:52:38 -08001767status_t SurfaceFlinger::setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken,
1768 bool enable, uint8_t componentMask,
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001769 uint64_t maxFrames) {
Dominik Laskowski756b7892021-08-04 12:53:59 -07001770 const char* const whence = __func__;
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001771 auto future = mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) -> status_t {
Dominik Laskowski756b7892021-08-04 12:53:59 -07001772 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
1773 return getHwComposer().setDisplayContentSamplingEnabled(*displayId, enable,
1774 componentMask, maxFrames);
1775 } else {
1776 ALOGE("%s: Invalid display token %p", whence, displayToken.get());
1777 return NAME_NOT_FOUND;
1778 }
1779 });
1780
1781 return future.get();
Kevin DuBois74e53772018-11-19 10:52:38 -08001782}
1783
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001784status_t SurfaceFlinger::getDisplayedContentSample(const sp<IBinder>& displayToken,
1785 uint64_t maxFrames, uint64_t timestamp,
1786 DisplayedFrameStats* outStats) const {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001787 Mutex::Autolock lock(mStateLock);
1788
1789 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1790 if (!displayId) {
1791 return NAME_NOT_FOUND;
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001792 }
1793
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001794 return getHwComposer().getDisplayedContentSample(*displayId, maxFrames, timestamp, outStats);
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001795}
1796
Peiyong Lin3c2791e2019-01-14 17:05:18 -08001797status_t SurfaceFlinger::getProtectedContentSupport(bool* outSupported) const {
1798 if (!outSupported) {
1799 return BAD_VALUE;
1800 }
1801 *outSupported = getRenderEngine().supportsProtectedContent();
1802 return NO_ERROR;
1803}
1804
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001805status_t SurfaceFlinger::isWideColorDisplay(const sp<IBinder>& displayToken,
1806 bool* outIsWideColorDisplay) const {
1807 if (!displayToken || !outIsWideColorDisplay) {
1808 return BAD_VALUE;
1809 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001810
1811 Mutex::Autolock lock(mStateLock);
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001812 const auto display = getDisplayDeviceLocked(displayToken);
1813 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001814 return NAME_NOT_FOUND;
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001815 }
Peiyong Linff84a152019-05-17 18:36:19 -07001816
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001817 *outIsWideColorDisplay =
Lloyd Pique30db6402023-06-26 18:56:51 +00001818 display->isPrimary() ? mSupportsWideColor : display->hasWideColorGamut();
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001819 return NO_ERROR;
1820}
1821
Huihong Luo05539a12022-02-23 10:29:40 -08001822status_t SurfaceFlinger::getLayerDebugInfo(std::vector<gui::LayerDebugInfo>* outLayers) {
Kalle Raitaa099a242017-01-11 11:17:29 -08001823 outLayers->clear();
Dominik Laskowski756b7892021-08-04 12:53:59 -07001824 auto future = mScheduler->schedule([=] {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001825 const auto display = FTL_FAKE_GUARD(mStateLock, getDefaultDisplayDeviceLocked());
Vishnu Nair43bccf82020-06-05 10:53:37 -07001826 mDrawingState.traverseInZOrder([&](Layer* layer) {
1827 outLayers->push_back(layer->getLayerDebugInfo(display.get()));
1828 });
Dominik Laskowski756b7892021-08-04 12:53:59 -07001829 });
1830
1831 future.wait();
Kalle Raitaa099a242017-01-11 11:17:29 -08001832 return NO_ERROR;
1833}
1834
Peiyong Linc6780972018-10-28 15:24:08 -07001835status_t SurfaceFlinger::getCompositionPreference(
1836 Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
1837 Dataspace* outWideColorGamutDataspace,
1838 ui::PixelFormat* outWideColorGamutPixelFormat) const {
Lloyd Pique30db6402023-06-26 18:56:51 +00001839 *outDataspace = mDefaultCompositionDataspace;
1840 *outPixelFormat = defaultCompositionPixelFormat;
1841 *outWideColorGamutDataspace = mWideColorGamutCompositionDataspace;
1842 *outWideColorGamutPixelFormat = wideColorGamutCompositionPixelFormat;
Peiyong Lin0256f722018-08-31 15:45:10 -07001843 return NO_ERROR;
1844}
1845
Dan Stozaec460082018-12-17 15:35:09 -08001846status_t SurfaceFlinger::addRegionSamplingListener(const Rect& samplingArea,
1847 const sp<IBinder>& stopLayerHandle,
1848 const sp<IRegionSamplingListener>& listener) {
Leon Scroggins IIIae16b802022-01-12 11:42:05 -05001849 if (!listener || samplingArea == Rect::INVALID_RECT || samplingArea.isEmpty()) {
Dan Stozaec460082018-12-17 15:35:09 -08001850 return BAD_VALUE;
1851 }
Alec Mouri9a02eda2020-04-21 17:39:34 -07001852
Vishnu Nair07e2a482022-10-18 19:18:16 +00001853 // LayerHandle::getLayer promotes the layer object in a binder thread but we will not destroy
1854 // the layer here since the caller has a strong ref to the layer's handle.
Vishnu Nair9d77a5c2022-10-28 06:31:21 +00001855 const sp<Layer> stopLayer = LayerHandle::getLayer(stopLayerHandle);
1856 mRegionSamplingThread->addListener(samplingArea,
1857 stopLayer ? stopLayer->getSequence() : UNASSIGNED_LAYER_ID,
1858 listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001859 return NO_ERROR;
1860}
1861
Dan Stozaec460082018-12-17 15:35:09 -08001862status_t SurfaceFlinger::removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) {
tangrobinaf45f012019-02-26 18:10:10 +08001863 if (!listener) {
1864 return BAD_VALUE;
1865 }
Dan Stozaec460082018-12-17 15:35:09 -08001866 mRegionSamplingThread->removeListener(listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001867 return NO_ERROR;
1868}
Dan Gittik57e63c52019-01-18 16:37:54 +00001869
Alec Mouria9a68a62021-03-04 19:14:50 -08001870status_t SurfaceFlinger::addFpsListener(int32_t taskId, const sp<gui::IFpsListener>& listener) {
Alec Mouriadebf5c2021-01-05 12:57:36 -08001871 if (!listener) {
1872 return BAD_VALUE;
1873 }
1874
Alec Mouria9a68a62021-03-04 19:14:50 -08001875 mFpsReporter->addListener(listener, taskId);
Alec Mouriadebf5c2021-01-05 12:57:36 -08001876 return NO_ERROR;
1877}
1878
1879status_t SurfaceFlinger::removeFpsListener(const sp<gui::IFpsListener>& listener) {
1880 if (!listener) {
1881 return BAD_VALUE;
1882 }
1883 mFpsReporter->removeListener(listener);
1884 return NO_ERROR;
1885}
1886
Galia Peycheva8f04b302021-04-27 13:25:38 +02001887status_t SurfaceFlinger::addTunnelModeEnabledListener(
1888 const sp<gui::ITunnelModeEnabledListener>& listener) {
1889 if (!listener) {
1890 return BAD_VALUE;
1891 }
1892
1893 mTunnelModeEnabledReporter->addListener(listener);
1894 return NO_ERROR;
1895}
1896
1897status_t SurfaceFlinger::removeTunnelModeEnabledListener(
1898 const sp<gui::ITunnelModeEnabledListener>& listener) {
1899 if (!listener) {
1900 return BAD_VALUE;
1901 }
1902
1903 mTunnelModeEnabledReporter->removeListener(listener);
1904 return NO_ERROR;
1905}
1906
Dan Gittik57e63c52019-01-18 16:37:54 +00001907status_t SurfaceFlinger::getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
1908 bool* outSupport) const {
1909 if (!displayToken || !outSupport) {
1910 return BAD_VALUE;
1911 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001912
1913 Mutex::Autolock lock(mStateLock);
1914
Dan Gittik57e63c52019-01-18 16:37:54 +00001915 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1916 if (!displayId) {
1917 return NAME_NOT_FOUND;
1918 }
Leon Scroggins III5967aec2021-12-29 11:14:22 -05001919 *outSupport = getHwComposer().hasDisplayCapability(*displayId, DisplayCapability::BRIGHTNESS);
Dan Gittik57e63c52019-01-18 16:37:54 +00001920 return NO_ERROR;
1921}
1922
John Reck22be6962021-03-10 12:59:54 -05001923status_t SurfaceFlinger::setDisplayBrightness(const sp<IBinder>& displayToken,
1924 const gui::DisplayBrightness& brightness) {
Dan Gittik57e63c52019-01-18 16:37:54 +00001925 if (!displayToken) {
1926 return BAD_VALUE;
1927 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001928
Dominik Laskowski756b7892021-08-04 12:53:59 -07001929 const char* const whence = __func__;
Dominik Laskowskib17c6212022-05-09 09:36:19 -07001930 return ftl::Future(mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) {
John Reckac09e452021-04-07 16:35:37 -04001931 if (const auto display = getDisplayDeviceLocked(displayToken)) {
Alec Mouricdf16792021-12-10 13:16:06 -08001932 const bool supportsDisplayBrightnessCommand =
1933 getHwComposer().getComposer()->isSupported(
1934 Hwc2::Composer::OptionalFeature::DisplayBrightnessCommand);
1935 // If we support applying display brightness as a command, then we also support
1936 // dimming SDR layers.
Alec Mouri90a19272021-12-30 14:11:38 -08001937 if (supportsDisplayBrightnessCommand) {
Alec Mouri6da0e272022-02-07 12:45:57 -08001938 auto compositionDisplay = display->getCompositionDisplay();
1939 float currentDimmingRatio =
1940 compositionDisplay->editState().sdrWhitePointNits /
1941 compositionDisplay->editState().displayBrightnessNits;
Sally Qi0ea47b52023-06-22 13:27:20 -07001942 static constexpr float kDimmingThreshold = 0.02f;
1943 if (brightness.sdrWhitePointNits == 0.f ||
1944 abs(brightness.sdrWhitePointNits - brightness.displayBrightnessNits) /
1945 brightness.sdrWhitePointNits >=
1946 kDimmingThreshold) {
1947 // to optimize, skip brightness setter if the brightness difference ratio
1948 // is lower than threshold
1949 compositionDisplay
1950 ->setDisplayBrightness(brightness.sdrWhitePointNits,
1951 brightness.displayBrightnessNits);
1952 } else {
1953 compositionDisplay->setDisplayBrightness(brightness.sdrWhitePointNits,
1954 brightness.sdrWhitePointNits);
1955 }
1956
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001957 FTL_FAKE_GUARD(kMainThreadContext,
1958 display->stageBrightness(brightness.displayBrightness));
Sally Qi147581b2023-06-27 11:55:34 -07001959 float currentHdrSdrRatio =
1960 compositionDisplay->editState().displayBrightnessNits /
1961 compositionDisplay->editState().sdrWhitePointNits;
1962 FTL_FAKE_GUARD(kMainThreadContext,
1963 display->updateHdrSdrRatioOverlayRatio(currentHdrSdrRatio));
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001964
Alec Mouri6da0e272022-02-07 12:45:57 -08001965 if (brightness.sdrWhitePointNits / brightness.displayBrightnessNits !=
1966 currentDimmingRatio) {
Alec Mouricdf16792021-12-10 13:16:06 -08001967 scheduleComposite(FrameHint::kNone);
1968 } else {
1969 scheduleCommit(FrameHint::kNone);
1970 }
1971 return ftl::yield<status_t>(OK);
1972 } else {
Alec Mouri90a19272021-12-30 14:11:38 -08001973 return getHwComposer()
1974 .setDisplayBrightness(display->getPhysicalId(),
1975 brightness.displayBrightness,
Alec Mouri4d8a05d2022-03-23 18:14:26 +00001976 brightness.displayBrightnessNits,
Alec Mouri90a19272021-12-30 14:11:38 -08001977 Hwc2::Composer::DisplayBrightnessOptions{
1978 .applyImmediately = true});
John Reckac09e452021-04-07 16:35:37 -04001979 }
Alec Mouricdf16792021-12-10 13:16:06 -08001980
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001981 } else {
Dominik Laskowski756b7892021-08-04 12:53:59 -07001982 ALOGE("%s: Invalid display token %p", whence, displayToken.get());
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -08001983 return ftl::yield<status_t>(NAME_NOT_FOUND);
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001984 }
Dominik Laskowski5690bde2020-04-23 19:04:22 -07001985 }))
Dominik Laskowskib17c6212022-05-09 09:36:19 -07001986 .then([](ftl::Future<status_t> task) { return task; })
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001987 .get();
Dan Gittik57e63c52019-01-18 16:37:54 +00001988}
1989
John Reck88270902021-03-18 11:27:35 -04001990status_t SurfaceFlinger::addHdrLayerInfoListener(const sp<IBinder>& displayToken,
1991 const sp<gui::IHdrLayerInfoListener>& listener) {
1992 if (!displayToken) {
1993 return BAD_VALUE;
1994 }
1995
1996 Mutex::Autolock lock(mStateLock);
1997
1998 const auto display = getDisplayDeviceLocked(displayToken);
1999 if (!display) {
2000 return NAME_NOT_FOUND;
2001 }
2002 const auto displayId = display->getId();
2003 sp<HdrLayerInfoReporter>& hdrInfoReporter = mHdrLayerInfoListeners[displayId];
2004 if (!hdrInfoReporter) {
2005 hdrInfoReporter = sp<HdrLayerInfoReporter>::make();
2006 }
2007 hdrInfoReporter->addListener(listener);
Robert Carr167bdde2021-07-28 11:26:51 -07002008
2009
2010 mAddingHDRLayerInfoListener = true;
John Reck88270902021-03-18 11:27:35 -04002011 return OK;
2012}
2013
2014status_t SurfaceFlinger::removeHdrLayerInfoListener(
2015 const sp<IBinder>& displayToken, const sp<gui::IHdrLayerInfoListener>& listener) {
2016 if (!displayToken) {
2017 return BAD_VALUE;
2018 }
2019
2020 Mutex::Autolock lock(mStateLock);
2021
2022 const auto display = getDisplayDeviceLocked(displayToken);
2023 if (!display) {
2024 return NAME_NOT_FOUND;
2025 }
2026 const auto displayId = display->getId();
2027 sp<HdrLayerInfoReporter>& hdrInfoReporter = mHdrLayerInfoListeners[displayId];
2028 if (hdrInfoReporter) {
2029 hdrInfoReporter->removeListener(listener);
2030 }
2031 return OK;
2032}
2033
Lais Andrade3a6e47d2020-04-02 11:20:16 +01002034status_t SurfaceFlinger::notifyPowerBoost(int32_t boostId) {
Xiang Wang99f6f3c2023-05-22 13:12:16 -07002035 using aidl::android::hardware::power::Boost;
Lais Andrade3a6e47d2020-04-02 11:20:16 +01002036 Boost powerBoost = static_cast<Boost>(boostId);
Ady Abraham8532d012019-05-08 14:50:56 -07002037
Lais Andrade3a6e47d2020-04-02 11:20:16 +01002038 if (powerBoost == Boost::INTERACTION) {
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07002039 mScheduler->onTouchHint();
Ady Abraham8532d012019-05-08 14:50:56 -07002040 }
2041
2042 return NO_ERROR;
2043}
2044
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -05002045status_t SurfaceFlinger::getDisplayDecorationSupport(
2046 const sp<IBinder>& displayToken,
2047 std::optional<DisplayDecorationSupport>* outSupport) const {
Leon Scroggins IIIe5cff632021-12-29 11:53:36 -05002048 if (!displayToken || !outSupport) {
2049 return BAD_VALUE;
2050 }
2051
2052 Mutex::Autolock lock(mStateLock);
2053
2054 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
2055 if (!displayId) {
2056 return NAME_NOT_FOUND;
2057 }
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -05002058 getHwComposer().getDisplayDecorationSupport(*displayId, outSupport);
Leon Scroggins IIIe5cff632021-12-29 11:53:36 -05002059 return NO_ERROR;
2060}
2061
Mathias Agopiand0566bc2011-11-17 17:49:17 -08002062// ----------------------------------------------------------------------------
2063
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -07002064sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection(
Rachel Lee2248f522023-01-27 16:45:23 -08002065 gui::ISurfaceComposer::VsyncSource vsyncSource, EventRegistrationFlags eventRegistration,
2066 const sp<IBinder>& layerHandle) {
Ana Krulecc2870422019-01-29 19:00:58 -08002067 const auto& handle =
Huihong Luo1b0c49f2022-03-15 19:18:21 -07002068 vsyncSource == gui::ISurfaceComposer::VsyncSource::eVsyncSourceSurfaceFlinger
2069 ? mSfConnectionHandle
2070 : mAppConnectionHandle;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08002071
Rachel Lee2248f522023-01-27 16:45:23 -08002072 return mScheduler->createDisplayEventConnection(handle, eventRegistration, layerHandle);
Mathias Agopianbb641242010-05-18 17:06:55 -07002073}
2074
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002075void SurfaceFlinger::scheduleCommit(FrameHint hint) {
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07002076 if (hint == FrameHint::kActive) {
2077 mScheduler->resetIdleTimer();
2078 }
Matt Buckley15ecd1c2022-11-01 21:57:16 +00002079 mPowerAdvisor->notifyDisplayUpdateImminentAndCpuReset();
Dominik Laskowski46f3e3b2021-08-10 11:44:24 -07002080 mScheduler->scheduleFrame();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08002081}
2082
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002083void SurfaceFlinger::scheduleComposite(FrameHint hint) {
2084 mMustComposite = true;
2085 scheduleCommit(hint);
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07002086}
2087
2088void SurfaceFlinger::scheduleRepaint() {
2089 mGeometryDirty = true;
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002090 scheduleComposite(FrameHint::kActive);
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07002091}
2092
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002093void SurfaceFlinger::scheduleSample() {
Dominik Laskowski756b7892021-08-04 12:53:59 -07002094 static_cast<void>(mScheduler->schedule([this] { sample(); }));
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08002095}
2096
Ady Abraham2492a022020-07-24 11:09:55 -07002097nsecs_t SurfaceFlinger::getVsyncPeriodFromHWC() const {
Marin Shalamanov045b7002021-01-07 16:56:24 +01002098 if (const auto display = getDefaultDisplayDeviceLocked()) {
2099 return display->getVsyncPeriodFromHWC();
Dominik Laskowski83b88212018-12-11 13:34:06 -08002100 }
2101
Marin Shalamanov045b7002021-01-07 16:56:24 +01002102 return 0;
Dominik Laskowski83b88212018-12-11 13:34:06 -08002103}
2104
Dominik Laskowski0deb06e2021-04-16 23:18:31 -07002105void SurfaceFlinger::onComposerHalVsync(hal::HWDisplayId hwcDisplayId, int64_t timestamp,
2106 std::optional<hal::VsyncPeriodNanos> vsyncPeriod) {
Dominik Laskowski3d483042023-02-22 17:58:56 -05002107 ATRACE_NAME(vsyncPeriod
2108 ? ftl::Concat(__func__, ' ', hwcDisplayId, ' ', *vsyncPeriod, "ns").c_str()
2109 : ftl::Concat(__func__, ' ', hwcDisplayId).c_str());
Steven Thomasdfde8fa2018-04-19 16:00:58 -07002110
Steven Thomas3cfac282017-02-06 12:29:30 -08002111 Mutex::Autolock lock(mStateLock);
Leon Scroggins III67388622023-02-06 20:36:20 -05002112 if (const auto displayIdOpt = getHwComposer().onVsync(hwcDisplayId, timestamp)) {
2113 if (mScheduler->addResyncSample(*displayIdOpt, timestamp, vsyncPeriod)) {
2114 // period flushed
2115 mScheduler->modulateVsync(displayIdOpt, &VsyncModulator::onRefreshRateChangeCompleted);
2116 }
Alec Mouri754c98a2019-03-18 18:53:42 -07002117 }
Mathias Agopian148994e2012-09-19 17:31:36 -07002118}
2119
Dominik Laskowski0deb06e2021-04-16 23:18:31 -07002120void SurfaceFlinger::onComposerHalHotplug(hal::HWDisplayId hwcDisplayId,
2121 hal::Connection connection) {
Dominik Laskowskif11728a2022-07-28 13:07:42 -07002122 {
2123 std::lock_guard<std::mutex> lock(mHotplugMutex);
2124 mPendingHotplugEvents.push_back(HotplugEvent{hwcDisplayId, connection});
Jiwen 'Steve' Caiccfd6822018-02-21 16:15:58 -08002125 }
2126
Dominik Laskowskif11728a2022-07-28 13:07:42 -07002127 if (mScheduler) {
2128 mScheduler->scheduleConfigure();
2129 }
Mathias Agopian86303202012-07-24 22:46:10 -07002130}
2131
Dominik Laskowski0deb06e2021-04-16 23:18:31 -07002132void SurfaceFlinger::onComposerHalVsyncPeriodTimingChanged(
2133 hal::HWDisplayId, const hal::VsyncPeriodChangeTimeline& timeline) {
Ady Abraham3a77a7b2019-12-02 18:46:59 -08002134 Mutex::Autolock lock(mStateLock);
Dominik Laskowski0deb06e2021-04-16 23:18:31 -07002135 mScheduler->onNewVsyncPeriodChangeTimeline(timeline);
Dominik Laskowskidd5827a2022-03-17 12:44:23 -07002136
2137 if (timeline.refreshRequired) {
2138 scheduleComposite(FrameHint::kNone);
2139 }
Ady Abraham7159f572019-10-11 11:10:18 -07002140}
2141
Dominik Laskowski0deb06e2021-04-16 23:18:31 -07002142void SurfaceFlinger::onComposerHalSeamlessPossible(hal::HWDisplayId) {
Marin Shalamanov3ea1d602020-12-16 19:59:39 +01002143 // TODO(b/142753666): use constraints when calling to setActiveModeWithConstraints and
Ady Abrahamb0433bc2020-01-08 17:31:06 -08002144 // use this callback to know when to retry in case of SEAMLESS_NOT_POSSIBLE.
2145}
2146
Dominik Laskowski0deb06e2021-04-16 23:18:31 -07002147void SurfaceFlinger::onComposerHalRefresh(hal::HWDisplayId) {
Steven Thomas3cfac282017-02-06 12:29:30 -08002148 Mutex::Autolock lock(mStateLock);
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002149 scheduleComposite(FrameHint::kNone);
Steven Thomas3cfac282017-02-06 12:29:30 -08002150}
2151
Yichi Chen3401b562022-01-17 15:42:35 +08002152void SurfaceFlinger::onComposerHalVsyncIdle(hal::HWDisplayId) {
Ady Abrahame9befd72022-02-24 17:24:44 -08002153 ATRACE_CALL();
2154 mScheduler->forceNextResync();
Yichi Chen3401b562022-01-17 15:42:35 +08002155}
2156
ramindanib2158ee2023-02-13 20:29:59 -08002157void SurfaceFlinger::onRefreshRateChangedDebug(const RefreshRateChangedDebugData& data) {
2158 ATRACE_CALL();
2159 if (const auto displayId = getHwComposer().toPhysicalDisplayId(data.display); displayId) {
2160 const Fps fps = Fps::fromPeriodNsecs(data.vsyncPeriodNanos);
2161 ATRACE_FORMAT("%s Fps %d", __func__, fps.getIntValue());
2162 static_cast<void>(mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) {
2163 {
2164 {
2165 const auto display = getDisplayDeviceLocked(*displayId);
2166 FTL_FAKE_GUARD(kMainThreadContext,
2167 display->updateRefreshRateOverlayRate(fps,
2168 display->getActiveMode()
2169 .fps,
2170 /* setByHwc */ true));
2171 }
2172 }
2173 }));
2174 }
ramindani12bfe6b2023-02-03 13:29:19 -08002175}
2176
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002177void SurfaceFlinger::configure() {
Dominik Laskowskif11728a2022-07-28 13:07:42 -07002178 Mutex::Autolock lock(mStateLock);
2179 if (configureLocked()) {
2180 setTransactionFlags(eDisplayTransactionNeeded);
2181 }
2182}
2183
Vishnu Nair4d9cef92023-06-24 22:34:41 +00002184bool SurfaceFlinger::updateLayerSnapshotsLegacy(VsyncId vsyncId, nsecs_t frameTimeNs,
2185 bool flushTransactions,
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002186 bool& outTransactionsAreEmpty) {
Vishnu Naira02943f2023-06-03 13:44:46 -07002187 ATRACE_CALL();
Vishnu Nair4d9cef92023-06-24 22:34:41 +00002188 frontend::Update update;
2189 if (flushTransactions) {
2190 update = flushLifecycleUpdates();
2191 if (mTransactionTracing) {
2192 mTransactionTracing->addCommittedTransactions(ftl::to_underlying(vsyncId), frameTimeNs,
2193 update, mFrontEndDisplayInfos,
2194 mFrontEndDisplayInfosChanged);
2195 }
2196 }
2197
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002198 bool needsTraversal = false;
Vishnu Nair4d9cef92023-06-24 22:34:41 +00002199 if (flushTransactions) {
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002200 needsTraversal |= commitMirrorDisplays(vsyncId);
2201 needsTraversal |= commitCreatedLayers(vsyncId, update.layerCreatedStates);
2202 needsTraversal |= applyTransactions(update.transactions, vsyncId);
2203 }
2204 outTransactionsAreEmpty = !needsTraversal;
2205 const bool shouldCommit = (getTransactionFlags() & ~eTransactionFlushNeeded) || needsTraversal;
2206 if (shouldCommit) {
2207 commitTransactions();
2208 }
2209
2210 bool mustComposite = latchBuffers() || shouldCommit;
2211 updateLayerGeometry();
2212 return mustComposite;
2213}
2214
Vishnu Nairef68d6d2023-02-28 06:18:27 +00002215void SurfaceFlinger::updateLayerHistory(const frontend::LayerSnapshot& snapshot) {
2216 using Changes = frontend::RequestedLayerState::Changes;
2217 if (snapshot.path.isClone() ||
2218 !snapshot.changes.any(Changes::FrameRate | Changes::Buffer | Changes::Animation)) {
2219 return;
2220 }
2221
2222 const auto layerProps = scheduler::LayerProps{
2223 .visible = snapshot.isVisible,
2224 .bounds = snapshot.geomLayerBounds,
2225 .transform = snapshot.geomLayerTransform,
2226 .setFrameRateVote = snapshot.frameRate,
2227 .frameRateSelectionPriority = snapshot.frameRateSelectionPriority,
2228 };
2229
2230 auto it = mLegacyLayers.find(snapshot.sequence);
2231 LOG_ALWAYS_FATAL_IF(it == mLegacyLayers.end(), "Couldnt find layer object for %s",
2232 snapshot.getDebugString().c_str());
2233
2234 if (snapshot.changes.test(Changes::Animation)) {
2235 it->second->recordLayerHistoryAnimationTx(layerProps);
2236 }
2237
2238 if (snapshot.changes.test(Changes::FrameRate)) {
2239 it->second->setFrameRateForLayerTree(snapshot.frameRate, layerProps);
2240 }
2241
2242 if (snapshot.changes.test(Changes::Buffer)) {
2243 it->second->recordLayerHistoryBufferUpdate(layerProps);
2244 }
2245}
2246
Vishnu Nair4d9cef92023-06-24 22:34:41 +00002247bool SurfaceFlinger::updateLayerSnapshots(VsyncId vsyncId, nsecs_t frameTimeNs,
2248 bool flushTransactions, bool& outTransactionsAreEmpty) {
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002249 using Changes = frontend::RequestedLayerState::Changes;
Vishnu Naira02943f2023-06-03 13:44:46 -07002250 ATRACE_CALL();
Vishnu Nair4d9cef92023-06-24 22:34:41 +00002251 frontend::Update update;
2252 if (flushTransactions) {
2253 ATRACE_NAME("TransactionHandler:flushTransactions");
2254 // Locking:
2255 // 1. to prevent onHandleDestroyed from being called while the state lock is held,
2256 // we must keep a copy of the transactions (specifically the composer
2257 // states) around outside the scope of the lock.
2258 // 2. Transactions and created layers do not share a lock. To prevent applying
2259 // transactions with layers still in the createdLayer queue, collect the transactions
2260 // before committing the created layers.
2261 // 3. Transactions can only be flushed after adding layers, since the layer can be a newly
2262 // created one
2263 mTransactionHandler.collectTransactions();
2264 {
2265 // TODO(b/238781169) lockless queue this and keep order.
2266 std::scoped_lock<std::mutex> lock(mCreatedLayersLock);
2267 update.layerCreatedStates = std::move(mCreatedLayers);
2268 mCreatedLayers.clear();
2269 update.newLayers = std::move(mNewLayers);
2270 mNewLayers.clear();
2271 update.layerCreationArgs = std::move(mNewLayerArgs);
2272 mNewLayerArgs.clear();
2273 update.destroyedHandles = std::move(mDestroyedHandles);
2274 mDestroyedHandles.clear();
2275 }
2276
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002277 mLayerLifecycleManager.addLayers(std::move(update.newLayers));
Vishnu Nair4d9cef92023-06-24 22:34:41 +00002278 update.transactions = mTransactionHandler.flushTransactions();
2279 if (mTransactionTracing) {
2280 mTransactionTracing->addCommittedTransactions(ftl::to_underlying(vsyncId), frameTimeNs,
2281 update, mFrontEndDisplayInfos,
2282 mFrontEndDisplayInfosChanged);
2283 }
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002284 mLayerLifecycleManager.applyTransactions(update.transactions);
2285 mLayerLifecycleManager.onHandlesDestroyed(update.destroyedHandles);
2286 for (auto& legacyLayer : update.layerCreatedStates) {
2287 sp<Layer> layer = legacyLayer.layer.promote();
2288 if (layer) {
2289 mLegacyLayers[layer->sequence] = layer;
2290 }
2291 }
Vishnu Nair4d9cef92023-06-24 22:34:41 +00002292 if (mLayerLifecycleManager.getGlobalChanges().test(Changes::Hierarchy)) {
2293 ATRACE_NAME("LayerHierarchyBuilder:update");
2294 mLayerHierarchyBuilder.update(mLayerLifecycleManager.getLayers(),
2295 mLayerLifecycleManager.getDestroyedLayers());
2296 }
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002297 }
2298
Vishnu Naird47bcee2023-02-24 18:08:51 +00002299 bool mustComposite = false;
2300 mustComposite |= applyAndCommitDisplayTransactionStates(update.transactions);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002301
2302 {
2303 ATRACE_NAME("LayerSnapshotBuilder:update");
Vishnu Nairc765c6c2023-02-23 00:08:01 +00002304 frontend::LayerSnapshotBuilder::Args
2305 args{.root = mLayerHierarchyBuilder.getHierarchy(),
2306 .layerLifecycleManager = mLayerLifecycleManager,
2307 .displays = mFrontEndDisplayInfos,
2308 .displayChanges = mFrontEndDisplayInfosChanged,
2309 .globalShadowSettings = mDrawingState.globalShadowSettings,
Lloyd Pique30db6402023-06-26 18:56:51 +00002310 .supportsBlur = mSupportsBlur,
Vishnu Nairc765c6c2023-02-23 00:08:01 +00002311 .forceFullDamage = mForceFullDamage,
2312 .supportedLayerGenericMetadata =
2313 getHwComposer().getSupportedLayerGenericMetadata(),
Vishnu Nair0808ae62023-08-07 21:42:42 -07002314 .genericLayerMetadataKeyMap = getGenericLayerMetadataKeyMap(),
2315 .skipRoundCornersWhenProtected =
2316 !getRenderEngine().supportsProtectedContent()};
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002317 mLayerSnapshotBuilder.update(args);
2318 }
2319
2320 if (mLayerLifecycleManager.getGlobalChanges().any(Changes::Geometry | Changes::Input |
Vishnu Nair40d02282023-02-28 21:11:40 +00002321 Changes::Hierarchy | Changes::Visibility)) {
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002322 mUpdateInputInfo = true;
2323 }
2324 if (mLayerLifecycleManager.getGlobalChanges().any(Changes::VisibleRegion | Changes::Hierarchy |
2325 Changes::Visibility)) {
2326 mVisibleRegionsDirty = true;
2327 }
Ady Abraham822ecbd2023-07-07 16:16:09 -07002328 if (mLayerLifecycleManager.getGlobalChanges().any(Changes::Hierarchy | Changes::FrameRate)) {
2329 // The frame rate of attached choreographers can only change as a result of a
2330 // FrameRate change (including when Hierarchy changes).
2331 mUpdateAttachedChoreographer = true;
2332 }
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002333 outTransactionsAreEmpty = mLayerLifecycleManager.getGlobalChanges().get() == 0;
Vishnu Naird47bcee2023-02-24 18:08:51 +00002334 mustComposite |= mLayerLifecycleManager.getGlobalChanges().get() != 0;
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002335
Vishnu Naird47bcee2023-02-24 18:08:51 +00002336 bool newDataLatched = false;
Lloyd Pique30db6402023-06-26 18:56:51 +00002337 if (!mLegacyFrontEndEnabled) {
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002338 ATRACE_NAME("DisplayCallbackAndStatsUpdates");
2339 applyTransactions(update.transactions, vsyncId);
Vishnu Nairc1d19d72023-08-10 12:35:11 -07002340 traverseLegacyLayers([&](Layer* layer) { layer->commitTransaction(); });
Vishnu Naird47bcee2023-02-24 18:08:51 +00002341 const nsecs_t latchTime = systemTime();
2342 bool unused = false;
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002343
Vishnu Naird47bcee2023-02-24 18:08:51 +00002344 for (auto& layer : mLayerLifecycleManager.getLayers()) {
2345 if (layer->changes.test(frontend::RequestedLayerState::Changes::Created) &&
2346 layer->bgColorLayer) {
2347 sp<Layer> bgColorLayer = getFactory().createEffectLayer(
2348 LayerCreationArgs(this, nullptr, layer->name,
2349 ISurfaceComposerClient::eFXSurfaceEffect, LayerMetadata(),
Vishnu Naire4af0952023-05-01 09:11:33 -07002350 std::make_optional(layer->id), true));
Vishnu Naird47bcee2023-02-24 18:08:51 +00002351 mLegacyLayers[bgColorLayer->sequence] = bgColorLayer;
2352 }
Vishnu Nair7ee4f462023-04-19 09:54:09 -07002353 const bool willReleaseBufferOnLatch = layer->willReleaseBufferOnLatch();
2354 if (!layer->hasReadyFrame() && !willReleaseBufferOnLatch) continue;
Vishnu Naird47bcee2023-02-24 18:08:51 +00002355
2356 auto it = mLegacyLayers.find(layer->id);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002357 LOG_ALWAYS_FATAL_IF(it == mLegacyLayers.end(), "Couldnt find layer object for %s",
Vishnu Naird47bcee2023-02-24 18:08:51 +00002358 layer->getDebugString().c_str());
2359 const bool bgColorOnly =
2360 !layer->externalTexture && (layer->bgColorLayerId != UNASSIGNED_LAYER_ID);
Vishnu Nair7ee4f462023-04-19 09:54:09 -07002361 if (willReleaseBufferOnLatch) {
2362 mLayersWithBuffersRemoved.emplace(it->second);
2363 }
Vishnu Naird47bcee2023-02-24 18:08:51 +00002364 it->second->latchBufferImpl(unused, latchTime, bgColorOnly);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002365 newDataLatched = true;
Vishnu Nair6f209e22023-08-04 16:33:23 +00002366 mLayersWithQueuedFrames.emplace(it->second);
2367 mLayersIdsWithQueuedFrames.emplace(it->second->sequence);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002368 }
2369
Vishnu Nair6f209e22023-08-04 16:33:23 +00002370 mLayerSnapshotBuilder.forEachVisibleSnapshot([&](const frontend::LayerSnapshot& snapshot) {
2371 updateLayerHistory(snapshot);
2372 if (mLayersIdsWithQueuedFrames.find(snapshot.path.id) ==
2373 mLayersIdsWithQueuedFrames.end())
2374 return;
2375 Region visibleReg;
2376 visibleReg.set(snapshot.transformedBoundsWithoutTransparentRegion);
2377 invalidateLayerStack(snapshot.outputFilter, visibleReg);
2378 });
2379
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002380 for (auto& destroyedLayer : mLayerLifecycleManager.getDestroyedLayers()) {
2381 mLegacyLayers.erase(destroyedLayer->id);
2382 }
2383
Vishnu Naird47bcee2023-02-24 18:08:51 +00002384 {
2385 ATRACE_NAME("LLM:commitChanges");
2386 mLayerLifecycleManager.commitChanges();
2387 }
2388
Vishnu Naira7caedc2023-02-26 03:24:58 +00002389 commitTransactions();
2390
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002391 // enter boot animation on first buffer latch
2392 if (CC_UNLIKELY(mBootStage == BootStage::BOOTLOADER && newDataLatched)) {
2393 ALOGI("Enter boot animation");
2394 mBootStage = BootStage::BOOTANIMATION;
2395 }
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002396 }
Vishnu Naird47bcee2023-02-24 18:08:51 +00002397 mustComposite |= (getTransactionFlags() & ~eTransactionFlushNeeded) || newDataLatched;
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002398 return mustComposite;
2399}
2400
Dominik Laskowskifdac5652023-06-29 12:01:13 -04002401bool SurfaceFlinger::commit(PhysicalDisplayId pacesetterId,
2402 const scheduler::FrameTargets& frameTargets) {
2403 const scheduler::FrameTarget& pacesetterFrameTarget = *frameTargets.get(pacesetterId)->get();
2404
Dominik Laskowskib418dd72023-06-13 17:31:04 -04002405 const VsyncId vsyncId = pacesetterFrameTarget.vsyncId();
2406 ATRACE_NAME(ftl::Concat(__func__, ' ', ftl::to_underlying(vsyncId)).c_str());
Dan Stoza28d46a52020-04-28 09:54:54 -07002407
Dominik Laskowskib418dd72023-06-13 17:31:04 -04002408 if (pacesetterFrameTarget.didMissFrame()) {
Dan Stoza28d46a52020-04-28 09:54:54 -07002409 mTimeStats->incrementMissedFrames();
Dan Stoza28d46a52020-04-28 09:54:54 -07002410 }
2411
Vishnu Nair286f4f92022-06-08 16:37:39 -07002412 if (mTracingEnabledChanged) {
2413 mLayerTracingEnabled = mLayerTracing.isEnabled();
2414 mTracingEnabledChanged = false;
2415 }
2416
Dominik Laskowskifdac5652023-06-29 12:01:13 -04002417 // If a mode set is pending and the fence hasn't fired yet, wait for the next commit.
2418 if (std::any_of(frameTargets.begin(), frameTargets.end(),
2419 [this](const auto& pair) FTL_FAKE_GUARD(mStateLock)
2420 FTL_FAKE_GUARD(kMainThreadContext) {
2421 if (!pair.second->isFramePending()) return false;
Dan Stoza28d46a52020-04-28 09:54:54 -07002422
Dominik Laskowskifdac5652023-06-29 12:01:13 -04002423 if (const auto display = getDisplayDeviceLocked(pair.first)) {
2424 return display->isModeSetPending();
2425 }
2426
2427 return false;
2428 })) {
2429 mScheduler->scheduleFrame();
2430 return false;
2431 }
2432
2433 {
2434 Mutex::Autolock lock(mStateLock);
2435
2436 for (const auto [id, target] : frameTargets) {
2437 // TODO(b/241285876): This is `nullptr` when the DisplayDevice is about to be removed in
2438 // this commit, since the PhysicalDisplay has already been removed. Rather than checking
2439 // for `nullptr` below, change Scheduler::onFrameSignal to filter out the FrameTarget of
2440 // the removed display.
2441 const auto display = getDisplayDeviceLocked(id);
2442
2443 if (display && display->isModeSetPending()) {
2444 finalizeDisplayModeChange(*display);
2445 }
yuhui.zhang087d3742021-12-11 15:23:52 +08002446 }
Dan Stoza28d46a52020-04-28 09:54:54 -07002447 }
2448
Dominik Laskowskib418dd72023-06-13 17:31:04 -04002449 if (pacesetterFrameTarget.isFramePending()) {
Lloyd Pique30db6402023-06-26 18:56:51 +00002450 if (mBackpressureGpuComposition || pacesetterFrameTarget.didMissHwcFrame()) {
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002451 scheduleCommit(FrameHint::kNone);
2452 return false;
Dan Stoza28d46a52020-04-28 09:54:54 -07002453 }
2454 }
2455
Dominik Laskowskib418dd72023-06-13 17:31:04 -04002456 const Period vsyncPeriod = mScheduler->getVsyncSchedule()->period();
2457
Matt Buckley50c44062022-01-17 20:48:10 +00002458 // Save this once per commit + composite to ensure consistency
Matt Buckleyba8d15a2022-08-02 20:10:15 +00002459 // TODO (b/240619471): consider removing active display check once AOD is fixed
Dominik Laskowskie591b552022-09-09 10:44:56 -07002460 const auto activeDisplay = FTL_FAKE_GUARD(mStateLock, getDisplayDeviceLocked(mActiveDisplayId));
Matt Buckleyba8d15a2022-08-02 20:10:15 +00002461 mPowerHintSessionEnabled = mPowerAdvisor->usePowerHintSession() && activeDisplay &&
2462 activeDisplay->getPowerMode() == hal::PowerMode::ON;
Matt Buckley50c44062022-01-17 20:48:10 +00002463 if (mPowerHintSessionEnabled) {
Dominik Laskowskib418dd72023-06-13 17:31:04 -04002464 mPowerAdvisor->setCommitStart(pacesetterFrameTarget.frameBeginTime());
2465 mPowerAdvisor->setExpectedPresentTime(pacesetterFrameTarget.expectedPresentTime());
Dominik Laskowski08fbd852022-07-14 08:53:42 -07002466
2467 // Frame delay is how long we should have minus how long we actually have.
Dominik Laskowski1c99a002023-01-20 17:10:36 -05002468 const Duration idealSfWorkDuration =
2469 mScheduler->vsyncModulator().getVsyncConfig().sfWorkDuration;
Dominik Laskowskib418dd72023-06-13 17:31:04 -04002470 const Duration frameDelay =
2471 idealSfWorkDuration - pacesetterFrameTarget.expectedFrameDuration();
Dominik Laskowski08fbd852022-07-14 08:53:42 -07002472
Matt Buckley2fa85012022-08-30 22:38:45 +00002473 mPowerAdvisor->setFrameDelay(frameDelay);
2474 mPowerAdvisor->setTotalFrameTargetWorkDuration(idealSfWorkDuration);
Matt Buckley676e4392023-05-25 22:09:26 +00002475
2476 const auto& display = FTL_FAKE_GUARD(mStateLock, getDefaultDisplayDeviceLocked()).get();
2477 const Period idealVsyncPeriod = display->getActiveMode().fps.getPeriod();
2478 mPowerAdvisor->updateTargetWorkDuration(idealVsyncPeriod);
Matt Buckley50c44062022-01-17 20:48:10 +00002479 }
2480
Sally Qi147581b2023-06-27 11:55:34 -07002481 if (mRefreshRateOverlaySpinner || mHdrSdrRatioOverlay) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07002482 Mutex::Autolock lock(mStateLock);
2483 if (const auto display = getDefaultDisplayDeviceLocked()) {
Sally Qi147581b2023-06-27 11:55:34 -07002484 display->animateOverlay();
Ady Abraham29d0da32020-07-16 18:39:33 -07002485 }
2486 }
2487
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002488 // Composite if transactions were committed, or if requested by HWC.
2489 bool mustComposite = mMustComposite.exchange(false);
Dan Stoza28d46a52020-04-28 09:54:54 -07002490 {
Dominik Laskowskib418dd72023-06-13 17:31:04 -04002491 mFrameTimeline->setSfWakeUp(ftl::to_underlying(vsyncId),
2492 pacesetterFrameTarget.frameBeginTime().ns(),
Dominik Laskowski08fbd852022-07-14 08:53:42 -07002493 Fps::fromPeriodNsecs(vsyncPeriod.ns()));
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -07002494
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002495 const bool flushTransactions = clearTransactionFlags(eTransactionFlushNeeded);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002496 bool transactionsAreEmpty;
Lloyd Pique30db6402023-06-26 18:56:51 +00002497 if (mLegacyFrontEndEnabled) {
Vishnu Nair4d9cef92023-06-24 22:34:41 +00002498 mustComposite |=
2499 updateLayerSnapshotsLegacy(vsyncId, pacesetterFrameTarget.frameBeginTime().ns(),
2500 flushTransactions, transactionsAreEmpty);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002501 }
Lloyd Pique30db6402023-06-26 18:56:51 +00002502 if (mLayerLifecycleManagerEnabled) {
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002503 mustComposite |=
Vishnu Nair4d9cef92023-06-24 22:34:41 +00002504 updateLayerSnapshots(vsyncId, pacesetterFrameTarget.frameBeginTime().ns(),
2505 flushTransactions, transactionsAreEmpty);
chaviw6b9ffea2021-11-08 09:25:48 -06002506 }
2507
2508 if (transactionFlushNeeded()) {
2509 setTransactionFlags(eTransactionFlushNeeded);
2510 }
2511
chaviw6b9ffea2021-11-08 09:25:48 -06002512 // This has to be called after latchBuffers because we want to include the layers that have
2513 // been latched in the commit callback
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002514 if (transactionsAreEmpty) {
chaviw6b9ffea2021-11-08 09:25:48 -06002515 // Invoke empty transaction callbacks early.
2516 mTransactionCallbackInvoker.sendCallbacks(false /* onCommitOnly */);
2517 } else {
2518 // Invoke OnCommit callbacks.
2519 mTransactionCallbackInvoker.sendCallbacks(true /* onCommitOnly */);
2520 }
Dan Stoza28d46a52020-04-28 09:54:54 -07002521 }
2522
2523 // Layers need to get updated (in the previous line) before we can use them for
2524 // choosing the refresh rate.
2525 // Hold mStateLock as chooseRefreshRateForContent promotes wp<Layer> to sp<Layer>
2526 // and may eventually call to ~Layer() if it holds the last reference
2527 {
Ady Abraham822ecbd2023-07-07 16:16:09 -07002528 bool updateAttachedChoreographer = mUpdateAttachedChoreographer;
2529 mUpdateAttachedChoreographer = false;
2530
Dominik Laskowskif8734e02022-08-26 09:06:59 -07002531 Mutex::Autolock lock(mStateLock);
Ady Abraham822ecbd2023-07-07 16:16:09 -07002532 mScheduler->chooseRefreshRateForContent(mLayerLifecycleManagerEnabled
2533 ? &mLayerHierarchyBuilder.getHierarchy()
2534 : nullptr,
2535 updateAttachedChoreographer);
Dominik Laskowskifdac5652023-06-29 12:01:13 -04002536 initiateDisplayModeChanges();
Dan Stoza28d46a52020-04-28 09:54:54 -07002537 }
2538
Dan Stoza28d46a52020-04-28 09:54:54 -07002539 updateCursorAsync();
Vishnu Naird2bfbb32023-07-18 00:45:45 +00002540 if (!mustComposite) {
2541 updateInputFlinger(vsyncId, pacesetterFrameTarget.frameBeginTime());
2542 }
Vishnu Nair1fe11172023-04-03 18:10:09 +00002543
Vishnu Nairb64a3b42022-01-13 15:29:32 -08002544 if (mLayerTracingEnabled && !mLayerTracing.flagIsSet(LayerTracing::TRACE_COMPOSITION)) {
2545 // This will block and tracing should only be enabled for debugging.
Dominik Laskowskib418dd72023-06-13 17:31:04 -04002546 addToLayerTracing(mVisibleRegionsDirty, pacesetterFrameTarget.frameBeginTime(), vsyncId);
Vishnu Nairb64a3b42022-01-13 15:29:32 -08002547 }
Pablo Gamito6be82442022-06-13 11:04:34 +00002548 mLastCommittedVsyncId = vsyncId;
Vishnu Nairb64a3b42022-01-13 15:29:32 -08002549
Dominik Laskowski298b08e2022-02-15 13:45:02 -08002550 persistDisplayBrightness(mustComposite);
Alec Mouricdf16792021-12-10 13:16:06 -08002551
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002552 return mustComposite && CC_LIKELY(mBootStage != BootStage::BOOTLOADER);
Dan Stoza28d46a52020-04-28 09:54:54 -07002553}
2554
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002555CompositeResultsPerDisplay SurfaceFlinger::composite(
2556 PhysicalDisplayId pacesetterId, const scheduler::FrameTargeters& frameTargeters) {
2557 const scheduler::FrameTarget& pacesetterTarget =
2558 frameTargeters.get(pacesetterId)->get()->target();
Dominik Laskowskib418dd72023-06-13 17:31:04 -04002559
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002560 const VsyncId vsyncId = pacesetterTarget.vsyncId();
Dominik Laskowski16a345b2023-04-27 17:07:33 -04002561 ATRACE_NAME(ftl::Concat(__func__, ' ', ftl::to_underlying(vsyncId)).c_str());
Dominik Laskowski298b08e2022-02-15 13:45:02 -08002562
Lloyd Piqueab039b52019-02-13 14:22:42 -08002563 compositionengine::CompositionRefreshArgs refreshArgs;
jimmyshiu4e211772023-06-15 15:18:38 +00002564 refreshArgs.powerCallback = this;
Dominik Laskowski298b08e2022-02-15 13:45:02 -08002565 const auto& displays = FTL_FAKE_GUARD(mStateLock, mDisplays);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002566 refreshArgs.outputs.reserve(displays.size());
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002567
2568 // Add outputs for physical displays.
2569 for (const auto& [id, targeter] : frameTargeters) {
2570 ftl::FakeGuard guard(mStateLock);
2571
2572 if (const auto display = getCompositionDisplayLocked(id)) {
2573 refreshArgs.outputs.push_back(display);
2574 }
2575 }
2576
Matt Buckley50c44062022-01-17 20:48:10 +00002577 std::vector<DisplayId> displayIds;
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002578 for (const auto& [_, display] : displays) {
Dominik Laskowskie85d7fa2023-05-15 10:50:22 -04002579 displayIds.push_back(display->getId());
Dominik Laskowskib418dd72023-06-13 17:31:04 -04002580 display->tracePowerMode();
2581
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002582 // Add outputs for virtual displays.
Dominik Laskowskib418dd72023-06-13 17:31:04 -04002583 if (display->isVirtual()) {
2584 const Fps refreshRate = display->getAdjustedRefreshRate();
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002585
2586 if (!refreshRate.isValid() ||
2587 mScheduler->isVsyncInPhase(pacesetterTarget.frameBeginTime(), refreshRate)) {
2588 refreshArgs.outputs.push_back(display->getCompositionDisplay());
Dominik Laskowskib418dd72023-06-13 17:31:04 -04002589 }
2590 }
Lloyd Piqueab039b52019-02-13 14:22:42 -08002591 }
Matt Buckley50c44062022-01-17 20:48:10 +00002592 mPowerAdvisor->setDisplays(displayIds);
Tianhao Yao67dd7122022-02-22 17:48:33 +00002593
Vishnu Nair0a4fb002022-08-08 02:40:42 +00002594 const bool updateTaskMetadata = mCompositionEngine->getFeatureFlags().test(
2595 compositionengine::Feature::kSnapshotLayerMetadata);
2596 if (updateTaskMetadata && (mVisibleRegionsDirty || mLayerMetadataSnapshotNeeded)) {
2597 updateLayerMetadataSnapshot();
2598 mLayerMetadataSnapshotNeeded = false;
2599 }
2600
Tianhao Yao67dd7122022-02-22 17:48:33 +00002601 if (DOES_CONTAIN_BORDER) {
2602 refreshArgs.borderInfoList.clear();
2603 mDrawingState.traverse([&refreshArgs](Layer* layer) {
2604 if (layer->isBorderEnabled()) {
2605 compositionengine::BorderRenderInfo info;
Tianhao Yao10cea3c2022-03-30 01:37:22 +00002606 info.width = layer->getBorderWidth();
2607 info.color = layer->getBorderColor();
Tianhao Yao67dd7122022-02-22 17:48:33 +00002608 layer->traverse(LayerVector::StateSet::Drawing, [&info](Layer* ilayer) {
2609 info.layerIds.push_back(ilayer->getSequence());
2610 });
2611 refreshArgs.borderInfoList.emplace_back(std::move(info));
2612 }
2613 });
2614 }
2615
Brian Lindahl439afad2022-11-14 11:16:55 -07002616 refreshArgs.bufferIdsToUncache = std::move(mBufferIdsToUncache);
2617
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002618 refreshArgs.layersWithQueuedFrames.reserve(mLayersWithQueuedFrames.size());
Alec Mouri5c9c9602020-09-01 15:10:40 -07002619 for (auto layer : mLayersWithQueuedFrames) {
Lloyd Piquede196652020-01-22 17:29:58 -08002620 if (auto layerFE = layer->getCompositionEngineLayerFE())
2621 refreshArgs.layersWithQueuedFrames.push_back(layerFE);
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002622 }
2623
Lloyd Pique6a3b4462019-03-07 20:58:12 -08002624 refreshArgs.outputColorSetting = useColorManagement
2625 ? mDisplayColorSetting
2626 : compositionengine::OutputColorSetting::kUnmanaged;
Lloyd Pique6a3b4462019-03-07 20:58:12 -08002627 refreshArgs.forceOutputColorMode = mForceColorMode;
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002628
2629 refreshArgs.updatingOutputGeometryThisFrame = mVisibleRegionsDirty;
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07002630 refreshArgs.updatingGeometryThisFrame = mGeometryDirty.exchange(false) || mVisibleRegionsDirty;
Leon Scroggins III85d4b222023-05-09 13:58:18 -04002631 refreshArgs.internalDisplayRotationFlags = getActiveDisplayRotationFlags();
Lloyd Pique3eb1b212019-03-07 21:15:40 -08002632
2633 if (CC_UNLIKELY(mDrawingState.colorMatrixChanged)) {
2634 refreshArgs.colorTransformMatrix = mDrawingState.colorMatrix;
2635 mDrawingState.colorMatrixChanged = false;
2636 }
2637
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07002638 refreshArgs.devOptForceClientComposition = mDebugDisableHWC;
Lloyd Pique3eb1b212019-03-07 21:15:40 -08002639
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07002640 if (mDebugFlashDelay != 0) {
2641 refreshArgs.devOptForceClientComposition = true;
2642 refreshArgs.devOptFlashDirtyRegionsDelay = std::chrono::milliseconds(mDebugFlashDelay);
Lloyd Piquef8cf14d2019-02-28 16:03:12 -08002643 }
Lloyd Piqueab039b52019-02-13 14:22:42 -08002644
Ady Abrahamf1db8032023-03-24 17:52:34 -07002645 const Period vsyncPeriod = mScheduler->getVsyncSchedule()->period();
Ady Abrahamf1db8032023-03-24 17:52:34 -07002646
Dominik Laskowski42ccc932023-04-20 10:08:04 -04002647 if (!getHwComposer().getComposer()->isSupported(
2648 Hwc2::Composer::OptionalFeature::ExpectedPresentTime) &&
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002649 pacesetterTarget.wouldPresentEarly(vsyncPeriod)) {
Dominik Laskowski42ccc932023-04-20 10:08:04 -04002650 const auto hwcMinWorkDuration = mVsyncConfiguration->getCurrentConfigs().hwcMinWorkDuration;
Ady Abrahamf1db8032023-03-24 17:52:34 -07002651
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002652 // TODO(b/255601557): Calculate and pass per-display values for each FrameTarget.
Dominik Laskowskib418dd72023-06-13 17:31:04 -04002653 refreshArgs.earliestPresentTime =
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002654 pacesetterTarget.previousFrameVsyncTime(vsyncPeriod) - hwcMinWorkDuration;
Ady Abrahamf1db8032023-03-24 17:52:34 -07002655 }
2656
Dominik Laskowski756b7892021-08-04 12:53:59 -07002657 refreshArgs.scheduledFrameTime = mScheduler->getScheduledFrameTime();
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002658 refreshArgs.expectedPresentTime = pacesetterTarget.expectedPresentTime().ns();
Chavi Weingarten545da0e2023-02-09 14:55:57 +00002659 refreshArgs.hasTrustedPresentationListener = mNumTrustedPresentationListeners > 0;
Ady Abraham3645e642021-04-20 18:39:00 -07002660
Ady Abraham3a77a7b2019-12-02 18:46:59 -08002661 // Store the present time just before calling to the composition engine so we could notify
2662 // the scheduler.
2663 const auto presentTime = systemTime();
2664
Dominik Laskowski16a345b2023-04-27 17:07:33 -04002665 constexpr bool kCursorOnly = false;
2666 const auto layers = moveSnapshotsToCompositionArgs(refreshArgs, kCursorOnly);
2667
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002668 mCompositionEngine->present(refreshArgs);
2669 moveSnapshotsFromCompositionArgs(refreshArgs, layers);
Matt Buckleyef51fba2021-10-12 19:30:12 +00002670
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002671 for (auto [layer, layerFE] : layers) {
2672 CompositionResult compositionResult{layerFE->stealCompositionResult()};
Vishnu Naire14c6b32022-08-06 04:20:15 +00002673 layer->onPreComposition(compositionResult.refreshStartTime);
Vishnu Nair7ee4f462023-04-19 09:54:09 -07002674 for (auto& [releaseFence, layerStack] : compositionResult.releaseFences) {
Vishnu Nair332e6ba2023-01-25 17:16:19 -08002675 Layer* clonedFrom = layer->getClonedFrom().get();
2676 auto owningLayer = clonedFrom ? clonedFrom : layer;
Vishnu Nair7ee4f462023-04-19 09:54:09 -07002677 owningLayer->onLayerDisplayed(std::move(releaseFence), layerStack);
Vishnu Naire14c6b32022-08-06 04:20:15 +00002678 }
2679 if (compositionResult.lastClientCompositionFence) {
2680 layer->setWasClientComposed(compositionResult.lastClientCompositionFence);
2681 }
2682 }
2683
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002684 mTimeStats->recordFrameDuration(pacesetterTarget.frameBeginTime().ns(), systemTime());
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002685
Dominik Laskowski61dfca42023-05-19 14:42:24 -04002686 // Send a power hint after presentation is finished.
Matt Buckley50c44062022-01-17 20:48:10 +00002687 if (mPowerHintSessionEnabled) {
Dominik Laskowski61dfca42023-05-19 14:42:24 -04002688 // Now that the current frame has been presented above, PowerAdvisor needs the present time
2689 // of the previous frame (whose fence is signaled by now) to determine how long the HWC had
2690 // waited on that fence to retire before presenting.
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002691 const auto& previousPresentFence = pacesetterTarget.presentFenceForPreviousFrame();
Dominik Laskowskie85d7fa2023-05-15 10:50:22 -04002692
Dominik Laskowski61dfca42023-05-19 14:42:24 -04002693 mPowerAdvisor->setSfPresentTiming(TimePoint::fromNs(previousPresentFence->getSignalTime()),
2694 TimePoint::now());
Matt Buckley0538cae2022-11-08 23:12:04 +00002695 mPowerAdvisor->reportActualWorkDuration();
Matt Buckley50c44062022-01-17 20:48:10 +00002696 }
2697
Dominik Laskowskidd5827a2022-03-17 12:44:23 -07002698 if (mScheduler->onPostComposition(presentTime)) {
2699 scheduleComposite(FrameHint::kNone);
2700 }
Ady Abraham3a77a7b2019-12-02 18:46:59 -08002701
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002702 postComposition(pacesetterId, frameTargeters, presentTime);
Jorim Jaggi9c03b502020-11-24 23:51:31 +01002703
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002704 const bool hadGpuComposited =
2705 multiDisplayUnion(mCompositionCoverage).test(CompositionCoverage::Gpu);
Dominik Laskowski63f12792023-01-21 16:58:22 -05002706 mCompositionCoverage.clear();
Alec Mouri8f7a0102020-04-15 12:11:10 -07002707
Vishnu Nair9cf89262022-02-26 09:17:49 -08002708 TimeStats::ClientCompositionRecord clientCompositionRecord;
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002709
Vishnu Nair9cf89262022-02-26 09:17:49 -08002710 for (const auto& [_, display] : displays) {
2711 const auto& state = display->getCompositionDisplay()->getState();
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002712 CompositionCoverageFlags& flags =
2713 mCompositionCoverage.try_emplace(display->getId()).first->second;
Dominik Laskowski63f12792023-01-21 16:58:22 -05002714
2715 if (state.usesDeviceComposition) {
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002716 flags |= CompositionCoverage::Hwc;
Dominik Laskowski63f12792023-01-21 16:58:22 -05002717 }
2718
2719 if (state.reusedClientComposition) {
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002720 flags |= CompositionCoverage::GpuReuse;
Dominik Laskowski63f12792023-01-21 16:58:22 -05002721 } else if (state.usesClientComposition) {
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002722 flags |= CompositionCoverage::Gpu;
Dominik Laskowski63f12792023-01-21 16:58:22 -05002723 }
2724
Vishnu Nair9cf89262022-02-26 09:17:49 -08002725 clientCompositionRecord.predicted |=
2726 (state.strategyPrediction != CompositionStrategyPredictionState::DISABLED);
2727 clientCompositionRecord.predictionSucceeded |=
2728 (state.strategyPrediction == CompositionStrategyPredictionState::SUCCESS);
Alec Mouri8f7a0102020-04-15 12:11:10 -07002729 }
2730
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002731 const auto coverage = multiDisplayUnion(mCompositionCoverage);
2732 const bool hasGpuComposited = coverage.test(CompositionCoverage::Gpu);
Dominik Laskowski63f12792023-01-21 16:58:22 -05002733
2734 clientCompositionRecord.hadClientComposition = hasGpuComposited;
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002735 clientCompositionRecord.reused = coverage.test(CompositionCoverage::GpuReuse);
Dominik Laskowski63f12792023-01-21 16:58:22 -05002736 clientCompositionRecord.changed = hadGpuComposited != hasGpuComposited;
2737
Vishnu Nair9cf89262022-02-26 09:17:49 -08002738 mTimeStats->pushCompositionStrategyState(clientCompositionRecord);
2739
Dominik Laskowski63f12792023-01-21 16:58:22 -05002740 using namespace ftl::flag_operators;
2741
2742 // TODO(b/160583065): Enable skip validation when SF caches all client composition layers.
2743 const bool hasGpuUseOrReuse =
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002744 coverage.any(CompositionCoverage::Gpu | CompositionCoverage::GpuReuse);
Leon Scroggins III67388622023-02-06 20:36:20 -05002745 mScheduler->modulateVsync({}, &VsyncModulator::onDisplayRefresh, hasGpuUseOrReuse);
Dan Stoza14cd37c2015-07-09 12:43:33 -07002746
David Sodman7e4ae112018-02-09 15:02:28 -08002747 mLayersWithQueuedFrames.clear();
Vishnu Nair6f209e22023-08-04 16:33:23 +00002748 mLayersIdsWithQueuedFrames.clear();
Vishnu Nairb64a3b42022-01-13 15:29:32 -08002749 if (mLayerTracingEnabled && mLayerTracing.flagIsSet(LayerTracing::TRACE_COMPOSITION)) {
Vishnu Nair00b90132021-11-05 14:03:40 -07002750 // This will block and should only be used for debugging.
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002751 addToLayerTracing(mVisibleRegionsDirty, pacesetterTarget.frameBeginTime(), vsyncId);
Vishnu Nairdf529052019-06-07 14:53:14 -07002752 }
Robert Carr167bdde2021-07-28 11:26:51 -07002753
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002754 updateInputFlinger(vsyncId, pacesetterTarget.frameBeginTime());
Vishnu Naird2bfbb32023-07-18 00:45:45 +00002755
John Reck68796592023-01-25 13:47:12 -05002756 if (mVisibleRegionsDirty) mHdrLayerInfoChanged = true;
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07002757 mVisibleRegionsDirty = false;
Lloyd Piqueab039b52019-02-13 14:22:42 -08002758
2759 if (mCompositionEngine->needsAnotherUpdate()) {
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002760 scheduleCommit(FrameHint::kNone);
Lloyd Piqueab039b52019-02-13 14:22:42 -08002761 }
Matt Buckleyef51fba2021-10-12 19:30:12 +00002762
Matt Buckley50c44062022-01-17 20:48:10 +00002763 if (mPowerHintSessionEnabled) {
Matt Buckley2fa85012022-08-30 22:38:45 +00002764 mPowerAdvisor->setCompositeEnd(TimePoint::now());
Matt Buckleyef51fba2021-10-12 19:30:12 +00002765 }
Dominik Laskowskib418dd72023-06-13 17:31:04 -04002766
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002767 CompositeResultsPerDisplay resultsPerDisplay;
2768
2769 // Filter out virtual displays.
2770 for (const auto& [id, coverage] : mCompositionCoverage) {
2771 if (const auto idOpt = PhysicalDisplayId::tryCast(id)) {
2772 resultsPerDisplay.try_emplace(*idOpt, CompositeResult{coverage});
2773 }
2774 }
2775
2776 return resultsPerDisplay;
Mathias Agopiancd60f992012-08-16 16:28:27 -07002777}
Mathias Agopian4fec8732012-06-29 14:12:52 -07002778
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002779void SurfaceFlinger::updateLayerGeometry() {
David Sodmanfa9b2af2017-12-24 13:28:59 -08002780 ATRACE_CALL();
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07002781
Vishnu Nair4351ad52019-02-11 14:13:02 -08002782 if (mVisibleRegionsDirty) {
2783 computeLayerBounds();
2784 }
2785
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002786 for (auto& layer : mLayersPendingRefresh) {
2787 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002788 visibleReg.set(layer->getScreenBounds());
Vishnu Nair3af0ec02023-02-10 04:13:48 +00002789 invalidateLayerStack(layer->getOutputFilter(), visibleReg);
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002790 }
2791 mLayersPendingRefresh.clear();
Mathias Agopian4fec8732012-06-29 14:12:52 -07002792}
2793
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00002794bool SurfaceFlinger::isHdrLayer(const frontend::LayerSnapshot& snapshot) const {
John Reck68796592023-01-25 13:47:12 -05002795 // Even though the camera layer may be using an HDR transfer function or otherwise be "HDR"
2796 // the device may need to avoid boosting the brightness as a result of these layers to
2797 // reduce power consumption during camera recording
Lloyd Pique30db6402023-06-26 18:56:51 +00002798 if (mIgnoreHdrCameraLayers) {
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00002799 if (snapshot.externalTexture &&
2800 (snapshot.externalTexture->getUsage() & GRALLOC_USAGE_HW_CAMERA_WRITE) != 0) {
John Reck49d9ad32022-02-23 19:03:31 -05002801 return false;
2802 }
2803 }
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00002804 if (isHdrDataspace(snapshot.dataspace)) {
John Reck68796592023-01-25 13:47:12 -05002805 return true;
2806 }
2807 // If the layer is not allowed to be dimmed, treat it as HDR. WindowManager may disable
2808 // dimming in order to keep animations invoking SDR screenshots of HDR layers seamless.
2809 // Treat such tagged layers as HDR so that DisplayManagerService does not try to change
2810 // the screen brightness
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00002811 if (!snapshot.dimmingEnabled) {
John Reck68796592023-01-25 13:47:12 -05002812 return true;
2813 }
2814 // RANGE_EXTENDED layers may identify themselves as being "HDR" via a desired sdr/hdr ratio
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00002815 if ((snapshot.dataspace & (int32_t)Dataspace::RANGE_MASK) ==
John Reck68796592023-01-25 13:47:12 -05002816 (int32_t)Dataspace::RANGE_EXTENDED &&
Sally Qi963049b2023-03-23 14:06:21 -07002817 snapshot.desiredHdrSdrRatio > 1.01f) {
John Reck68796592023-01-25 13:47:12 -05002818 return true;
2819 }
2820 return false;
John Reck49d9ad32022-02-23 19:03:31 -05002821}
2822
ramindani06e518e2022-03-14 18:47:53 +00002823ui::Rotation SurfaceFlinger::getPhysicalDisplayOrientation(DisplayId displayId,
2824 bool isPrimary) const {
2825 const auto id = PhysicalDisplayId::tryCast(displayId);
2826 if (!id) {
2827 return ui::ROTATION_0;
2828 }
Lloyd Pique30db6402023-06-26 18:56:51 +00002829 if (!mIgnoreHwcPhysicalDisplayOrientation &&
Neha Jain7b31cca2023-01-09 23:10:42 +00002830 getHwComposer().getComposer()->isSupported(
ramindani06e518e2022-03-14 18:47:53 +00002831 Hwc2::Composer::OptionalFeature::PhysicalDisplayOrientation)) {
2832 switch (getHwComposer().getPhysicalDisplayOrientation(*id)) {
2833 case Hwc2::AidlTransform::ROT_90:
2834 return ui::ROTATION_90;
2835 case Hwc2::AidlTransform::ROT_180:
2836 return ui::ROTATION_180;
2837 case Hwc2::AidlTransform::ROT_270:
2838 return ui::ROTATION_270;
2839 default:
2840 return ui::ROTATION_0;
2841 }
2842 }
2843
2844 if (isPrimary) {
2845 using Values = SurfaceFlingerProperties::primary_display_orientation_values;
2846 switch (primary_display_orientation(Values::ORIENTATION_0)) {
2847 case Values::ORIENTATION_90:
2848 return ui::ROTATION_90;
2849 case Values::ORIENTATION_180:
2850 return ui::ROTATION_180;
2851 case Values::ORIENTATION_270:
2852 return ui::ROTATION_270;
2853 default:
2854 break;
2855 }
2856 }
2857 return ui::ROTATION_0;
2858}
2859
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002860void SurfaceFlinger::postComposition(PhysicalDisplayId pacesetterId,
2861 const scheduler::FrameTargeters& frameTargeters,
Dominik Laskowskib418dd72023-06-13 17:31:04 -04002862 nsecs_t presentStartTime) {
Dan Stoza9e56aa02015-11-02 13:00:03 -08002863 ATRACE_CALL();
Dominik Laskowski8792c112022-07-12 09:03:39 -07002864 ALOGV(__func__);
Dan Stoza9e56aa02015-11-02 13:00:03 -08002865
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002866 ui::PhysicalDisplayMap<PhysicalDisplayId, std::shared_ptr<FenceTime>> presentFences;
2867 ui::PhysicalDisplayMap<PhysicalDisplayId, const sp<Fence>> gpuCompositionDoneFences;
Brian Anderson3d4039d2016-09-23 16:31:30 -07002868
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002869 for (const auto& [id, targeter] : frameTargeters) {
2870 auto presentFence = getHwComposer().getPresentFence(id);
2871
2872 if (id == pacesetterId) {
2873 mTransactionCallbackInvoker.addPresentFence(presentFence);
2874 }
2875
2876 if (auto fenceTime = targeter->setPresentFence(std::move(presentFence));
2877 fenceTime->isValid()) {
2878 presentFences.try_emplace(id, std::move(fenceTime));
2879 }
2880
2881 ftl::FakeGuard guard(mStateLock);
2882 if (const auto display = getCompositionDisplayLocked(id);
2883 display && display->getState().usesClientComposition) {
2884 gpuCompositionDoneFences
2885 .try_emplace(id, display->getRenderSurface()->getClientTargetAcquireFence());
2886 }
Brian Anderson3d4039d2016-09-23 16:31:30 -07002887 }
Brian Anderson3d4039d2016-09-23 16:31:30 -07002888
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002889 const auto pacesetterDisplay = FTL_FAKE_GUARD(mStateLock, getDisplayDeviceLocked(pacesetterId));
Dominik Laskowski8792c112022-07-12 09:03:39 -07002890
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002891 std::shared_ptr<FenceTime> pacesetterPresentFenceTime =
2892 presentFences.get(pacesetterId)
2893 .transform([](const FenceTimePtr& ptr) { return ptr; })
2894 .value_or(FenceTime::NO_FENCE);
2895
2896 std::shared_ptr<FenceTime> pacesetterGpuCompositionDoneFenceTime =
2897 gpuCompositionDoneFences.get(pacesetterId)
2898 .transform([](sp<Fence> fence) {
2899 return std::make_shared<FenceTime>(std::move(fence));
2900 })
2901 .value_or(FenceTime::NO_FENCE);
2902
Matt Buckley2fa85012022-08-30 22:38:45 +00002903 const TimePoint presentTime = TimePoint::now();
Vishnu Nair9a69a042021-06-18 13:19:49 -07002904
Jorim Jaggi8d34c902020-12-16 21:43:07 +01002905 // Set presentation information before calling Layer::releasePendingBuffer, such that jank
2906 // information from previous' frame classification is already available when sending jank info
2907 // to clients, so they get jank classification as early as possible.
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002908 mFrameTimeline->setSfPresent(presentTime.ns(), pacesetterPresentFenceTime,
2909 pacesetterGpuCompositionDoneFenceTime);
Jorim Jaggi8d34c902020-12-16 21:43:07 +01002910
Lloyd Piqueab039b52019-02-13 14:22:42 -08002911 // We use the CompositionEngine::getLastFrameRefreshTimestamp() which might
2912 // be sampled a little later than when we started doing work for this frame,
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07002913 // but that should be okay since CompositorTiming has snapping logic.
Dominik Laskowski80c77272022-07-08 12:47:29 -07002914 const TimePoint compositeTime =
2915 TimePoint::fromNs(mCompositionEngine->getLastFrameRefreshTimestamp());
2916 const Duration presentLatency =
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002917 getHwComposer().hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)
2918 ? Duration::zero()
2919 : mPresentLatencyTracker.trackPendingFrame(compositeTime, pacesetterPresentFenceTime);
Dominik Laskowski5d164f22022-07-07 07:56:07 -07002920
Leon Scroggins III67388622023-02-06 20:36:20 -05002921 const auto schedule = mScheduler->getVsyncSchedule();
2922 const TimePoint vsyncDeadline = schedule->vsyncDeadlineAfter(presentTime);
2923 const Period vsyncPeriod = schedule->period();
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07002924 const nsecs_t vsyncPhase = mVsyncConfiguration->getCurrentConfigs().late.sfOffset;
Dominik Laskowski5d164f22022-07-07 07:56:07 -07002925
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -07002926 const CompositorTiming compositorTiming(vsyncDeadline.ns(), vsyncPeriod.ns(), vsyncPhase,
Dominik Laskowski80c77272022-07-08 12:47:29 -07002927 presentLatency.ns());
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002928
Dominik Laskowski6b049ff2023-01-29 15:46:45 -05002929 ui::DisplayMap<ui::LayerStack, const DisplayDevice*> layerStackToDisplay;
Vishnu Nair7ee4f462023-04-19 09:54:09 -07002930 {
2931 if (!mLayersWithBuffersRemoved.empty() || mNumTrustedPresentationListeners > 0) {
2932 Mutex::Autolock lock(mStateLock);
2933 for (const auto& [token, display] : mDisplays) {
2934 layerStackToDisplay.emplace_or_replace(display->getLayerStack(), display.get());
2935 }
2936 }
2937 }
2938
2939 for (auto layer : mLayersWithBuffersRemoved) {
Vishnu Nairf10a87b2023-05-01 14:02:51 -07002940 std::vector<ui::LayerStack> previouslyPresentedLayerStacks =
2941 std::move(layer->mPreviouslyPresentedLayerStacks);
2942 layer->mPreviouslyPresentedLayerStacks.clear();
2943 for (auto layerStack : previouslyPresentedLayerStacks) {
Vishnu Nair7ee4f462023-04-19 09:54:09 -07002944 auto optDisplay = layerStackToDisplay.get(layerStack);
2945 if (optDisplay && !optDisplay->get()->isVirtual()) {
2946 auto fence = getHwComposer().getPresentFence(optDisplay->get()->getPhysicalId());
2947 layer->onLayerDisplayed(ftl::yield<FenceResult>(fence).share(),
2948 ui::INVALID_LAYER_STACK);
2949 }
2950 }
2951 layer->releasePendingBuffer(presentTime.ns());
2952 }
2953 mLayersWithBuffersRemoved.clear();
2954
Robert Carrc747ad02021-06-11 14:01:24 -07002955 for (const auto& layer: mLayersWithQueuedFrames) {
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05002956 layer->onPostComposition(pacesetterDisplay.get(), pacesetterGpuCompositionDoneFenceTime,
2957 pacesetterPresentFenceTime, compositorTiming);
Dominik Laskowski8792c112022-07-12 09:03:39 -07002958 layer->releasePendingBuffer(presentTime.ns());
Robert Carrc747ad02021-06-11 14:01:24 -07002959 }
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002960
John Reck88270902021-03-18 11:27:35 -04002961 std::vector<std::pair<std::shared_ptr<compositionengine::Display>, sp<HdrLayerInfoReporter>>>
2962 hdrInfoListeners;
Robert Carr167bdde2021-07-28 11:26:51 -07002963 bool haveNewListeners = false;
Alec Mouriadebf5c2021-01-05 12:57:36 -08002964 {
2965 Mutex::Autolock lock(mStateLock);
2966 if (mFpsReporter) {
2967 mFpsReporter->dispatchLayerFps();
2968 }
Galia Peycheva8f04b302021-04-27 13:25:38 +02002969
2970 if (mTunnelModeEnabledReporter) {
2971 mTunnelModeEnabledReporter->updateTunnelModeStatus();
2972 }
John Reck88270902021-03-18 11:27:35 -04002973 hdrInfoListeners.reserve(mHdrLayerInfoListeners.size());
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -07002974 for (const auto& [displayId, reporter] : mHdrLayerInfoListeners) {
2975 if (reporter && reporter->hasListeners()) {
2976 if (const auto display = getDisplayDeviceLocked(displayId)) {
2977 hdrInfoListeners.emplace_back(display->getCompositionDisplay(), reporter);
John Reck88270902021-03-18 11:27:35 -04002978 }
2979 }
2980 }
Robert Carr167bdde2021-07-28 11:26:51 -07002981 haveNewListeners = mAddingHDRLayerInfoListener; // grab this with state lock
2982 mAddingHDRLayerInfoListener = false;
John Reck88270902021-03-18 11:27:35 -04002983 }
2984
John Reck68796592023-01-25 13:47:12 -05002985 if (haveNewListeners || mHdrLayerInfoChanged) {
Robert Carr167bdde2021-07-28 11:26:51 -07002986 for (auto& [compositionDisplay, listener] : hdrInfoListeners) {
2987 HdrLayerInfoReporter::HdrLayerInfo info;
2988 int32_t maxArea = 0;
Vishnu Nair9a5463a2023-06-17 12:18:36 -07002989 auto updateInfoFn =
2990 [&](const std::shared_ptr<compositionengine::Display>& compositionDisplay,
2991 const frontend::LayerSnapshot& snapshot, const sp<LayerFE>& layerFe) {
2992 if (snapshot.isVisible &&
2993 compositionDisplay->includesLayer(snapshot.outputFilter)) {
2994 if (isHdrLayer(snapshot)) {
2995 const auto* outputLayer =
2996 compositionDisplay->getOutputLayerForLayer(layerFe);
2997 if (outputLayer) {
2998 const float desiredHdrSdrRatio =
2999 snapshot.desiredHdrSdrRatio <= 1.f
3000 ? std::numeric_limits<float>::infinity()
3001 : snapshot.desiredHdrSdrRatio;
3002 info.mergeDesiredRatio(desiredHdrSdrRatio);
3003 info.numberOfHdrLayers++;
3004 const auto displayFrame = outputLayer->getState().displayFrame;
3005 const int32_t area =
3006 displayFrame.width() * displayFrame.height();
3007 if (area > maxArea) {
3008 maxArea = area;
3009 info.maxW = displayFrame.width();
3010 info.maxH = displayFrame.height();
3011 }
3012 }
Robert Carr167bdde2021-07-28 11:26:51 -07003013 }
John Reckdb1a16b2021-07-09 13:05:52 -04003014 }
Vishnu Nair9a5463a2023-06-17 12:18:36 -07003015 };
3016
Lloyd Pique30db6402023-06-26 18:56:51 +00003017 if (mLayerLifecycleManagerEnabled) {
Vishnu Nair9a5463a2023-06-17 12:18:36 -07003018 mLayerSnapshotBuilder.forEachVisibleSnapshot(
3019 [&, compositionDisplay = compositionDisplay](
3020 std::unique_ptr<frontend::LayerSnapshot>& snapshot) {
3021 auto it = mLegacyLayers.find(snapshot->sequence);
3022 LOG_ALWAYS_FATAL_IF(it == mLegacyLayers.end(),
3023 "Couldnt find layer object for %s",
3024 snapshot->getDebugString().c_str());
3025 auto& legacyLayer = it->second;
3026 sp<LayerFE> layerFe =
3027 legacyLayer->getCompositionEngineLayerFE(snapshot->path);
3028
3029 updateInfoFn(compositionDisplay, *snapshot, layerFe);
3030 });
3031 } else {
3032 mDrawingState.traverse([&, compositionDisplay = compositionDisplay](Layer* layer) {
3033 const auto layerFe = layer->getCompositionEngineLayerFE();
3034 const frontend::LayerSnapshot& snapshot = *layer->getLayerSnapshot();
3035 updateInfoFn(compositionDisplay, snapshot, layerFe);
3036 });
3037 }
Robert Carr167bdde2021-07-28 11:26:51 -07003038 listener->dispatchHdrLayerInfo(info);
3039 }
Alec Mouriadebf5c2021-01-05 12:57:36 -08003040 }
3041
John Reck68796592023-01-25 13:47:12 -05003042 mHdrLayerInfoChanged = false;
Robert Carr167bdde2021-07-28 11:26:51 -07003043
Vishnu Nair1fe11172023-04-03 18:10:09 +00003044 mTransactionCallbackInvoker.sendCallbacks(false /* onCommitOnly */);
3045 mTransactionCallbackInvoker.clearCompletedTransactions();
3046
Dominik Laskowski8792c112022-07-12 09:03:39 -07003047 mTimeStats->incrementTotalFrames();
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05003048 mTimeStats->setPresentFenceGlobal(pacesetterPresentFenceTime);
Dominik Laskowski8792c112022-07-12 09:03:39 -07003049
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05003050 for (auto&& [id, presentFence] : presentFences) {
Leon Scroggins III67388622023-02-06 20:36:20 -05003051 ftl::FakeGuard guard(mStateLock);
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05003052 const bool isInternalDisplay =
3053 mPhysicalDisplays.get(id).transform(&PhysicalDisplay::isInternal).value_or(false);
3054
3055 if (isInternalDisplay) {
3056 mScheduler->addPresentFence(id, std::move(presentFence));
Leon Scroggins III67388622023-02-06 20:36:20 -05003057 }
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07003058 }
3059
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05003060 const bool hasPacesetterDisplay =
3061 pacesetterDisplay && getHwComposer().isConnected(pacesetterId);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07003062
Lloyd Pique30db6402023-06-26 18:56:51 +00003063 if (!hasSyncFramework) {
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05003064 if (hasPacesetterDisplay && pacesetterDisplay->isPoweredOn()) {
3065 mScheduler->enableHardwareVsync(pacesetterId);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07003066 }
3067 }
3068
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05003069 if (hasPacesetterDisplay && !pacesetterDisplay->isPoweredOn()) {
Lars Svenssond9e54692021-12-21 07:41:57 +01003070 getRenderEngine().cleanupPostRender();
Dan Stozab90cf072015-03-05 11:05:59 -08003071 return;
3072 }
3073
Lingfeng Yang2e4fef62020-04-24 14:48:43 +00003074 // Cleanup any outstanding resources due to rendering a prior frame.
3075 getRenderEngine().cleanupPostRender();
3076
Dan Stoza436ccf32018-06-21 12:10:12 -07003077 {
3078 std::lock_guard lock(mTexturePoolMutex);
Dan Stoza67765d82019-05-07 14:58:27 -07003079 if (mTexturePool.size() < mTexturePoolSize) {
3080 const size_t refillCount = mTexturePoolSize - mTexturePool.size();
Dan Stoza436ccf32018-06-21 12:10:12 -07003081 const size_t offset = mTexturePool.size();
3082 mTexturePool.resize(mTexturePoolSize);
3083 getRenderEngine().genTextures(refillCount, mTexturePool.data() + offset);
3084 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Dan Stoza67765d82019-05-07 14:58:27 -07003085 } else if (mTexturePool.size() > mTexturePoolSize) {
3086 const size_t deleteCount = mTexturePool.size() - mTexturePoolSize;
3087 const size_t offset = mTexturePoolSize;
3088 getRenderEngine().deleteTextures(deleteCount, mTexturePool.data() + offset);
3089 mTexturePool.resize(mTexturePoolSize);
3090 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Dan Stoza436ccf32018-06-21 12:10:12 -07003091 }
3092 }
Marissa Walle2ffb422018-10-12 11:33:52 -07003093
Chavi Weingarten076acac2023-01-19 17:20:43 +00003094 if (mNumTrustedPresentationListeners > 0) {
3095 // We avoid any reverse traversal upwards so this shouldn't be too expensive
Vishnu Naird47bcee2023-02-24 18:08:51 +00003096 traverseLegacyLayers([&](Layer* layer) {
Chavi Weingarten076acac2023-01-19 17:20:43 +00003097 if (!layer->hasTrustedPresentationListener()) {
3098 return;
3099 }
Lloyd Pique30db6402023-06-26 18:56:51 +00003100 const frontend::LayerSnapshot* snapshot = mLayerLifecycleManagerEnabled
Vishnu Naird47bcee2023-02-24 18:08:51 +00003101 ? mLayerSnapshotBuilder.getSnapshot(layer->sequence)
3102 : layer->getLayerSnapshot();
3103 std::optional<const DisplayDevice*> displayOpt = std::nullopt;
3104 if (snapshot) {
3105 displayOpt = layerStackToDisplay.get(snapshot->outputFilter.layerStack);
3106 }
Vishnu Nairfad494c2023-02-01 19:52:54 +00003107 const DisplayDevice* display = displayOpt.value_or(nullptr);
Vishnu Naird47bcee2023-02-24 18:08:51 +00003108 layer->updateTrustedPresentationState(display, snapshot,
Dominik Laskowskib418dd72023-06-13 17:31:04 -04003109 nanoseconds_to_milliseconds(presentStartTime),
3110 false);
Chavi Weingarten076acac2023-01-19 17:20:43 +00003111 });
3112 }
3113
Dan Stoza45de5ba2019-04-25 14:12:09 -07003114 // Even though ATRACE_INT64 already checks if tracing is enabled, it doesn't prevent the
3115 // side-effect of getTotalSize(), so we check that again here
3116 if (ATRACE_ENABLED()) {
Marissa Wall22b2de12019-12-02 18:11:43 -08003117 // getTotalSize returns the total number of buffers that were allocated by SurfaceFlinger
Dan Stoza45de5ba2019-04-25 14:12:09 -07003118 ATRACE_INT64("Total Buffer Size", GraphicBufferAllocator::get().getTotalSize());
3119 }
Dominik Laskowski8792c112022-07-12 09:03:39 -07003120
3121 logFrameStats(presentTime);
Mathias Agopiancd60f992012-08-16 16:28:27 -07003122}
3123
chaviw79468ab2021-10-27 11:11:24 -05003124FloatRect SurfaceFlinger::getMaxDisplayBounds() {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08003125 const ui::Size maxSize = [this] {
3126 ftl::FakeGuard guard(mStateLock);
Vishnu Nairf6f56952022-03-01 20:29:46 -08003127
Dominik Laskowski298b08e2022-02-15 13:45:02 -08003128 // The LayerTraceGenerator tool runs without displays.
3129 if (mDisplays.empty()) return ui::Size{5000, 5000};
Vishnu Nairf6f56952022-03-01 20:29:46 -08003130
Dominik Laskowski298b08e2022-02-15 13:45:02 -08003131 return std::accumulate(mDisplays.begin(), mDisplays.end(), ui::kEmptySize,
3132 [](ui::Size size, const auto& pair) -> ui::Size {
3133 const auto& display = pair.second;
3134 return {std::max(size.getWidth(), display->getWidth()),
3135 std::max(size.getHeight(), display->getHeight())};
3136 });
3137 }();
chaviwb09c6552021-08-12 17:20:43 -05003138
3139 // Ignore display bounds for now since they will be computed later. Use a large Rect bound
3140 // to ensure it's bigger than an actual display will be.
Dominik Laskowski298b08e2022-02-15 13:45:02 -08003141 const float xMax = maxSize.getWidth() * 10.f;
3142 const float yMax = maxSize.getHeight() * 10.f;
3143
3144 return {-xMax, -yMax, xMax, yMax};
chaviw79468ab2021-10-27 11:11:24 -05003145}
3146
3147void SurfaceFlinger::computeLayerBounds() {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08003148 const FloatRect maxBounds = getMaxDisplayBounds();
chaviwb09c6552021-08-12 17:20:43 -05003149 for (const auto& layer : mDrawingState.layersSortedByZ) {
3150 layer->computeBounds(maxBounds, ui::Transform(), 0.f /* shadowRadius */);
Vishnu Nair4351ad52019-02-11 14:13:02 -08003151 }
3152}
3153
Dominik Laskowski9e168db2021-05-27 16:05:12 -07003154void SurfaceFlinger::commitTransactions() {
Mathias Agopian841cde52012-03-01 15:44:37 -08003155 ATRACE_CALL();
3156
Dominik Laskowski9e168db2021-05-27 16:05:12 -07003157 // Keep a copy of the drawing state (that is going to be overwritten
3158 // by commitTransactionsLocked) outside of mStateLock so that the side
3159 // effects of the State assignment don't happen with mStateLock held,
3160 // which can cause deadlocks.
Mathias Agopian7cc6df52013-06-05 14:30:54 -07003161 State drawingState(mDrawingState);
3162
Dominik Laskowski9e168db2021-05-27 16:05:12 -07003163 Mutex::Autolock lock(mStateLock);
Dominik Laskowski9dab3432019-03-27 13:21:10 -07003164 mDebugInTransaction = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003165
Mathias Agopianca4d3602011-05-19 15:38:14 -07003166 // Here we're guaranteed that some transaction flags are set
Dominik Laskowski9e168db2021-05-27 16:05:12 -07003167 // so we can call commitTransactionsLocked unconditionally.
3168 // We clear the flags with mStateLock held to guarantee that
3169 // mCurrentState won't change until the transaction is committed.
Leon Scroggins III67388622023-02-06 20:36:20 -05003170 mScheduler->modulateVsync({}, &VsyncModulator::onTransactionCommit);
Dominik Laskowski9e168db2021-05-27 16:05:12 -07003171 commitTransactionsLocked(clearTransactionFlags(eTransactionMask));
Mathias Agopiandea20b12011-05-03 17:04:02 -07003172
Mathias Agopianca4d3602011-05-19 15:38:14 -07003173 mDebugInTransaction = 0;
Mathias Agopian3d579642009-06-04 18:46:21 -07003174}
3175
Dominik Laskowskib0054a22022-03-03 09:03:06 -08003176std::pair<DisplayModes, DisplayModePtr> SurfaceFlinger::loadDisplayModes(
3177 PhysicalDisplayId displayId) const {
Marin Shalamanovd3b5c5d2021-02-11 18:26:14 +01003178 std::vector<HWComposer::HWCDisplayMode> hwcModes;
3179 std::optional<hal::HWDisplayId> activeModeHwcId;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08003180
Marin Shalamanovd3b5c5d2021-02-11 18:26:14 +01003181 int attempt = 0;
3182 constexpr int kMaxAttempts = 3;
3183 do {
ramindani263a3f12023-07-18 20:44:49 -07003184 hwcModes = getHwComposer().getModes(displayId,
3185 scheduler::RefreshRateSelector::kMinSupportedFrameRate
3186 .getPeriodNsecs());
Marin Shalamanovd3b5c5d2021-02-11 18:26:14 +01003187 activeModeHwcId = getHwComposer().getActiveMode(displayId);
Marin Shalamanovd3b5c5d2021-02-11 18:26:14 +01003188
Dominik Laskowskib0054a22022-03-03 09:03:06 -08003189 const auto isActiveMode = [activeModeHwcId](const HWComposer::HWCDisplayMode& mode) {
Dominik Laskowskibab51282022-08-12 09:28:55 -07003190 return mode.hwcId == activeModeHwcId;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08003191 };
3192
3193 if (std::any_of(hwcModes.begin(), hwcModes.end(), isActiveMode)) {
3194 break;
3195 }
3196 } while (++attempt < kMaxAttempts);
3197
Dominik Laskowskibab51282022-08-12 09:28:55 -07003198 if (attempt == kMaxAttempts) {
3199 const std::string activeMode =
3200 activeModeHwcId ? std::to_string(*activeModeHwcId) : "unknown"s;
3201 ALOGE("HWC failed to report an active mode that is supported: activeModeHwcId=%s, "
3202 "hwcModes={%s}",
3203 activeMode.c_str(), base::Join(hwcModes, ", ").c_str());
3204 return {};
3205 }
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01003206
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07003207 const DisplayModes oldModes = mPhysicalDisplays.get(displayId)
3208 .transform([](const PhysicalDisplay& display) {
3209 return display.snapshot().displayModes();
3210 })
3211 .value_or(DisplayModes{});
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01003212
Dominik Laskowskib0054a22022-03-03 09:03:06 -08003213 ui::DisplayModeId nextModeId = 1 +
3214 std::accumulate(oldModes.begin(), oldModes.end(), static_cast<ui::DisplayModeId>(-1),
3215 [](ui::DisplayModeId max, const auto& pair) {
3216 return std::max(max, pair.first.value());
3217 });
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01003218
3219 DisplayModes newModes;
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01003220 for (const auto& hwcMode : hwcModes) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08003221 const DisplayModeId id{nextModeId++};
3222 newModes.try_emplace(id,
3223 DisplayMode::Builder(hwcMode.hwcId)
3224 .setId(id)
3225 .setPhysicalDisplayId(displayId)
3226 .setResolution({hwcMode.width, hwcMode.height})
3227 .setVsyncPeriod(hwcMode.vsyncPeriod)
3228 .setDpiX(hwcMode.dpiX)
3229 .setDpiY(hwcMode.dpiY)
3230 .setGroup(hwcMode.configGroup)
3231 .build());
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01003232 }
3233
Dominik Laskowskib0054a22022-03-03 09:03:06 -08003234 const bool sameModes =
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01003235 std::equal(newModes.begin(), newModes.end(), oldModes.begin(), oldModes.end(),
Dominik Laskowskib0054a22022-03-03 09:03:06 -08003236 [](const auto& lhs, const auto& rhs) {
3237 return equalsExceptDisplayModeId(*lhs.second, *rhs.second);
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01003238 });
3239
Dominik Laskowskib0054a22022-03-03 09:03:06 -08003240 // Keep IDs if modes have not changed.
3241 const auto& modes = sameModes ? oldModes : newModes;
3242 const DisplayModePtr activeMode =
3243 std::find_if(modes.begin(), modes.end(), [activeModeHwcId](const auto& pair) {
3244 return pair.second->getHwcId() == activeModeHwcId;
3245 })->second;
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01003246
Dominik Laskowskib0054a22022-03-03 09:03:06 -08003247 return {modes, activeMode};
Marin Shalamanov045b7002021-01-07 16:56:24 +01003248}
3249
Dominik Laskowskif11728a2022-07-28 13:07:42 -07003250bool SurfaceFlinger::configureLocked() {
3251 std::vector<HotplugEvent> events;
3252 {
3253 std::lock_guard<std::mutex> lock(mHotplugMutex);
3254 events = std::move(mPendingHotplugEvents);
3255 }
3256
Dominik Laskowskibb66e632022-08-17 08:00:25 -07003257 for (const auto [hwcDisplayId, connection] : events) {
3258 if (auto info = getHwComposer().onHotplug(hwcDisplayId, connection)) {
3259 const auto displayId = info->id;
3260 const bool connected = connection == hal::Connection::CONNECTED;
Lloyd Piqueba04e622017-12-14 17:11:26 -08003261
Dominik Laskowskibb66e632022-08-17 08:00:25 -07003262 if (const char* const log =
3263 processHotplug(displayId, hwcDisplayId, connected, std::move(*info))) {
3264 ALOGI("%s display %s (HAL ID %" PRIu64 ")", log, to_string(displayId).c_str(),
3265 hwcDisplayId);
3266 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08003267 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08003268 }
3269
Dominik Laskowskif11728a2022-07-28 13:07:42 -07003270 return !events.empty();
Lloyd Piqueba04e622017-12-14 17:11:26 -08003271}
3272
Dominik Laskowskibb66e632022-08-17 08:00:25 -07003273const char* SurfaceFlinger::processHotplug(PhysicalDisplayId displayId,
3274 hal::HWDisplayId hwcDisplayId, bool connected,
3275 DisplayIdentificationInfo&& info) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07003276 const auto displayOpt = mPhysicalDisplays.get(displayId);
Dominik Laskowskibb66e632022-08-17 08:00:25 -07003277 if (!connected) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07003278 LOG_ALWAYS_FATAL_IF(!displayOpt);
3279 const auto& display = displayOpt->get();
Dominik Laskowskibb66e632022-08-17 08:00:25 -07003280
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07003281 if (const ssize_t index = mCurrentState.displays.indexOfKey(display.token()); index >= 0) {
Dominik Laskowskibb66e632022-08-17 08:00:25 -07003282 mCurrentState.displays.removeItemsAt(index);
3283 }
3284
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07003285 mPhysicalDisplays.erase(displayId);
Dominik Laskowskibb66e632022-08-17 08:00:25 -07003286 return "Disconnecting";
3287 }
3288
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07003289 auto [displayModes, activeMode] = loadDisplayModes(displayId);
Dominik Laskowskibb66e632022-08-17 08:00:25 -07003290 if (!activeMode) {
3291 // TODO(b/241286153): Report hotplug failure to the framework.
3292 ALOGE("Failed to hotplug display %s", to_string(displayId).c_str());
3293 getHwComposer().disconnectDisplay(displayId);
3294 return nullptr;
3295 }
3296
Dominik Laskowski788945b2022-08-30 12:10:56 -07003297 ui::ColorModes colorModes = getHwComposer().getColorModes(displayId);
3298
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07003299 if (displayOpt) {
3300 const auto& display = displayOpt->get();
3301 const auto& snapshot = display.snapshot();
3302
3303 std::optional<DeviceProductInfo> deviceProductInfo;
Dominik Laskowskibb66e632022-08-17 08:00:25 -07003304 if (getHwComposer().updatesDeviceProductInfoOnHotplugReconnect()) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07003305 deviceProductInfo = std::move(info.deviceProductInfo);
3306 } else {
3307 deviceProductInfo = snapshot.deviceProductInfo();
Dominik Laskowskibb66e632022-08-17 08:00:25 -07003308 }
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07003309
3310 const auto it =
3311 mPhysicalDisplays.try_replace(displayId, display.token(), displayId,
3312 snapshot.connectionType(), std::move(displayModes),
Dominik Laskowski788945b2022-08-30 12:10:56 -07003313 std::move(colorModes), std::move(deviceProductInfo));
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07003314
3315 auto& state = mCurrentState.displays.editValueFor(it->second.token());
3316 state.sequenceId = DisplayDeviceState{}.sequenceId; // Generate new sequenceId.
3317 state.physical->activeMode = std::move(activeMode);
Dominik Laskowskibb66e632022-08-17 08:00:25 -07003318 return "Reconnecting";
3319 }
3320
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07003321 const sp<IBinder> token = sp<BBinder>::make();
3322
3323 mPhysicalDisplays.try_emplace(displayId, token, displayId,
3324 getHwComposer().getDisplayConnectionType(displayId),
Dominik Laskowski788945b2022-08-30 12:10:56 -07003325 std::move(displayModes), std::move(colorModes),
3326 std::move(info.deviceProductInfo));
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07003327
Dominik Laskowskibb66e632022-08-17 08:00:25 -07003328 DisplayDeviceState state;
3329 state.physical = {.id = displayId,
Dominik Laskowskibb66e632022-08-17 08:00:25 -07003330 .hwcDisplayId = hwcDisplayId,
Dominik Laskowskibb66e632022-08-17 08:00:25 -07003331 .activeMode = std::move(activeMode)};
3332 state.isSecure = true; // All physical displays are currently considered secure.
3333 state.displayName = std::move(info.name);
3334
Dominik Laskowskibb66e632022-08-17 08:00:25 -07003335 mCurrentState.displays.add(token, state);
Dominik Laskowskibb66e632022-08-17 08:00:25 -07003336 return "Connecting";
3337}
3338
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08003339void SurfaceFlinger::dispatchDisplayHotplugEvent(PhysicalDisplayId displayId, bool connected) {
Dominik Laskowski98041832019-08-01 18:35:59 -07003340 mScheduler->onHotplugReceived(mAppConnectionHandle, displayId, connected);
3341 mScheduler->onHotplugReceived(mSfConnectionHandle, displayId, connected);
Dominik Laskowski1eba0202019-01-24 09:14:40 -08003342}
3343
Dominik Laskowskifdac5652023-06-29 12:01:13 -04003344void SurfaceFlinger::dispatchDisplayModeChangeEvent(PhysicalDisplayId displayId,
3345 const scheduler::FrameRateMode& mode) {
3346 // TODO(b/255635821): Merge code paths and move to Scheduler.
3347 const auto onDisplayModeChanged = displayId == mActiveDisplayId
3348 ? &scheduler::Scheduler::onPrimaryDisplayModeChanged
3349 : &scheduler::Scheduler::onNonPrimaryDisplayModeChanged;
3350
3351 ((*mScheduler).*onDisplayModeChanged)(mAppConnectionHandle, mode);
3352}
3353
Lloyd Pique99d3da52018-01-22 17:48:03 -08003354sp<DisplayDevice> SurfaceFlinger::setupNewDisplayDeviceInternal(
Lloyd Pique9370a482019-10-03 17:58:30 -07003355 const wp<IBinder>& displayToken,
3356 std::shared_ptr<compositionengine::Display> compositionDisplay,
Marin Shalamanovae685592020-02-12 17:12:22 +01003357 const DisplayDeviceState& state,
3358 const sp<compositionengine::DisplaySurface>& displaySurface,
Dominik Laskowski075d3172018-05-24 15:50:06 -07003359 const sp<IGraphicBufferProducer>& producer) {
Ady Abrahamd11bade2022-08-01 16:18:03 -07003360 DisplayDeviceCreationArgs creationArgs(sp<SurfaceFlinger>::fromExisting(this), getHwComposer(),
3361 displayToken, compositionDisplay);
Dominik Laskowskie9774092018-12-11 10:04:24 -08003362 creationArgs.sequenceId = state.sequenceId;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07003363 creationArgs.isSecure = state.isSecure;
Marin Shalamanovae685592020-02-12 17:12:22 +01003364 creationArgs.displaySurface = displaySurface;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07003365 creationArgs.hasWideColorGamut = false;
3366 creationArgs.supportedPerFrameMetadata = 0;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07003367
Dominik Laskowski55c85402020-01-21 16:25:47 -08003368 if (const auto& physical = state.physical) {
Ady Abraham3efa3942021-06-24 19:01:25 -07003369 creationArgs.activeModeId = physical->activeMode->getId();
ramindani32cf0602022-03-02 02:30:29 +00003370 const auto [kernelIdleTimerController, idleTimerTimeoutMs] =
3371 getKernelIdleTimerProperties(compositionDisplay->getId());
3372
Ady Abraham0c8b7232023-01-27 21:12:16 -08003373 using Config = scheduler::RefreshRateSelector::Config;
3374 const auto enableFrameRateOverride = sysprop::enable_frame_rate_override(true)
3375 ? Config::FrameRateOverride::Enabled
3376 : Config::FrameRateOverride::Disabled;
Ady Abraham0d4b41c2023-02-14 23:28:40 +00003377 Config config =
Ady Abraham8ca643a2022-10-18 18:26:47 -07003378 {.enableFrameRateOverride = enableFrameRateOverride,
Ady Abraham3efa3942021-06-24 19:01:25 -07003379 .frameRateMultipleThreshold =
Ady Abraham9a2ea342021-09-03 17:32:34 -07003380 base::GetIntProperty("debug.sf.frame_rate_multiple_threshold", 0),
ramindani32cf0602022-03-02 02:30:29 +00003381 .idleTimerTimeout = idleTimerTimeoutMs,
3382 .kernelIdleTimerController = kernelIdleTimerController};
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07003383
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04003384 creationArgs.refreshRateSelector =
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07003385 mPhysicalDisplays.get(physical->id)
3386 .transform(&PhysicalDisplay::snapshotRef)
3387 .transform([&](const display::DisplaySnapshot& snapshot) {
3388 return std::make_shared<
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04003389 scheduler::RefreshRateSelector>(snapshot.displayModes(),
3390 creationArgs.activeModeId,
3391 config);
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07003392 })
3393 .value_or(nullptr);
Dominik Laskowski55c85402020-01-21 16:25:47 -08003394
Dominik Laskowski788945b2022-08-30 12:10:56 -07003395 creationArgs.isPrimary = physical->id == getPrimaryDisplayIdLocked();
Dominik Laskowski075d3172018-05-24 15:50:06 -07003396
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02003397 if (useColorManagement) {
Dominik Laskowski788945b2022-08-30 12:10:56 -07003398 mPhysicalDisplays.get(physical->id)
3399 .transform(&PhysicalDisplay::snapshotRef)
3400 .transform(ftl::unit_fn([&](const display::DisplaySnapshot& snapshot) {
3401 for (const auto mode : snapshot.colorModes()) {
3402 creationArgs.hasWideColorGamut |= ui::isWideColorMode(mode);
3403 creationArgs.hwcColorModes
3404 .emplace(mode,
3405 getHwComposer().getRenderIntents(physical->id, mode));
3406 }
3407 }));
Lloyd Pique99d3da52018-01-22 17:48:03 -08003408 }
tangrobin6753a022018-08-10 10:58:54 +08003409 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08003410
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02003411 if (const auto id = HalDisplayId::tryCast(compositionDisplay->getId())) {
3412 getHwComposer().getHdrCapabilities(*id, &creationArgs.hdrCapabilities);
3413 creationArgs.supportedPerFrameMetadata = getHwComposer().getSupportedPerFrameMetadata(*id);
Chia-I Wu0f509fb2018-06-21 15:52:50 +08003414 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08003415
Lloyd Pique90c115d2018-09-18 21:39:42 -07003416 auto nativeWindowSurface = getFactory().createNativeWindowSurface(producer);
Lloyd Pique99d3da52018-01-22 17:48:03 -08003417 auto nativeWindow = nativeWindowSurface->getNativeWindow();
Lloyd Pique2eef1d22018-09-18 21:30:04 -07003418 creationArgs.nativeWindow = nativeWindow;
Lloyd Pique99d3da52018-01-22 17:48:03 -08003419
Lloyd Pique99d3da52018-01-22 17:48:03 -08003420 // Make sure that composition can never be stalled by a virtual display
3421 // consumer that isn't processing buffers fast enough. We have to do this
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003422 // here, in case the display is composed entirely by HWC.
Dominik Laskowski281644e2018-04-19 15:47:35 -07003423 if (state.isVirtual()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08003424 nativeWindow->setSwapInterval(nativeWindow.get(), 0);
3425 }
3426
Dominik Laskowski718f9602019-11-09 20:01:35 -08003427 creationArgs.physicalOrientation =
ramindani06e518e2022-03-14 18:47:53 +00003428 getPhysicalDisplayOrientation(compositionDisplay->getId(), creationArgs.isPrimary);
3429 ALOGV("Display Orientation: %s", toCString(creationArgs.physicalOrientation));
Chia-I Wua02871c2018-08-27 14:38:23 -07003430
Lloyd Pique99d3da52018-01-22 17:48:03 -08003431 // virtual displays are always considered enabled
linpeter1c69cd32022-07-13 19:20:48 +08003432 creationArgs.initialPowerMode =
3433 state.isVirtual() ? std::make_optional(hal::PowerMode::ON) : std::nullopt;
Lloyd Pique99d3da52018-01-22 17:48:03 -08003434
Huihong Luo1768cb02022-10-11 11:10:34 -07003435 creationArgs.requestedRefreshRate = state.requestedRefreshRate;
3436
Lloyd Pique9370a482019-10-03 17:58:30 -07003437 sp<DisplayDevice> display = getFactory().createDisplayDevice(creationArgs);
Lloyd Pique99d3da52018-01-22 17:48:03 -08003438
Ady Abraham8565ad22021-06-22 17:45:44 -07003439 nativeWindowSurface->preallocateBuffers();
Lloyd Pique99d3da52018-01-22 17:48:03 -08003440
Dominik Laskowski788945b2022-08-30 12:10:56 -07003441 ui::ColorMode defaultColorMode = ui::ColorMode::NATIVE;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08003442 Dataspace defaultDataSpace = Dataspace::UNKNOWN;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07003443 if (display->hasWideColorGamut()) {
Dominik Laskowski788945b2022-08-30 12:10:56 -07003444 defaultColorMode = ui::ColorMode::SRGB;
Peiyong Lin14724e62018-12-05 07:27:30 -08003445 defaultDataSpace = Dataspace::V0_SRGB;
Lloyd Pique99d3da52018-01-22 17:48:03 -08003446 }
Lloyd Pique6a3b4462019-03-07 20:58:12 -08003447 display->getCompositionDisplay()->setColorProfile(
3448 compositionengine::Output::ColorProfile{defaultColorMode, defaultDataSpace,
Alec Mouri88790f32023-07-21 01:25:14 +00003449 RenderIntent::COLORIMETRIC});
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07003450
3451 if (const auto& physical = state.physical) {
Dominik Laskowskifdac5652023-06-29 12:01:13 -04003452 const auto& mode = *physical->activeMode;
3453 display->setActiveMode(mode.getId(), mode.getFps(), mode.getFps());
Lloyd Pique3c085a02018-05-09 19:38:32 -07003454 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07003455
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07003456 display->setLayerFilter(makeLayerFilterForDisplay(display->getId(), state.layerStack));
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02003457 display->setProjection(state.orientation, state.layerStackSpaceRect,
3458 state.orientedDisplaySpaceRect);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003459 display->setDisplayName(state.displayName);
Vishnu Naira119aaa2021-09-24 07:19:35 -07003460 display->setFlags(state.flags);
Lloyd Pique99d3da52018-01-22 17:48:03 -08003461
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003462 return display;
Lloyd Pique99d3da52018-01-22 17:48:03 -08003463}
3464
Marin Shalamanovae685592020-02-12 17:12:22 +01003465void SurfaceFlinger::processDisplayAdded(const wp<IBinder>& displayToken,
3466 const DisplayDeviceState& state) {
Marin Shalamanov045b7002021-01-07 16:56:24 +01003467 ui::Size resolution(0, 0);
Marin Shalamanovae685592020-02-12 17:12:22 +01003468 ui::PixelFormat pixelFormat = static_cast<ui::PixelFormat>(PIXEL_FORMAT_UNKNOWN);
3469 if (state.physical) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08003470 resolution = state.physical->activeMode->getResolution();
Marin Shalamanovae685592020-02-12 17:12:22 +01003471 pixelFormat = static_cast<ui::PixelFormat>(PIXEL_FORMAT_RGBA_8888);
3472 } else if (state.surface != nullptr) {
Marin Shalamanov045b7002021-01-07 16:56:24 +01003473 int status = state.surface->query(NATIVE_WINDOW_WIDTH, &resolution.width);
Marin Shalamanovae685592020-02-12 17:12:22 +01003474 ALOGE_IF(status != NO_ERROR, "Unable to query width (%d)", status);
Marin Shalamanov045b7002021-01-07 16:56:24 +01003475 status = state.surface->query(NATIVE_WINDOW_HEIGHT, &resolution.height);
Marin Shalamanovae685592020-02-12 17:12:22 +01003476 ALOGE_IF(status != NO_ERROR, "Unable to query height (%d)", status);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003477 int format;
3478 status = state.surface->query(NATIVE_WINDOW_FORMAT, &format);
Marin Shalamanovae685592020-02-12 17:12:22 +01003479 ALOGE_IF(status != NO_ERROR, "Unable to query format (%d)", status);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003480 pixelFormat = static_cast<ui::PixelFormat>(format);
Marin Shalamanovae685592020-02-12 17:12:22 +01003481 } else {
3482 // Virtual displays without a surface are dormant:
3483 // they have external state (layer stack, projection,
3484 // etc.) but no internal state (i.e. a DisplayDevice).
3485 return;
3486 }
3487
3488 compositionengine::DisplayCreationArgsBuilder builder;
3489 if (const auto& physical = state.physical) {
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003490 builder.setId(physical->id);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003491 } else {
Dominik Laskowski263eec42021-07-21 23:13:24 -07003492 builder.setId(acquireVirtualDisplay(resolution, pixelFormat));
Marin Shalamanovae685592020-02-12 17:12:22 +01003493 }
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003494
Marin Shalamanov045b7002021-01-07 16:56:24 +01003495 builder.setPixels(resolution);
Marin Shalamanovae685592020-02-12 17:12:22 +01003496 builder.setIsSecure(state.isSecure);
Xiang Wang839fe5b2022-04-04 17:39:38 +00003497 builder.setPowerAdvisor(mPowerAdvisor.get());
Marin Shalamanovae685592020-02-12 17:12:22 +01003498 builder.setName(state.displayName);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003499 auto compositionDisplay = getCompositionEngine().createDisplay(builder.build());
Lloyd Pique30db6402023-06-26 18:56:51 +00003500 compositionDisplay->setLayerCachingEnabled(mLayerCachingEnabled);
Marin Shalamanovae685592020-02-12 17:12:22 +01003501
3502 sp<compositionengine::DisplaySurface> displaySurface;
3503 sp<IGraphicBufferProducer> producer;
3504 sp<IGraphicBufferProducer> bqProducer;
3505 sp<IGraphicBufferConsumer> bqConsumer;
3506 getFactory().createBufferQueue(&bqProducer, &bqConsumer, /*consumerIsSurfaceFlinger =*/false);
3507
Marin Shalamanovae685592020-02-12 17:12:22 +01003508 if (state.isVirtual()) {
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003509 const auto displayId = VirtualDisplayId::tryCast(compositionDisplay->getId());
3510 LOG_FATAL_IF(!displayId);
3511 auto surface = sp<VirtualDisplaySurface>::make(getHwComposer(), *displayId, state.surface,
Lloyd Pique30db6402023-06-26 18:56:51 +00003512 bqProducer, bqConsumer, state.displayName);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003513 displaySurface = surface;
3514 producer = std::move(surface);
Marin Shalamanovae685592020-02-12 17:12:22 +01003515 } else {
3516 ALOGE_IF(state.surface != nullptr,
3517 "adding a supported display, but rendering "
3518 "surface is provided (%p), ignoring it",
3519 state.surface.get());
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003520 const auto displayId = PhysicalDisplayId::tryCast(compositionDisplay->getId());
3521 LOG_FATAL_IF(!displayId);
Lloyd Pique30db6402023-06-26 18:56:51 +00003522 displaySurface =
3523 sp<FramebufferSurface>::make(getHwComposer(), *displayId, bqConsumer,
3524 state.physical->activeMode->getResolution(),
3525 ui::Size(maxGraphicsWidth, maxGraphicsHeight));
Marin Shalamanovae685592020-02-12 17:12:22 +01003526 producer = bqProducer;
3527 }
3528
Marin Shalamanov700e6392020-02-12 20:22:26 +01003529 LOG_FATAL_IF(!displaySurface);
Dominik Laskowskieb627312022-04-07 09:13:16 -07003530 auto display = setupNewDisplayDeviceInternal(displayToken, std::move(compositionDisplay), state,
3531 displaySurface, producer);
Dominik Laskowski68399272022-09-15 07:54:46 -07003532
3533 if (mScheduler && !display->isVirtual()) {
Dominik Laskowski596a2562022-10-28 11:26:12 -04003534 const auto displayId = display->getPhysicalId();
3535 {
Dominik Laskowski59db9562022-10-27 16:18:53 -04003536 // TODO(b/241285876): Annotate `processDisplayAdded` instead.
3537 ftl::FakeGuard guard(kMainThreadContext);
Dominik Laskowski596a2562022-10-28 11:26:12 -04003538
3539 // For hotplug reconnect, renew the registration since display modes have been reloaded.
3540 mScheduler->registerDisplay(displayId, display->holdRefreshRateSelector());
Dominik Laskowski68399272022-09-15 07:54:46 -07003541 }
Dominik Laskowskib5a094b2022-10-27 12:00:12 -04003542
Dominik Laskowski596a2562022-10-28 11:26:12 -04003543 dispatchDisplayHotplugEvent(displayId, true);
Marin Shalamanov700e6392020-02-12 20:22:26 +01003544 }
Dominik Laskowskieb627312022-04-07 09:13:16 -07003545
Huihong Luo1768cb02022-10-11 11:10:34 -07003546 if (display->isVirtual()) {
Leon Scroggins III1af0fb62023-03-02 14:21:44 -05003547 display->adjustRefreshRate(mScheduler->getPacesetterRefreshRate());
Huihong Luo1768cb02022-10-11 11:10:34 -07003548 }
3549
Dominik Laskowskieb627312022-04-07 09:13:16 -07003550 mDisplays.try_emplace(displayToken, std::move(display));
Marin Shalamanovae685592020-02-12 17:12:22 +01003551}
3552
3553void SurfaceFlinger::processDisplayRemoved(const wp<IBinder>& displayToken) {
Vishnu Nairf78589c2020-12-02 18:36:03 -08003554 auto display = getDisplayDeviceLocked(displayToken);
3555 if (display) {
Marin Shalamanovae685592020-02-12 17:12:22 +01003556 display->disconnect();
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003557
3558 if (display->isVirtual()) {
3559 releaseVirtualDisplay(display->getVirtualId());
3560 } else {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02003561 dispatchDisplayHotplugEvent(display->getPhysicalId(), false);
ramindani69b58e82022-09-26 16:48:36 -07003562 mScheduler->unregisterDisplay(display->getPhysicalId());
Marin Shalamanovae685592020-02-12 17:12:22 +01003563 }
3564 }
3565
3566 mDisplays.erase(displayToken);
Vishnu Nairf78589c2020-12-02 18:36:03 -08003567
3568 if (display && display->isVirtual()) {
Dominik Laskowski756b7892021-08-04 12:53:59 -07003569 static_cast<void>(mScheduler->schedule([display = std::move(display)] {
Vishnu Nairf78589c2020-12-02 18:36:03 -08003570 // Destroy the display without holding the mStateLock.
3571 // This is a temporary solution until we can manage transaction queues without
3572 // holding the mStateLock.
3573 // With blast, the IGBP that is passed to the VirtualDisplaySurface is owned by the
3574 // client. When the IGBP is disconnected, its buffer cache in SF will be cleared
3575 // via SurfaceComposerClient::doUncacheBufferTransaction. This call from the client
3576 // ends up running on the main thread causing a deadlock since setTransactionstate
3577 // will try to acquire the mStateLock. Instead we extend the lifetime of
3578 // DisplayDevice and destroy it in the main thread without holding the mStateLock.
3579 // The display will be disconnected and removed from the mDisplays list so it will
3580 // not be accessible.
3581 }));
3582 }
Marin Shalamanovae685592020-02-12 17:12:22 +01003583}
3584
3585void SurfaceFlinger::processDisplayChanged(const wp<IBinder>& displayToken,
3586 const DisplayDeviceState& currentState,
3587 const DisplayDeviceState& drawingState) {
3588 const sp<IBinder> currentBinder = IInterface::asBinder(currentState.surface);
3589 const sp<IBinder> drawingBinder = IInterface::asBinder(drawingState.surface);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003590
3591 // Recreate the DisplayDevice if the surface or sequence ID changed.
Marin Shalamanov700e6392020-02-12 20:22:26 +01003592 if (currentBinder != drawingBinder || currentState.sequenceId != drawingState.sequenceId) {
Marin Shalamanov23c31af2020-09-09 15:01:47 +02003593 getRenderEngine().cleanFramebufferCache();
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003594
Marin Shalamanovae685592020-02-12 17:12:22 +01003595 if (const auto display = getDisplayDeviceLocked(displayToken)) {
3596 display->disconnect();
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003597 if (display->isVirtual()) {
3598 releaseVirtualDisplay(display->getVirtualId());
3599 }
Marin Shalamanovae685592020-02-12 17:12:22 +01003600 }
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003601
Marin Shalamanovae685592020-02-12 17:12:22 +01003602 mDisplays.erase(displayToken);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003603
Marin Shalamanov700e6392020-02-12 20:22:26 +01003604 if (const auto& physical = currentState.physical) {
3605 getHwComposer().allocatePhysicalDisplay(physical->hwcDisplayId, physical->id);
3606 }
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003607
Marin Shalamanovae685592020-02-12 17:12:22 +01003608 processDisplayAdded(displayToken, currentState);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003609
Marin Shalamanov700e6392020-02-12 20:22:26 +01003610 if (currentState.physical) {
Marin Shalamanov4c5e3012020-06-04 21:41:42 +02003611 const auto display = getDisplayDeviceLocked(displayToken);
3612 setPowerModeInternal(display, hal::PowerMode::ON);
Marin Shalamanovf7f6b3c2020-12-09 13:19:38 +01003613
3614 // TODO(b/175678251) Call a listener instead.
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07003615 if (currentState.physical->hwcDisplayId == getHwComposer().getPrimaryHwcDisplayId()) {
Dominik Laskowski14956dc2023-02-22 13:43:57 -05003616 resetPhaseConfiguration(display->getActiveMode().fps);
Marin Shalamanovf7f6b3c2020-12-09 13:19:38 +01003617 }
Marin Shalamanov700e6392020-02-12 20:22:26 +01003618 }
Marin Shalamanovae685592020-02-12 17:12:22 +01003619 return;
3620 }
3621
3622 if (const auto display = getDisplayDeviceLocked(displayToken)) {
3623 if (currentState.layerStack != drawingState.layerStack) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07003624 display->setLayerFilter(
3625 makeLayerFilterForDisplay(display->getId(), currentState.layerStack));
Marin Shalamanovae685592020-02-12 17:12:22 +01003626 }
Evan Rosky2239b372021-05-20 13:43:47 -07003627 if (currentState.flags != drawingState.flags) {
3628 display->setFlags(currentState.flags);
3629 }
Marin Shalamanovae685592020-02-12 17:12:22 +01003630 if ((currentState.orientation != drawingState.orientation) ||
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02003631 (currentState.layerStackSpaceRect != drawingState.layerStackSpaceRect) ||
3632 (currentState.orientedDisplaySpaceRect != drawingState.orientedDisplaySpaceRect)) {
3633 display->setProjection(currentState.orientation, currentState.layerStackSpaceRect,
3634 currentState.orientedDisplaySpaceRect);
Dominik Laskowskie591b552022-09-09 10:44:56 -07003635 if (display->getId() == mActiveDisplayId) {
Ady Abraham1273ac12021-08-26 17:31:53 -07003636 mActiveDisplayTransformHint = display->getTransformHint();
Leon Scroggins III85d4b222023-05-09 13:58:18 -04003637 sActiveDisplayRotationFlags =
3638 ui::Transform::toRotationFlags(display->getOrientation());
Arthur Hungb6aa9a02021-06-09 14:23:01 +08003639 }
Marin Shalamanovae685592020-02-12 17:12:22 +01003640 }
3641 if (currentState.width != drawingState.width ||
3642 currentState.height != drawingState.height) {
3643 display->setDisplaySize(currentState.width, currentState.height);
Dominik Laskowski20134642020-04-20 22:36:44 -07003644
Dominik Laskowskie591b552022-09-09 10:44:56 -07003645 if (display->getId() == mActiveDisplayId) {
Dominik Laskowski39dfc942023-02-08 16:27:05 -05003646 onActiveDisplaySizeChanged(*display);
Marin Shalamanovae685592020-02-12 17:12:22 +01003647 }
3648 }
3649 }
3650}
Dominik Laskowskif8734e02022-08-26 09:06:59 -07003651
Dominik Laskowski14956dc2023-02-22 13:43:57 -05003652void SurfaceFlinger::resetPhaseConfiguration(Fps refreshRate) {
3653 // Cancel the pending refresh rate change, if any, before updating the phase configuration.
3654 mScheduler->vsyncModulator().cancelRefreshRateChange();
3655
Ady Abrahamed3290f2021-05-17 15:12:14 -07003656 mVsyncConfiguration->reset();
Ady Abrahamed3290f2021-05-17 15:12:14 -07003657 updatePhaseConfiguration(refreshRate);
3658 mRefreshRateStats->setRefreshRate(refreshRate);
Ady Abrahamed3290f2021-05-17 15:12:14 -07003659}
Marin Shalamanovae685592020-02-12 17:12:22 +01003660
Lloyd Pique347200f2017-12-14 17:00:15 -08003661void SurfaceFlinger::processDisplayChangesLocked() {
3662 // here we take advantage of Vector's copy-on-write semantics to
3663 // improve performance by skipping the transaction entirely when
3664 // know that the lists are identical
3665 const KeyedVector<wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
3666 const KeyedVector<wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
3667 if (!curr.isIdenticalTo(draw)) {
3668 mVisibleRegionsDirty = true;
Arthur Hung9ed43392022-05-27 06:31:57 +00003669 mUpdateInputInfo = true;
Lloyd Pique347200f2017-12-14 17:00:15 -08003670
3671 // find the displays that were removed
3672 // (ie: in drawing state but not in current state)
3673 // also handle displays that changed
3674 // (ie: displays that are in both lists)
Marin Shalamanovae685592020-02-12 17:12:22 +01003675 for (size_t i = 0; i < draw.size(); i++) {
3676 const wp<IBinder>& displayToken = draw.keyAt(i);
3677 const ssize_t j = curr.indexOfKey(displayToken);
Lloyd Pique347200f2017-12-14 17:00:15 -08003678 if (j < 0) {
3679 // in drawing state but not in current state
Marin Shalamanovae685592020-02-12 17:12:22 +01003680 processDisplayRemoved(displayToken);
Lloyd Pique347200f2017-12-14 17:00:15 -08003681 } else {
3682 // this display is in both lists. see if something changed.
Marin Shalamanovae685592020-02-12 17:12:22 +01003683 const DisplayDeviceState& currentState = curr[j];
3684 const DisplayDeviceState& drawingState = draw[i];
3685 processDisplayChanged(displayToken, currentState, drawingState);
Lloyd Pique347200f2017-12-14 17:00:15 -08003686 }
Lloyd Pique347200f2017-12-14 17:00:15 -08003687 }
3688
3689 // find displays that were added
3690 // (ie: in current state but not in drawing state)
Marin Shalamanovae685592020-02-12 17:12:22 +01003691 for (size_t i = 0; i < curr.size(); i++) {
3692 const wp<IBinder>& displayToken = curr.keyAt(i);
3693 if (draw.indexOfKey(displayToken) < 0) {
3694 processDisplayAdded(displayToken, curr[i]);
Lloyd Pique347200f2017-12-14 17:00:15 -08003695 }
3696 }
3697 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08003698
3699 mDrawingState.displays = mCurrentState.displays;
Lloyd Pique347200f2017-12-14 17:00:15 -08003700}
3701
Dominik Laskowski9e168db2021-05-27 16:05:12 -07003702void SurfaceFlinger::commitTransactionsLocked(uint32_t transactionFlags) {
3703 // Commit display transactions.
Vishnu Nair6bdec7d2021-05-10 15:01:13 -07003704 const bool displayTransactionNeeded = transactionFlags & eDisplayTransactionNeeded;
Vishnu Nair3af0ec02023-02-10 04:13:48 +00003705 mFrontEndDisplayInfosChanged = displayTransactionNeeded;
Lloyd Pique30db6402023-06-26 18:56:51 +00003706 if (displayTransactionNeeded && !mLayerLifecycleManagerEnabled) {
Vishnu Nair6bdec7d2021-05-10 15:01:13 -07003707 processDisplayChangesLocked();
Vishnu Nair67b431c2022-11-16 01:54:05 +00003708 mFrontEndDisplayInfos.clear();
3709 for (const auto& [_, display] : mDisplays) {
3710 mFrontEndDisplayInfos.try_emplace(display->getLayerStack(), display->getFrontEndInfo());
3711 }
Vishnu Nair6bdec7d2021-05-10 15:01:13 -07003712 }
Robert Carrb552ff52021-06-11 13:35:54 -07003713 mForceTransactionDisplayChange = displayTransactionNeeded;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003714
Robert Carre450fb52021-06-11 13:21:09 -07003715 if (mSomeChildrenChanged) {
3716 mVisibleRegionsDirty = true;
3717 mSomeChildrenChanged = false;
Arthur Hung9ed43392022-05-27 06:31:57 +00003718 mUpdateInputInfo = true;
Robert Carre450fb52021-06-11 13:21:09 -07003719 }
3720
Dominik Laskowski9e168db2021-05-27 16:05:12 -07003721 // Update transform hint.
Vishnu Nair6213bd92020-05-08 17:42:25 -07003722 if (transactionFlags & (eTransformHintUpdateNeeded | eDisplayTransactionNeeded)) {
Dominik Laskowski29fa1462021-04-27 15:51:50 -07003723 // Layers and/or displays have changed, so update the transform hint for each layer.
Mathias Agopian84300952012-11-21 16:02:13 -08003724 //
Lloyd Piquec29e4c62019-03-07 21:48:19 -08003725 // NOTE: we do this here, rather than when presenting the display so that
Mathias Agopian84300952012-11-21 16:02:13 -08003726 // the hint is set before we acquire a buffer from the surface texture.
3727 //
3728 // NOTE: layer transactions have taken place already, so we use their
3729 // drawing state. However, SurfaceFlinger's own transaction has not
3730 // happened yet, so we must use the current state layer list
3731 // (soon to become the drawing state list).
3732 //
Dominik Laskowski9fae1022018-05-29 13:17:40 -07003733 sp<const DisplayDevice> hintDisplay;
Dominik Laskowski29fa1462021-04-27 15:51:50 -07003734 ui::LayerStack layerStack;
3735
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07003736 mCurrentState.traverse([&](Layer* layer) REQUIRES(mStateLock) {
Mathias Agopian84300952012-11-21 16:02:13 -08003737 // NOTE: we rely on the fact that layers are sorted by
3738 // layerStack first (so we don't have to traverse the list
3739 // of displays for every layer).
Dominik Laskowski29fa1462021-04-27 15:51:50 -07003740 if (const auto filter = layer->getOutputFilter(); layerStack != filter.layerStack) {
3741 layerStack = filter.layerStack;
Dominik Laskowski9fae1022018-05-29 13:17:40 -07003742 hintDisplay = nullptr;
Dominik Laskowski29fa1462021-04-27 15:51:50 -07003743
3744 // Find the display that includes the layer.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07003745 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski29fa1462021-04-27 15:51:50 -07003746 if (!display->getCompositionDisplay()->includesLayer(filter)) {
3747 continue;
Mathias Agopian84300952012-11-21 16:02:13 -08003748 }
Dominik Laskowski29fa1462021-04-27 15:51:50 -07003749
3750 // Pick the primary display if another display mirrors the layer.
3751 if (hintDisplay) {
3752 hintDisplay = nullptr;
3753 break;
3754 }
3755
3756 hintDisplay = display;
Mathias Agopian84300952012-11-21 16:02:13 -08003757 }
3758 }
Chet Haase91d25932013-04-11 15:24:55 -07003759
Vishnu Nair71fcf912022-10-18 09:14:20 -07003760 if (!hintDisplay) {
Lloyd Piqued432a7c2018-03-23 16:05:31 -07003761 // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
3762 // redraw after transform hint changes. See bug 8508397.
Lloyd Piqued432a7c2018-03-23 16:05:31 -07003763 // could be null when this layer is using a layerStack
3764 // that is not visible on any display. Also can occur at
3765 // screen off/on times.
Vishnu Nair71fcf912022-10-18 09:14:20 -07003766 // U Update: Don't provide stale hints to the clients. For
3767 // special cases where we want the app to draw its
3768 // first frame before the display is available, we rely
3769 // on WMS and DMS to provide the right information
3770 // so the client can calculate the hint.
3771 ALOGV("Skipping reporting transform hint update for %s", layer->getDebugName());
3772 layer->skipReportingTransformHint();
Vishnu Naire3066de2022-06-08 12:16:25 -07003773 } else {
Vishnu Nair71fcf912022-10-18 09:14:20 -07003774 layer->updateTransformHint(hintDisplay->getTransformHint());
Vishnu Naire3066de2022-06-08 12:16:25 -07003775 }
Robert Carr2047fae2016-11-28 14:09:09 -08003776 });
Mathias Agopian84300952012-11-21 16:02:13 -08003777 }
3778
Robert Carr1f0a16a2016-10-24 16:27:39 -07003779 if (mLayersAdded) {
3780 mLayersAdded = false;
3781 // Layers have been added.
Mathias Agopian3559b072012-08-15 13:46:03 -07003782 mVisibleRegionsDirty = true;
Arthur Hung9ed43392022-05-27 06:31:57 +00003783 mUpdateInputInfo = true;
Mathias Agopian3559b072012-08-15 13:46:03 -07003784 }
3785
3786 // some layers might have been removed, so
3787 // we need to update the regions they're exposing.
3788 if (mLayersRemoved) {
3789 mLayersRemoved = false;
3790 mVisibleRegionsDirty = true;
Arthur Hung9ed43392022-05-27 06:31:57 +00003791 mUpdateInputInfo = true;
Robert Carr2047fae2016-11-28 14:09:09 -08003792 mDrawingState.traverseInZOrder([&](Layer* layer) {
Ady Abrahamd11bade2022-08-01 16:18:03 -07003793 if (mLayersPendingRemoval.indexOf(sp<Layer>::fromExisting(layer)) >= 0) {
Mathias Agopian3559b072012-08-15 13:46:03 -07003794 // this layer is not visible anymore
Robert Carr1f0a16a2016-10-24 16:27:39 -07003795 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08003796 visibleReg.set(layer->getScreenBounds());
Vishnu Nair3af0ec02023-02-10 04:13:48 +00003797 invalidateLayerStack(layer->getOutputFilter(), visibleReg);
Mathias Agopian0aa758d2009-04-22 15:23:34 -07003798 }
Robert Carr2047fae2016-11-28 14:09:09 -08003799 });
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003800 }
3801
Patrick Williamsaf06b792023-02-16 17:46:22 -06003802 if (transactionFlags & eInputInfoUpdateNeeded) {
3803 mUpdateInputInfo = true;
3804 }
3805
Dominik Laskowski9e168db2021-05-27 16:05:12 -07003806 doCommitTransactions();
Riley Andrews03414a12014-07-01 14:22:59 -07003807}
3808
Patrick Williams6681c022023-05-15 13:38:16 -05003809void SurfaceFlinger::updateInputFlinger(VsyncId vsyncId, TimePoint frameTime) {
Patrick Williamsd86bd8c2023-04-21 11:54:11 -05003810 if (!mInputFlinger || (!mUpdateInputInfo && mInputWindowCommands.empty())) {
Vishnu Nair42a27b52021-11-18 15:35:22 -08003811 return;
3812 }
Patrick Williamsd86bd8c2023-04-21 11:54:11 -05003813 ATRACE_CALL();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08003814
Vishnu Nair03ccbd62021-12-01 17:21:16 -08003815 std::vector<WindowInfo> windowInfos;
3816 std::vector<DisplayInfo> displayInfos;
3817 bool updateWindowInfo = false;
Arthur Hung9ed43392022-05-27 06:31:57 +00003818 if (mUpdateInputInfo) {
3819 mUpdateInputInfo = false;
Vishnu Nair03ccbd62021-12-01 17:21:16 -08003820 updateWindowInfo = true;
3821 buildWindowInfos(windowInfos, displayInfos);
Vishnu Nair03ccbd62021-12-01 17:21:16 -08003822 }
Arthur Hung9ed43392022-05-27 06:31:57 +00003823
Patrick Williamsd86bd8c2023-04-21 11:54:11 -05003824 std::unordered_set<int32_t> visibleWindowIds;
3825 for (WindowInfo& windowInfo : windowInfos) {
3826 if (!windowInfo.inputConfig.test(WindowInfo::InputConfig::NOT_VISIBLE)) {
3827 visibleWindowIds.insert(windowInfo.id);
Patrick Williams1caf3b72023-03-31 10:59:10 -05003828 }
Patrick Williamsd86bd8c2023-04-21 11:54:11 -05003829 }
3830 bool visibleWindowsChanged = false;
3831 if (visibleWindowIds != mVisibleWindowIds) {
3832 visibleWindowsChanged = true;
3833 mVisibleWindowIds = std::move(visibleWindowIds);
Patrick Williams1caf3b72023-03-31 10:59:10 -05003834 }
3835
Alec Mouri8d7d0f42022-05-10 23:33:40 +00003836 BackgroundExecutor::getInstance().sendCallbacks({[updateWindowInfo,
3837 windowInfos = std::move(windowInfos),
3838 displayInfos = std::move(displayInfos),
3839 inputWindowCommands =
3840 std::move(mInputWindowCommands),
Patrick Williams1caf3b72023-03-31 10:59:10 -05003841 inputFlinger = mInputFlinger, this,
Patrick Williams6681c022023-05-15 13:38:16 -05003842 visibleWindowsChanged, vsyncId, frameTime]() {
Vishnu Nair03ccbd62021-12-01 17:21:16 -08003843 ATRACE_NAME("BackgroundExecutor::updateInputFlinger");
3844 if (updateWindowInfo) {
Patrick Williams641f7f22022-06-22 19:25:35 +00003845 mWindowInfosListenerInvoker
Patrick Williams6681c022023-05-15 13:38:16 -05003846 ->windowInfosChanged(gui::WindowInfosUpdate{std::move(windowInfos),
3847 std::move(displayInfos),
3848 ftl::to_underlying(vsyncId),
3849 frameTime.ns()},
Patrick Williams1caf3b72023-03-31 10:59:10 -05003850 std::move(
3851 inputWindowCommands.windowInfosReportedListeners),
Patrick Williamsd86bd8c2023-04-21 11:54:11 -05003852 /* forceImmediateCall= */ visibleWindowsChanged ||
Patrick Williams6681c022023-05-15 13:38:16 -05003853 !inputWindowCommands.focusRequests.empty());
Patrick Williams641f7f22022-06-22 19:25:35 +00003854 } else {
3855 // If there are listeners but no changes to input windows, call the listeners
3856 // immediately.
3857 for (const auto& listener : inputWindowCommands.windowInfosReportedListeners) {
3858 if (IInterface::asBinder(listener)->isBinderAlive()) {
3859 listener->onWindowInfosReported();
3860 }
3861 }
Vishnu Nair03ccbd62021-12-01 17:21:16 -08003862 }
3863 for (const auto& focusRequest : inputWindowCommands.focusRequests) {
3864 inputFlinger->setFocusedWindow(focusRequest);
3865 }
Alec Mouri8d7d0f42022-05-10 23:33:40 +00003866 }});
Jaineel Mehtaac331c52021-11-29 21:38:10 +00003867
Arthur Hung6cbb9752019-09-05 16:38:18 +08003868 mInputWindowCommands.clear();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08003869}
3870
Alec Mouricdf16792021-12-10 13:16:06 -08003871void SurfaceFlinger::persistDisplayBrightness(bool needsComposite) {
3872 const bool supportsDisplayBrightnessCommand = getHwComposer().getComposer()->isSupported(
3873 Hwc2::Composer::OptionalFeature::DisplayBrightnessCommand);
3874 if (!supportsDisplayBrightnessCommand) {
3875 return;
3876 }
3877
Dominik Laskowski298b08e2022-02-15 13:45:02 -08003878 for (const auto& [_, display] : FTL_FAKE_GUARD(mStateLock, mDisplays)) {
Alec Mouricdf16792021-12-10 13:16:06 -08003879 if (const auto brightness = display->getStagedBrightness(); brightness) {
3880 if (!needsComposite) {
3881 const status_t error =
3882 getHwComposer()
3883 .setDisplayBrightness(display->getPhysicalId(), *brightness,
Alec Mouri4d8a05d2022-03-23 18:14:26 +00003884 display->getCompositionDisplay()
3885 ->getState()
3886 .displayBrightnessNits,
Alec Mouricdf16792021-12-10 13:16:06 -08003887 Hwc2::Composer::DisplayBrightnessOptions{
3888 .applyImmediately = true})
3889 .get();
3890
3891 ALOGE_IF(error != NO_ERROR,
3892 "Error setting display brightness for display %s: %d (%s)",
Dominik Laskowski5d7de5f2022-11-03 12:38:32 -04003893 to_string(display->getId()).c_str(), error, strerror(error));
Alec Mouricdf16792021-12-10 13:16:06 -08003894 }
3895 display->persistBrightness(needsComposite);
3896 }
3897 }
3898}
3899
Vishnu Nair03ccbd62021-12-01 17:21:16 -08003900void SurfaceFlinger::buildWindowInfos(std::vector<WindowInfo>& outWindowInfos,
3901 std::vector<DisplayInfo>& outDisplayInfos) {
Dominik Laskowski9f410f02022-01-08 16:22:46 -08003902 static size_t sNumWindowInfos = 0;
3903 outWindowInfos.reserve(sNumWindowInfos);
3904 sNumWindowInfos = 0;
3905
Lloyd Pique30db6402023-06-26 18:56:51 +00003906 if (mLayerLifecycleManagerEnabled) {
Vishnu Nair3af0ec02023-02-10 04:13:48 +00003907 mLayerSnapshotBuilder.forEachInputSnapshot(
3908 [&outWindowInfos](const frontend::LayerSnapshot& snapshot) {
3909 outWindowInfos.push_back(snapshot.inputInfo);
3910 });
3911 } else {
3912 mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
3913 if (!layer->needsInputInfo()) return;
3914 const auto opt =
3915 mFrontEndDisplayInfos.get(layer->getLayerStack())
3916 .transform([](const frontend::DisplayInfo& info) {
3917 return Layer::InputDisplayArgs{&info.transform, info.isSecure};
3918 });
Dominik Laskowski29fa1462021-04-27 15:51:50 -07003919
Vishnu Nair3af0ec02023-02-10 04:13:48 +00003920 outWindowInfos.push_back(layer->fillInputInfo(opt.value_or(Layer::InputDisplayArgs{})));
3921 });
3922 }
Prabir Pradhand0aba782021-12-14 00:44:21 -08003923
Dominik Laskowski9f410f02022-01-08 16:22:46 -08003924 sNumWindowInfos = outWindowInfos.size();
3925
Vishnu Nair67b431c2022-11-16 01:54:05 +00003926 outDisplayInfos.reserve(mFrontEndDisplayInfos.size());
3927 for (const auto& [_, info] : mFrontEndDisplayInfos) {
Dominik Laskowski9f410f02022-01-08 16:22:46 -08003928 outDisplayInfos.push_back(info.info);
Prabir Pradhand0aba782021-12-14 00:44:21 -08003929 }
Robert Carr720e5062018-07-30 17:45:14 -07003930}
3931
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07003932void SurfaceFlinger::updateCursorAsync() {
Lloyd Piquec7b0c752019-03-07 20:59:59 -08003933 compositionengine::CompositionRefreshArgs refreshArgs;
Dominik Laskowski298b08e2022-02-15 13:45:02 -08003934 for (const auto& [_, display] : FTL_FAKE_GUARD(mStateLock, mDisplays)) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02003935 if (HalDisplayId::tryCast(display->getId())) {
Lloyd Piquec7b0c752019-03-07 20:59:59 -08003936 refreshArgs.outputs.push_back(display->getCompositionDisplay());
Riley Andrews03414a12014-07-01 14:22:59 -07003937 }
3938 }
Dominik Laskowski16a345b2023-04-27 17:07:33 -04003939
3940 constexpr bool kCursorOnly = true;
3941 const auto layers = moveSnapshotsToCompositionArgs(refreshArgs, kCursorOnly);
Lloyd Piquec7b0c752019-03-07 20:59:59 -08003942 mCompositionEngine->updateCursorAsync(refreshArgs);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00003943 moveSnapshotsFromCompositionArgs(refreshArgs, layers);
Mathias Agopian4fec8732012-06-29 14:12:52 -07003944}
3945
Dominik Laskowski66295432023-03-14 12:25:36 -04003946void SurfaceFlinger::requestHardwareVsync(PhysicalDisplayId displayId, bool enable) {
3947 getHwComposer().setVsyncEnabled(displayId, enable ? hal::Vsync::ENABLE : hal::Vsync::DISABLE);
3948}
3949
Dominik Laskowski530d6bd2022-10-10 16:55:54 -04003950void SurfaceFlinger::requestDisplayModes(std::vector<display::DisplayModeRequest> modeRequests) {
ramindani69b58e82022-09-26 16:48:36 -07003951 if (mBootStage != BootStage::FINISHED) {
3952 ALOGV("Currently in the boot stage, skipping display mode changes");
3953 return;
3954 }
3955
3956 ATRACE_CALL();
Dominik Laskowski530d6bd2022-10-10 16:55:54 -04003957
Ady Abraham8a82ba62020-01-17 12:43:17 -08003958 // If this is called from the main thread mStateLock must be locked before
3959 // Currently the only way to call this function from the main thread is from
Ady Abraham62a0be22020-12-08 16:54:10 -08003960 // Scheduler::chooseRefreshRateForContent
Ady Abraham8a82ba62020-01-17 12:43:17 -08003961
3962 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
Marin Shalamanova63f9ae2021-11-03 15:05:16 +01003963
Dominik Laskowski530d6bd2022-10-10 16:55:54 -04003964 for (auto& request : modeRequests) {
Ady Abrahamace3d052022-11-17 16:25:05 -08003965 const auto& modePtr = request.mode.modePtr;
Dominik Laskowskifc378b02022-12-02 14:56:05 -05003966
3967 const auto displayId = modePtr->getPhysicalDisplayId();
3968 const auto display = getDisplayDeviceLocked(displayId);
Dominik Laskowski530d6bd2022-10-10 16:55:54 -04003969
3970 if (!display) continue;
3971
Dominik Laskowskifdac5652023-06-29 12:01:13 -04003972 if (!display->isPoweredOn()) {
3973 ALOGV("%s(%s): Display is powered off", __func__, to_string(displayId).c_str());
Dominik Laskowskifc378b02022-12-02 14:56:05 -05003974 continue;
3975 }
3976
Ady Abrahamace3d052022-11-17 16:25:05 -08003977 if (display->refreshRateSelector().isModeAllowed(request.mode)) {
Dominik Laskowski530d6bd2022-10-10 16:55:54 -04003978 setDesiredActiveMode(std::move(request));
3979 } else {
3980 ALOGV("%s: Mode %d is disallowed for display %s", __func__, modePtr->getId().value(),
Dominik Laskowskifdac5652023-06-29 12:01:13 -04003981 to_string(displayId).c_str());
Dominik Laskowski530d6bd2022-10-10 16:55:54 -04003982 }
3983 }
Ady Abraham2139f732019-11-13 18:56:40 -08003984}
3985
Ady Abraham62a0be22020-12-08 16:54:10 -08003986void SurfaceFlinger::triggerOnFrameRateOverridesChanged() {
3987 PhysicalDisplayId displayId = [&]() {
3988 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
3989 return getDefaultDisplayDeviceLocked()->getPhysicalId();
3990 }();
3991
3992 mScheduler->onFrameRateOverridesChanged(mAppConnectionHandle, displayId);
3993}
3994
jimmyshiu4e211772023-06-15 15:18:38 +00003995void SurfaceFlinger::notifyCpuLoadUp() {
3996 mPowerAdvisor->notifyCpuLoadUp();
3997}
3998
Ady Abraham822ecbd2023-07-07 16:16:09 -07003999void SurfaceFlinger::onChoreographerAttached() {
4000 ATRACE_CALL();
4001 if (mLayerLifecycleManagerEnabled) {
4002 mUpdateAttachedChoreographer = true;
4003 scheduleCommit(FrameHint::kNone);
4004 }
4005}
4006
Dominik Laskowski68399272022-09-15 07:54:46 -07004007void SurfaceFlinger::initScheduler(const sp<const DisplayDevice>& display) {
Dominik Laskowski1c99a002023-01-20 17:10:36 -05004008 using namespace scheduler;
4009
Dominik Laskowski68399272022-09-15 07:54:46 -07004010 LOG_ALWAYS_FATAL_IF(mScheduler);
4011
Ady Abrahamace3d052022-11-17 16:25:05 -08004012 const auto activeMode = display->refreshRateSelector().getActiveMode();
4013 const Fps activeRefreshRate = activeMode.fps;
Dominik Laskowski02bb2072022-08-26 15:02:52 -07004014 mRefreshRateStats =
Dominik Laskowski1c99a002023-01-20 17:10:36 -05004015 std::make_unique<RefreshRateStats>(*mTimeStats, activeRefreshRate, hal::PowerMode::OFF);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07004016
Dominik Laskowski02bb2072022-08-26 15:02:52 -07004017 mVsyncConfiguration = getFactory().createVsyncConfiguration(activeRefreshRate);
Ady Abraham9e16a482019-12-03 17:19:41 -08004018
Dominik Laskowski1c99a002023-01-20 17:10:36 -05004019 FeatureFlags features;
Dominik Laskowski9c93d602021-10-07 19:38:26 -07004020
Dominik Laskowski068173d2021-08-11 17:22:59 -07004021 if (sysprop::use_content_detection_for_refresh_rate(false)) {
4022 features |= Feature::kContentDetection;
4023 }
4024 if (base::GetBoolProperty("debug.sf.show_predicted_vsync"s, false)) {
4025 features |= Feature::kTracePredictedVsync;
4026 }
4027 if (!base::GetBoolProperty("debug.sf.vsync_reactor_ignore_present_fences"s, false) &&
Ady Abrahamde549d42022-01-26 19:19:17 -08004028 !getHwComposer().hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
Dominik Laskowski068173d2021-08-11 17:22:59 -07004029 features |= Feature::kPresentFences;
Dominik Laskowski9c93d602021-10-07 19:38:26 -07004030 }
Dominik Laskowski596a2562022-10-28 11:26:12 -04004031 if (display->refreshRateSelector().kernelIdleTimerController()) {
Dominik Laskowski03cfce82022-11-02 12:13:29 -04004032 features |= Feature::kKernelIdleTimer;
4033 }
Lloyd Pique30db6402023-06-26 18:56:51 +00004034 if (mBackpressureGpuComposition) {
Dominik Laskowskib418dd72023-06-13 17:31:04 -04004035 features |= Feature::kBackpressureGpuComposition;
4036 }
Dominik Laskowski03cfce82022-11-02 12:13:29 -04004037
Dominik Laskowski1c99a002023-01-20 17:10:36 -05004038 auto modulatorPtr = sp<VsyncModulator>::make(mVsyncConfiguration->getCurrentConfigs());
4039
4040 mScheduler = std::make_unique<Scheduler>(static_cast<ICompositor&>(*this),
4041 static_cast<ISchedulerCallback&>(*this), features,
4042 std::move(modulatorPtr));
Dominik Laskowski596a2562022-10-28 11:26:12 -04004043 mScheduler->registerDisplay(display->getPhysicalId(), display->holdRefreshRateSelector());
Dominik Laskowski9c93d602021-10-07 19:38:26 -07004044 mScheduler->startTimers();
4045
Ady Abraham9c53ee72020-07-22 21:16:18 -07004046 const auto configs = mVsyncConfiguration->getCurrentConfigs();
Dominik Laskowski1c99a002023-01-20 17:10:36 -05004047
Steven Thomas2bbaabe2019-08-28 16:08:35 -07004048 mAppConnectionHandle =
Dominik Laskowski1c99a002023-01-20 17:10:36 -05004049 mScheduler->createEventThread(Scheduler::Cycle::Render,
4050 mFrameTimeline->getTokenManager(),
4051 /* workDuration */ configs.late.appWorkDuration,
4052 /* readyDuration */ configs.late.sfWorkDuration);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07004053 mSfConnectionHandle =
Dominik Laskowski1c99a002023-01-20 17:10:36 -05004054 mScheduler->createEventThread(Scheduler::Cycle::LastComposite,
4055 mFrameTimeline->getTokenManager(),
4056 /* workDuration */ activeRefreshRate.getPeriod(),
4057 /* readyDuration */ configs.late.sfWorkDuration);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07004058
Leon Scroggins III67388622023-02-06 20:36:20 -05004059 mScheduler->initVsync(mScheduler->getVsyncSchedule()->getDispatch(),
Dominik Laskowski5d164f22022-07-07 07:56:07 -07004060 *mFrameTimeline->getTokenManager(), configs.late.sfWorkDuration);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07004061
4062 mRegionSamplingThread =
Ady Abrahamd11bade2022-08-01 16:18:03 -07004063 sp<RegionSamplingThread>::make(*this,
4064 RegionSamplingThread::EnvironmentTimingTunables());
4065 mFpsReporter = sp<FpsReporter>::make(*mFrameTimeline, *this);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07004066}
4067
Dominik Laskowski1c99a002023-01-20 17:10:36 -05004068void SurfaceFlinger::updatePhaseConfiguration(Fps refreshRate) {
Marin Shalamanov5801c942020-12-17 17:00:13 +01004069 mVsyncConfiguration->setRefreshRateFps(refreshRate);
Dominik Laskowski1c99a002023-01-20 17:10:36 -05004070 mScheduler->setVsyncConfigSet(mVsyncConfiguration->getCurrentConfigs(),
4071 refreshRate.getPeriod());
Dominik Laskowski08d05c22020-07-22 00:05:08 -07004072}
4073
Dominik Laskowski9e168db2021-05-27 16:05:12 -07004074void SurfaceFlinger::doCommitTransactions() {
Robert Carr6a160312021-05-17 12:08:20 -07004075 ATRACE_CALL();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004076
Lloyd Pique58e24a32019-08-01 15:50:14 -07004077 if (!mLayersPendingRemoval.isEmpty()) {
4078 // Notify removed layers now that they can't be drawn from
4079 for (const auto& l : mLayersPendingRemoval) {
Lloyd Pique58e24a32019-08-01 15:50:14 -07004080 // Ensure any buffers set to display on any children are released.
4081 if (l->isRemovedFromCurrentState()) {
4082 l->latchAndReleaseBuffer();
4083 }
4084
chaviw6852bff2022-04-19 17:35:11 -05004085 // If a layer has a parent, we allow it to out-live it's handle
4086 // with the idea that the parent holds a reference and will eventually
4087 // be cleaned up. However no one cleans up the top-level so we do so
4088 // here.
4089 if (l->isAtRoot()) {
4090 l->setIsAtRoot(false);
4091 mCurrentState.layersSortedByZ.remove(l);
4092 }
4093
Lloyd Pique58e24a32019-08-01 15:50:14 -07004094 // If the layer has been removed and has no parent, then it will not be reachable
4095 // when traversing layers on screen. Add the layer to the offscreenLayers set to
4096 // ensure we can copy its current to drawing state.
4097 if (!l->getParent()) {
4098 mOffscreenLayers.emplace(l.get());
4099 }
4100 }
4101 mLayersPendingRemoval.clear();
4102 }
4103
Lloyd Pique58e24a32019-08-01 15:50:14 -07004104 mDrawingState = mCurrentState;
4105 // clear the "changed" flags in current state
4106 mCurrentState.colorMatrixChanged = false;
4107
Robert Carra70e91c2021-06-11 13:59:52 -07004108 if (mVisibleRegionsDirty) {
4109 for (const auto& rootLayer : mDrawingState.layersSortedByZ) {
4110 rootLayer->commitChildList();
4111 }
Andrei Stanciudadac5a2020-08-05 17:02:34 +03004112 }
Robert Carra70e91c2021-06-11 13:59:52 -07004113
Lloyd Pique58e24a32019-08-01 15:50:14 -07004114 commitOffscreenLayers();
Vishnu Nair3be61902023-04-26 19:47:29 -07004115 if (mLayerMirrorRoots.size() > 0) {
4116 std::deque<Layer*> pendingUpdates;
4117 pendingUpdates.insert(pendingUpdates.end(), mLayerMirrorRoots.begin(),
4118 mLayerMirrorRoots.end());
4119 std::vector<Layer*> needsUpdating;
4120 for (Layer* cloneRoot : mLayerMirrorRoots) {
4121 pendingUpdates.pop_front();
4122 if (cloneRoot->isRemovedFromCurrentState()) {
4123 continue;
4124 }
4125 if (cloneRoot->updateMirrorInfo(pendingUpdates)) {
4126 } else {
4127 needsUpdating.push_back(cloneRoot);
4128 }
4129 }
4130 for (Layer* cloneRoot : needsUpdating) {
4131 cloneRoot->updateMirrorInfo({});
4132 }
Robert Carr6a0382d2021-07-01 15:57:17 -07004133 }
Lloyd Pique58e24a32019-08-01 15:50:14 -07004134}
4135
chaviw74d90ad2019-04-26 14:45:26 -07004136void SurfaceFlinger::commitOffscreenLayers() {
4137 for (Layer* offscreenLayer : mOffscreenLayers) {
Edgar Arriaga844fa672020-01-16 14:21:42 -08004138 offscreenLayer->traverse(LayerVector::StateSet::Drawing, [](Layer* layer) {
Dominik Laskowski9e168db2021-05-27 16:05:12 -07004139 if (layer->clearTransactionFlags(eTransactionNeeded)) {
Vishnu Naira156f482023-02-22 00:23:38 +00004140 layer->doTransaction(0);
Dominik Laskowski9e168db2021-05-27 16:05:12 -07004141 layer->commitChildList();
4142 }
chaviw74d90ad2019-04-26 14:45:26 -07004143 });
4144 }
4145}
4146
Vishnu Nair3af0ec02023-02-10 04:13:48 +00004147void SurfaceFlinger::invalidateLayerStack(const ui::LayerFilter& layerFilter, const Region& dirty) {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08004148 for (const auto& [token, displayDevice] : FTL_FAKE_GUARD(mStateLock, mDisplays)) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07004149 auto display = displayDevice->getCompositionDisplay();
Vishnu Nair3af0ec02023-02-10 04:13:48 +00004150 if (display->includesLayer(layerFilter)) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07004151 display->editState().dirtyRegion.orSelf(dirty);
Mathias Agopian92a979a2012-08-02 18:32:23 -07004152 }
4153 }
Mathias Agopian87baae12012-07-31 12:38:26 -07004154}
4155
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07004156bool SurfaceFlinger::latchBuffers() {
Ady Abraham09bd3922019-04-08 10:44:56 -07004157 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08004158
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07004159 const nsecs_t latchTime = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004160
Mathias Agopian4fec8732012-06-29 14:12:52 -07004161 bool visibleRegions = false;
Dan Stoza6b9454d2014-11-07 16:00:59 -08004162 bool frameQueued = false;
Mike Stroyan0cd76192017-04-20 12:10:48 -06004163 bool newDataLatched = false;
Eric Penner51c59cd2014-07-28 19:51:58 -07004164
4165 // Store the set of layers that need updates. This set must not change as
4166 // buffers are being latched, as this could result in a deadlock.
4167 // Example: Two producers share the same command stream and:
4168 // 1.) Layer 0 is latched
4169 // 2.) Layer 0 gets a new frame
4170 // 2.) Layer 1 gets a new frame
4171 // 3.) Layer 1 is latched.
4172 // Display is now waiting on Layer 1's frame, which is behind layer 0's
4173 // second frame. But layer 0's second frame could be waiting on display.
Edgar Arriaga844fa672020-01-16 14:21:42 -08004174 mDrawingState.traverse([&](Layer* layer) {
Dominik Laskowski9e168db2021-05-27 16:05:12 -07004175 if (layer->clearTransactionFlags(eTransactionNeeded) || mForceTransactionDisplayChange) {
Vishnu Naira156f482023-02-22 00:23:38 +00004176 const uint32_t flags = layer->doTransaction(0);
Dominik Laskowski9e168db2021-05-27 16:05:12 -07004177 if (flags & Layer::eVisibleRegion) {
4178 mVisibleRegionsDirty = true;
4179 }
4180 }
Robert Carrb552ff52021-06-11 13:35:54 -07004181
Vishnu Nair7ee4f462023-04-19 09:54:09 -07004182 if (layer->hasReadyFrame() || layer->willReleaseBufferOnLatch()) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08004183 frameQueued = true;
Ady Abrahamd11bade2022-08-01 16:18:03 -07004184 mLayersWithQueuedFrames.emplace(sp<Layer>::fromExisting(layer));
Dominik Laskowski9e168db2021-05-27 16:05:12 -07004185 } else {
Dan Stozaee44edd2015-03-23 15:50:23 -07004186 layer->useEmptyDamage();
Vishnu Nairc09c0232023-03-02 03:22:35 +00004187 if (!layer->hasBuffer()) {
4188 // The last latch time is used to classify a missed frame as buffer stuffing
4189 // instead of a missed frame. This is used to identify scenarios where we
4190 // could not latch a buffer or apply a transaction due to backpressure.
4191 // We only update the latch time for buffer less layers here, the latch time
4192 // is updated for buffer layers when the buffer is latched.
4193 layer->updateLastLatchTime(latchTime);
4194 }
Dan Stoza6b9454d2014-11-07 16:00:59 -08004195 }
Robert Carr2047fae2016-11-28 14:09:09 -08004196 });
Robert Carrb552ff52021-06-11 13:35:54 -07004197 mForceTransactionDisplayChange = false;
Robert Carr2047fae2016-11-28 14:09:09 -08004198
chaviw49a108c2019-08-12 11:23:06 -07004199 // The client can continue submitting buffers for offscreen layers, but they will not
4200 // be shown on screen. Therefore, we need to latch and release buffers of offscreen
4201 // layers to ensure dequeueBuffer doesn't block indefinitely.
4202 for (Layer* offscreenLayer : mOffscreenLayers) {
Edgar Arriaga844fa672020-01-16 14:21:42 -08004203 offscreenLayer->traverse(LayerVector::StateSet::Drawing,
chaviw49a108c2019-08-12 11:23:06 -07004204 [&](Layer* l) { l->latchAndReleaseBuffer(); });
4205 }
4206
Lloyd Piquef2c79392018-12-20 16:23:33 -08004207 if (!mLayersWithQueuedFrames.empty()) {
4208 // mStateLock is needed for latchBuffer as LayerRejecter::reject()
4209 // writes to Layer current state. See also b/119481871
4210 Mutex::Autolock lock(mStateLock);
4211
Alec Mouri2f7d9ae2020-11-30 19:32:33 -08004212 for (const auto& layer : mLayersWithQueuedFrames) {
Vishnu Nair7ee4f462023-04-19 09:54:09 -07004213 if (layer->willReleaseBufferOnLatch()) {
4214 mLayersWithBuffersRemoved.emplace(layer);
4215 }
Vishnu Nair397a0e32022-07-26 00:01:48 +00004216 if (layer->latchBuffer(visibleRegions, latchTime)) {
Vishnu Nair6194e2e2019-02-06 12:58:39 -08004217 mLayersPendingRefresh.push_back(layer);
Lloyd Piquef2c79392018-12-20 16:23:33 -08004218 newDataLatched = true;
4219 }
Vishnu Nair1b700192022-02-04 10:09:47 -08004220 layer->useSurfaceDamage();
Mike Stroyan0cd76192017-04-20 12:10:48 -06004221 }
Mathias Agopian4fec8732012-06-29 14:12:52 -07004222 }
Mathias Agopian4da75192010-08-10 17:19:56 -07004223
Mathias Agopian3b1d2b62012-07-11 13:48:17 -07004224 mVisibleRegionsDirty |= visibleRegions;
Dan Stoza6b9454d2014-11-07 16:00:59 -08004225
4226 // If we will need to wake up at some time in the future to deal with a
4227 // queued frame that shouldn't be displayed during this vsync period, wake
4228 // up during the next vsync period to check again.
Chia-I Wua36bf922017-06-30 12:51:05 -07004229 if (frameQueued && (mLayersWithQueuedFrames.empty() || !newDataLatched)) {
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07004230 scheduleCommit(FrameHint::kNone);
Dan Stoza6b9454d2014-11-07 16:00:59 -08004231 }
4232
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08004233 // enter boot animation on first buffer latch
4234 if (CC_UNLIKELY(mBootStage == BootStage::BOOTLOADER && newDataLatched)) {
4235 ALOGI("Enter boot animation");
4236 mBootStage = BootStage::BOOTANIMATION;
4237 }
4238
Vishnu Nair3be61902023-04-26 19:47:29 -07004239 if (mLayerMirrorRoots.size() > 0) {
Robert Carr6a0382d2021-07-01 15:57:17 -07004240 mDrawingState.traverse([&](Layer* layer) { layer->updateCloneBufferInfo(); });
4241 }
chaviw74b03172019-08-19 11:09:03 -07004242
Dan Stoza6b9454d2014-11-07 16:00:59 -08004243 // Only continue with the refresh if there is actually new work to do
Mike Stroyan0cd76192017-04-20 12:10:48 -06004244 return !mLayersWithQueuedFrames.empty() && newDataLatched;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004245}
4246
Vishnu Nair1391de22023-03-05 19:56:14 -08004247status_t SurfaceFlinger::addClientLayer(LayerCreationArgs& args, const sp<IBinder>& handle,
Vishnu Nair0fc7af52022-01-13 08:11:34 -08004248 const sp<Layer>& layer, const wp<Layer>& parent,
Vishnu Naircb8be502022-10-12 19:03:23 +00004249 uint32_t* outTransformHint) {
Huihong Luo1b0c49f2022-03-15 19:18:21 -07004250 if (mNumLayers >= MAX_LAYERS) {
arthurhungdba591c2021-02-08 17:28:49 +08004251 ALOGE("AddClientLayer failed, mNumLayers (%zu) >= MAX_LAYERS (%zu)", mNumLayers.load(),
Huihong Luo1b0c49f2022-03-15 19:18:21 -07004252 MAX_LAYERS);
Robert Carr26b98f42022-04-11 15:54:31 -07004253 static_cast<void>(mScheduler->schedule([=] {
Vishnu Nair787aa782023-03-17 13:46:46 -07004254 ALOGE("Dumping layer keeping > 20 children alive:");
4255 bool leakingParentLayerFound = false;
4256 mDrawingState.traverse([&](Layer* layer) {
4257 if (leakingParentLayerFound) {
4258 return;
4259 }
4260 if (layer->getChildrenCount() > 20) {
4261 leakingParentLayerFound = true;
4262 sp<Layer> parent = sp<Layer>::fromExisting(layer);
4263 while (parent) {
Vishnu Nair3be61902023-04-26 19:47:29 -07004264 ALOGE("Parent Layer: %s%s", parent->getName().c_str(),
4265 (parent->isHandleAlive() ? "handleAlive" : ""));
Vishnu Nair787aa782023-03-17 13:46:46 -07004266 parent = parent->getParent();
4267 }
4268 // Sample up to 100 layers
4269 ALOGE("Dumping random sampling of child layers total(%zu): ",
4270 layer->getChildrenCount());
4271 int sampleSize = (layer->getChildrenCount() / 100) + 1;
4272 layer->traverseChildren([&](Layer* layer) {
4273 if (rand() % sampleSize == 0) {
4274 ALOGE("Child Layer: %s", layer->getName().c_str());
4275 }
4276 });
4277 }
4278 });
4279
Vishnu Nair3be61902023-04-26 19:47:29 -07004280 int numLayers = 0;
4281 mDrawingState.traverse([&](Layer* layer) { numLayers++; });
4282
4283 ALOGE("Dumping random sampling of on-screen layers total(%u):", numLayers);
Vishnu Nair787aa782023-03-17 13:46:46 -07004284 mDrawingState.traverse([&](Layer* layer) {
Robert Carr26b98f42022-04-11 15:54:31 -07004285 // Aim to dump about 200 layers to avoid totally trashing
4286 // logcat. On the other hand, if there really are 4096 layers
4287 // something has gone totally wrong its probably the most
4288 // useful information in logcat.
4289 if (rand() % 20 == 13) {
Vishnu Nair3be61902023-04-26 19:47:29 -07004290 ALOGE("Layer: %s%s", layer->getName().c_str(),
4291 (layer->isHandleAlive() ? "handleAlive" : ""));
4292 std::this_thread::sleep_for(std::chrono::milliseconds(5));
Robert Carr26b98f42022-04-11 15:54:31 -07004293 }
4294 });
Vishnu Nair787aa782023-03-17 13:46:46 -07004295 ALOGE("Dumping random sampling of off-screen layers total(%zu): ",
4296 mOffscreenLayers.size());
Robert Carr26b98f42022-04-11 15:54:31 -07004297 for (Layer* offscreenLayer : mOffscreenLayers) {
4298 if (rand() % 20 == 13) {
Vishnu Nair3be61902023-04-26 19:47:29 -07004299 ALOGE("Offscreen-layer: %s%s", offscreenLayer->getName().c_str(),
4300 (offscreenLayer->isHandleAlive() ? "handleAlive" : ""));
4301 std::this_thread::sleep_for(std::chrono::milliseconds(5));
Robert Carr26b98f42022-04-11 15:54:31 -07004302 }
4303 }
4304 }));
arthurhungdba591c2021-02-08 17:28:49 +08004305 return NO_MEMORY;
Dan Stoza7d89d062015-04-30 13:29:25 -07004306 }
4307
Vishnu Nair86e11902022-09-06 16:03:27 +00004308 layer->updateTransformHint(mActiveDisplayTransformHint);
4309 if (outTransformHint) {
4310 *outTransformHint = mActiveDisplayTransformHint;
4311 }
Vishnu Nair1391de22023-03-05 19:56:14 -08004312 args.parentId = LayerHandle::getLayerId(args.parentHandle.promote());
4313 args.layerIdToMirror = LayerHandle::getLayerId(args.mirrorLayerHandle.promote());
Vishnu Nair0fc7af52022-01-13 08:11:34 -08004314 {
4315 std::scoped_lock<std::mutex> lock(mCreatedLayersLock);
Vishnu Naircb8be502022-10-12 19:03:23 +00004316 mCreatedLayers.emplace_back(layer, parent, args.addToRoot);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00004317 mNewLayers.emplace_back(std::make_unique<frontend::RequestedLayerState>(args));
Vishnu Nair81750622023-03-08 15:02:06 -08004318 args.mirrorLayerHandle.clear();
4319 args.parentHandle.clear();
4320 mNewLayerArgs.emplace_back(std::move(args));
Vishnu Nair0fc7af52022-01-13 08:11:34 -08004321 }
arthurhungdba591c2021-02-08 17:28:49 +08004322
Vishnu Nair0fc7af52022-01-13 08:11:34 -08004323 setTransactionFlags(eTransactionNeeded);
4324 return NO_ERROR;
Mathias Agopian96f08192010-06-02 23:28:45 -07004325}
4326
Dominik Laskowski9e168db2021-05-27 16:05:12 -07004327uint32_t SurfaceFlinger::getTransactionFlags() const {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07004328 return mTransactionFlags;
Mathias Agopiandea20b12011-05-03 17:04:02 -07004329}
4330
Dominik Laskowski9e168db2021-05-27 16:05:12 -07004331uint32_t SurfaceFlinger::clearTransactionFlags(uint32_t mask) {
Vishnu Naire4f00c52023-01-31 20:20:18 -08004332 uint32_t transactionFlags = mTransactionFlags.fetch_and(~mask);
4333 ATRACE_INT("mTransactionFlags", transactionFlags);
4334 return transactionFlags & mask;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004335}
4336
Dominik Laskowski94000c42022-03-17 12:55:14 -07004337void SurfaceFlinger::setTransactionFlags(uint32_t mask, TransactionSchedule schedule,
Dominik Laskowski1f6fc702022-03-21 08:34:50 -07004338 const sp<IBinder>& applyToken, FrameHint frameHint) {
Leon Scroggins III67388622023-02-06 20:36:20 -05004339 mScheduler->modulateVsync({}, &VsyncModulator::setTransactionSchedule, schedule, applyToken);
Vishnu Naire4f00c52023-01-31 20:20:18 -08004340 uint32_t transactionFlags = mTransactionFlags.fetch_or(mask);
4341 ATRACE_INT("mTransactionFlags", transactionFlags);
Dominik Laskowski94000c42022-03-17 12:55:14 -07004342
Vishnu Naire4f00c52023-01-31 20:20:18 -08004343 if (const bool scheduled = transactionFlags & mask; !scheduled) {
Dominik Laskowski1f6fc702022-03-21 08:34:50 -07004344 scheduleCommit(frameHint);
Ady Abraham27bcb552023-01-21 04:34:22 +00004345 } else if (frameHint == FrameHint::kActive) {
4346 // Even if the next frame is already scheduled, we should reset the idle timer
4347 // as a new activity just happened.
4348 mScheduler->resetIdleTimer();
Dominik Laskowski94000c42022-03-17 12:55:14 -07004349 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004350}
4351
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004352TransactionHandler::TransactionReadiness SurfaceFlinger::transactionReadyTimelineCheck(
4353 const TransactionHandler::TransactionFlushState& flushState) {
Dominik Laskowskie85d7fa2023-05-15 10:50:22 -04004354 const auto& transaction = *flushState.transaction;
Dominik Laskowskib418dd72023-06-13 17:31:04 -04004355
4356 const TimePoint desiredPresentTime = TimePoint::fromNs(transaction.desiredPresentTime);
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05004357 const TimePoint expectedPresentTime = mScheduler->expectedPresentTimeForPacesetter();
Dominik Laskowskib418dd72023-06-13 17:31:04 -04004358
4359 using TransactionReadiness = TransactionHandler::TransactionReadiness;
4360
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004361 // Do not present if the desiredPresentTime has not passed unless it is more than
4362 // one second in the future. We ignore timestamps more than 1 second in the future
4363 // for stability reasons.
Dominik Laskowskib418dd72023-06-13 17:31:04 -04004364 if (!transaction.isAutoTimestamp && desiredPresentTime >= expectedPresentTime &&
4365 desiredPresentTime < expectedPresentTime + 1s) {
Vishnu Nair73cc9fd2023-04-18 11:18:07 -07004366 ATRACE_FORMAT("not current desiredPresentTime: %" PRId64 " expectedPresentTime: %" PRId64,
Dominik Laskowskib418dd72023-06-13 17:31:04 -04004367 desiredPresentTime, expectedPresentTime);
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004368 return TransactionReadiness::NotReady;
Ady Abrahame1bfaac2022-02-22 21:32:08 -08004369 }
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004370
Dominik Laskowskib418dd72023-06-13 17:31:04 -04004371 if (!mScheduler->isVsyncValid(expectedPresentTime, transaction.originUid)) {
4372 ATRACE_FORMAT("!isVsyncValid expectedPresentTime: %" PRId64 " uid: %d", expectedPresentTime,
4373 transaction.originUid);
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004374 return TransactionReadiness::NotReady;
4375 }
4376
4377 // If the client didn't specify desiredPresentTime, use the vsyncId to determine the
4378 // expected present time of this transaction.
4379 if (transaction.isAutoTimestamp &&
Dominik Laskowskib418dd72023-06-13 17:31:04 -04004380 frameIsEarly(expectedPresentTime, VsyncId{transaction.frameTimelineInfo.vsyncId})) {
Vishnu Nair73cc9fd2023-04-18 11:18:07 -07004381 ATRACE_FORMAT("frameIsEarly vsyncId: %" PRId64 " expectedPresentTime: %" PRId64,
Dominik Laskowskib418dd72023-06-13 17:31:04 -04004382 transaction.frameTimelineInfo.vsyncId, expectedPresentTime);
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004383 return TransactionReadiness::NotReady;
4384 }
Dominik Laskowskib418dd72023-06-13 17:31:04 -04004385
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004386 return TransactionReadiness::Ready;
4387}
4388
Vishnu Nair4d9cef92023-06-24 22:34:41 +00004389TransactionHandler::TransactionReadiness SurfaceFlinger::transactionReadyBufferCheckLegacy(
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004390 const TransactionHandler::TransactionFlushState& flushState) {
4391 using TransactionReadiness = TransactionHandler::TransactionReadiness;
4392 auto ready = TransactionReadiness::Ready;
Vishnu Nair4d9cef92023-06-24 22:34:41 +00004393 flushState.transaction->traverseStatesWithBuffersWhileTrue([&](const ResolvedComposerState&
4394 resolvedState) -> bool {
4395 sp<Layer> layer = LayerHandle::getLayer(resolvedState.state.surface);
4396
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004397 const auto& transaction = *flushState.transaction;
Vishnu Nair4d9cef92023-06-24 22:34:41 +00004398 const auto& s = resolvedState.state;
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004399 // check for barrier frames
liulijuneb489f62022-10-17 22:02:14 +08004400 if (s.bufferData->hasBarrier) {
4401 // The current producerId is already a newer producer than the buffer that has a
4402 // barrier. This means the incoming buffer is older and we can release it here. We
4403 // don't wait on the barrier since we know that's stale information.
Vishnu Nair63221212023-04-06 15:17:37 -07004404 if (layer->getDrawingState().barrierProducerId > s.bufferData->producerId) {
liulijuneb489f62022-10-17 22:02:14 +08004405 layer->callReleaseBufferCallback(s.bufferData->releaseBufferListener,
Vishnu Nair4d9cef92023-06-24 22:34:41 +00004406 resolvedState.externalTexture->getBuffer(),
Chavi Weingartenc8bcb682023-03-06 22:20:42 +00004407 s.bufferData->frameNumber,
liulijuneb489f62022-10-17 22:02:14 +08004408 s.bufferData->acquireFence);
4409 // Delete the entire state at this point and not just release the buffer because
4410 // everything associated with the Layer in this Transaction is now out of date.
Vishnu Nair73cc9fd2023-04-18 11:18:07 -07004411 ATRACE_FORMAT("DeleteStaleBuffer %s barrierProducerId:%d > %d",
4412 layer->getDebugName(), layer->getDrawingState().barrierProducerId,
4413 s.bufferData->producerId);
liulijuneb489f62022-10-17 22:02:14 +08004414 return TraverseBuffersReturnValues::DELETE_AND_CONTINUE_TRAVERSAL;
4415 }
4416
Vishnu Nair63221212023-04-06 15:17:37 -07004417 if (layer->getDrawingState().barrierFrameNumber < s.bufferData->barrierFrameNumber) {
liulijuneb489f62022-10-17 22:02:14 +08004418 const bool willApplyBarrierFrame =
4419 flushState.bufferLayersReadyToPresent.contains(s.surface.get()) &&
4420 ((flushState.bufferLayersReadyToPresent.get(s.surface.get()) >=
4421 s.bufferData->barrierFrameNumber));
4422 if (!willApplyBarrierFrame) {
Vishnu Nair73cc9fd2023-04-18 11:18:07 -07004423 ATRACE_FORMAT("NotReadyBarrier %s barrierFrameNumber:%" PRId64 " > %" PRId64,
4424 layer->getDebugName(),
4425 layer->getDrawingState().barrierFrameNumber,
4426 s.bufferData->barrierFrameNumber);
liulijuneb489f62022-10-17 22:02:14 +08004427 ready = TransactionReadiness::NotReadyBarrier;
4428 return TraverseBuffersReturnValues::STOP_TRAVERSAL;
4429 }
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004430 }
4431 }
4432
4433 // If backpressure is enabled and we already have a buffer to commit, keep
4434 // the transaction in the queue.
4435 const bool hasPendingBuffer =
4436 flushState.bufferLayersReadyToPresent.contains(s.surface.get());
4437 if (layer->backpressureEnabled() && hasPendingBuffer && transaction.isAutoTimestamp) {
Vishnu Nair73cc9fd2023-04-18 11:18:07 -07004438 ATRACE_FORMAT("hasPendingBuffer %s", layer->getDebugName());
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004439 ready = TransactionReadiness::NotReady;
liulijuneb489f62022-10-17 22:02:14 +08004440 return TraverseBuffersReturnValues::STOP_TRAVERSAL;
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004441 }
4442
Vishnu Nairf01a6f12023-04-03 22:34:17 +00004443 const bool acquireFenceAvailable = s.bufferData &&
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004444 s.bufferData->flags.test(BufferData::BufferDataChange::fenceChanged) &&
4445 s.bufferData->acquireFence;
Ying Wei1fd9bfc2023-06-29 16:47:00 +00004446 const bool fenceSignaled = !acquireFenceAvailable ||
Vishnu Nairf01a6f12023-04-03 22:34:17 +00004447 s.bufferData->acquireFence->getStatus() != Fence::Status::Unsignaled;
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004448 if (!fenceSignaled) {
Vishnu Nairf01a6f12023-04-03 22:34:17 +00004449 // check fence status
Vishnu Nair4d9cef92023-06-24 22:34:41 +00004450 const bool allowLatchUnsignaled = shouldLatchUnsignaled(s, transaction.states.size(),
4451 flushState.firstTransaction) &&
4452 layer->isSimpleBufferUpdate(s);
4453
Vishnu Nairf01a6f12023-04-03 22:34:17 +00004454 if (allowLatchUnsignaled) {
Vishnu Nair73cc9fd2023-04-18 11:18:07 -07004455 ATRACE_FORMAT("fence unsignaled try allowLatchUnsignaled %s",
4456 layer->getDebugName());
Vishnu Nairf01a6f12023-04-03 22:34:17 +00004457 ready = TransactionReadiness::NotReadyUnsignaled;
4458 } else {
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004459 ready = TransactionReadiness::NotReady;
4460 auto& listener = s.bufferData->releaseBufferListener;
4461 if (listener &&
4462 (flushState.queueProcessTime - transaction.postTime) >
4463 std::chrono::nanoseconds(4s).count()) {
Patrick Williamsf1e5df12022-10-17 21:37:42 +00004464 mTransactionHandler
4465 .onTransactionQueueStalled(transaction.id, listener,
4466 "Buffer processing hung up due to stuck "
4467 "fence. Indicates GPU hang");
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004468 }
Vishnu Nair73cc9fd2023-04-18 11:18:07 -07004469 ATRACE_FORMAT("fence unsignaled %s", layer->getDebugName());
liulijuneb489f62022-10-17 22:02:14 +08004470 return TraverseBuffersReturnValues::STOP_TRAVERSAL;
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004471 }
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004472 }
liulijuneb489f62022-10-17 22:02:14 +08004473 return TraverseBuffersReturnValues::CONTINUE_TRAVERSAL;
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004474 });
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004475 return ready;
4476}
4477
Vishnu Nair4d9cef92023-06-24 22:34:41 +00004478TransactionHandler::TransactionReadiness SurfaceFlinger::transactionReadyBufferCheck(
4479 const TransactionHandler::TransactionFlushState& flushState) {
4480 using TransactionReadiness = TransactionHandler::TransactionReadiness;
4481 auto ready = TransactionReadiness::Ready;
4482 flushState.transaction->traverseStatesWithBuffersWhileTrue([&](const ResolvedComposerState&
4483 resolvedState) -> bool {
4484 const frontend::RequestedLayerState* layer =
4485 mLayerLifecycleManager.getLayerFromId(resolvedState.layerId);
4486 const auto& transaction = *flushState.transaction;
4487 const auto& s = resolvedState.state;
4488 // check for barrier frames
4489 if (s.bufferData->hasBarrier) {
4490 // The current producerId is already a newer producer than the buffer that has a
4491 // barrier. This means the incoming buffer is older and we can release it here. We
4492 // don't wait on the barrier since we know that's stale information.
4493 if (layer->barrierProducerId > s.bufferData->producerId) {
4494 if (s.bufferData->releaseBufferListener) {
4495 uint32_t currentMaxAcquiredBufferCount =
4496 getMaxAcquiredBufferCountForCurrentRefreshRate(layer->ownerUid.val());
4497 ATRACE_FORMAT_INSTANT("callReleaseBufferCallback %s - %" PRIu64,
4498 layer->name.c_str(), s.bufferData->frameNumber);
4499 s.bufferData->releaseBufferListener
4500 ->onReleaseBuffer({resolvedState.externalTexture->getBuffer()->getId(),
4501 s.bufferData->frameNumber},
4502 s.bufferData->acquireFence
4503 ? s.bufferData->acquireFence
4504 : Fence::NO_FENCE,
4505 currentMaxAcquiredBufferCount);
4506 }
4507
4508 // Delete the entire state at this point and not just release the buffer because
4509 // everything associated with the Layer in this Transaction is now out of date.
4510 ATRACE_FORMAT("DeleteStaleBuffer %s barrierProducerId:%d > %d", layer->name.c_str(),
4511 layer->barrierProducerId, s.bufferData->producerId);
4512 return TraverseBuffersReturnValues::DELETE_AND_CONTINUE_TRAVERSAL;
4513 }
4514
4515 if (layer->barrierFrameNumber < s.bufferData->barrierFrameNumber) {
4516 const bool willApplyBarrierFrame =
4517 flushState.bufferLayersReadyToPresent.contains(s.surface.get()) &&
4518 ((flushState.bufferLayersReadyToPresent.get(s.surface.get()) >=
4519 s.bufferData->barrierFrameNumber));
4520 if (!willApplyBarrierFrame) {
4521 ATRACE_FORMAT("NotReadyBarrier %s barrierFrameNumber:%" PRId64 " > %" PRId64,
4522 layer->name.c_str(), layer->barrierFrameNumber,
4523 s.bufferData->barrierFrameNumber);
4524 ready = TransactionReadiness::NotReadyBarrier;
4525 return TraverseBuffersReturnValues::STOP_TRAVERSAL;
4526 }
4527 }
4528 }
4529
4530 // If backpressure is enabled and we already have a buffer to commit, keep
4531 // the transaction in the queue.
4532 const bool hasPendingBuffer =
4533 flushState.bufferLayersReadyToPresent.contains(s.surface.get());
4534 if (layer->backpressureEnabled() && hasPendingBuffer && transaction.isAutoTimestamp) {
4535 ATRACE_FORMAT("hasPendingBuffer %s", layer->name.c_str());
4536 ready = TransactionReadiness::NotReady;
4537 return TraverseBuffersReturnValues::STOP_TRAVERSAL;
4538 }
4539
Vishnu Nair4d9cef92023-06-24 22:34:41 +00004540 const bool acquireFenceAvailable = s.bufferData &&
4541 s.bufferData->flags.test(BufferData::BufferDataChange::fenceChanged) &&
4542 s.bufferData->acquireFence;
Ying Wei1fd9bfc2023-06-29 16:47:00 +00004543 const bool fenceSignaled = !acquireFenceAvailable ||
Vishnu Nair4d9cef92023-06-24 22:34:41 +00004544 s.bufferData->acquireFence->getStatus() != Fence::Status::Unsignaled;
4545 if (!fenceSignaled) {
4546 // check fence status
4547 const bool allowLatchUnsignaled = shouldLatchUnsignaled(s, transaction.states.size(),
4548 flushState.firstTransaction) &&
4549 layer->isSimpleBufferUpdate(s);
4550 if (allowLatchUnsignaled) {
4551 ATRACE_FORMAT("fence unsignaled try allowLatchUnsignaled %s", layer->name.c_str());
4552 ready = TransactionReadiness::NotReadyUnsignaled;
4553 } else {
4554 ready = TransactionReadiness::NotReady;
4555 auto& listener = s.bufferData->releaseBufferListener;
4556 if (listener &&
4557 (flushState.queueProcessTime - transaction.postTime) >
4558 std::chrono::nanoseconds(4s).count()) {
4559 mTransactionHandler
4560 .onTransactionQueueStalled(transaction.id, listener,
4561 "Buffer processing hung up due to stuck "
4562 "fence. Indicates GPU hang");
4563 }
4564 ATRACE_FORMAT("fence unsignaled %s", layer->name.c_str());
4565 return TraverseBuffersReturnValues::STOP_TRAVERSAL;
4566 }
4567 }
4568 return TraverseBuffersReturnValues::CONTINUE_TRAVERSAL;
4569 });
4570 return ready;
4571}
4572
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004573void SurfaceFlinger::addTransactionReadyFilters() {
4574 mTransactionHandler.addTransactionReadyFilter(
4575 std::bind(&SurfaceFlinger::transactionReadyTimelineCheck, this, std::placeholders::_1));
Lloyd Pique30db6402023-06-26 18:56:51 +00004576 if (mLayerLifecycleManagerEnabled) {
Vishnu Nair4d9cef92023-06-24 22:34:41 +00004577 mTransactionHandler.addTransactionReadyFilter(
4578 std::bind(&SurfaceFlinger::transactionReadyBufferCheck, this,
4579 std::placeholders::_1));
4580 } else {
4581 mTransactionHandler.addTransactionReadyFilter(
4582 std::bind(&SurfaceFlinger::transactionReadyBufferCheckLegacy, this,
4583 std::placeholders::_1));
4584 }
Ady Abrahame1bfaac2022-02-22 21:32:08 -08004585}
4586
Vishnu Nair42ad3192023-01-24 19:17:59 -08004587// For tests only
Dominik Laskowski08fbd852022-07-14 08:53:42 -07004588bool SurfaceFlinger::flushTransactionQueues(VsyncId vsyncId) {
Vishnu Nair4d9cef92023-06-24 22:34:41 +00004589 mTransactionHandler.collectTransactions();
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004590 std::vector<TransactionState> transactions = mTransactionHandler.flushTransactions();
Vishnu Nair42ad3192023-01-24 19:17:59 -08004591 return applyTransactions(transactions, vsyncId);
ramindani4d48f902021-09-20 21:07:45 +00004592}
4593
Vishnu Nair7891e962021-11-11 12:07:21 -08004594bool SurfaceFlinger::applyTransactions(std::vector<TransactionState>& transactions,
Dominik Laskowski08fbd852022-07-14 08:53:42 -07004595 VsyncId vsyncId) {
Dominik Laskowski16863742022-09-29 11:57:40 -04004596 Mutex::Autolock lock(mStateLock);
Vishnu Nair42ad3192023-01-24 19:17:59 -08004597 return applyTransactionsLocked(transactions, vsyncId);
4598}
4599
4600bool SurfaceFlinger::applyTransactionsLocked(std::vector<TransactionState>& transactions,
4601 VsyncId vsyncId) {
ramindani4d48f902021-09-20 21:07:45 +00004602 bool needsTraversal = false;
4603 // Now apply all transactions.
Robert Carrff7663b2022-02-08 12:46:49 -08004604 for (auto& transaction : transactions) {
ramindani4d48f902021-09-20 21:07:45 +00004605 needsTraversal |=
4606 applyTransactionState(transaction.frameTimelineInfo, transaction.states,
4607 transaction.displays, transaction.flags,
4608 transaction.inputWindowCommands,
4609 transaction.desiredPresentTime, transaction.isAutoTimestamp,
Patrick Williams6c6dd3b2023-02-13 22:53:06 +00004610 std::move(transaction.uncacheBufferIds), transaction.postTime,
Chavi Weingartenc78f53c2023-04-14 18:50:53 +00004611 transaction.hasListenerCallbacks,
ramindani4d48f902021-09-20 21:07:45 +00004612 transaction.listenerCallbacks, transaction.originPid,
4613 transaction.originUid, transaction.id);
ramindani4d48f902021-09-20 21:07:45 +00004614 }
Vishnu Naircd52e2d2021-10-18 08:42:46 -07004615 return needsTraversal;
Marissa Walle6e3c0d2019-03-29 10:28:30 -07004616}
4617
4618bool SurfaceFlinger::transactionFlushNeeded() {
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004619 return mTransactionHandler.hasPendingTransactions();
Marissa Wall713b63f2018-10-17 15:42:43 -07004620}
4621
Dominik Laskowski08fbd852022-07-14 08:53:42 -07004622bool SurfaceFlinger::frameIsEarly(TimePoint expectedPresentTime, VsyncId vsyncId) const {
4623 const auto prediction =
Dominik Laskowski16a345b2023-04-27 17:07:33 -04004624 mFrameTimeline->getTokenManager()->getPredictionsForToken(ftl::to_underlying(vsyncId));
Dominik Laskowski08fbd852022-07-14 08:53:42 -07004625 if (!prediction) {
Ady Abraham8db10102021-03-15 17:19:23 -07004626 return false;
4627 }
4628
Dominik Laskowski08fbd852022-07-14 08:53:42 -07004629 const auto predictedPresentTime = TimePoint::fromNs(prediction->presentTime);
4630
Rachel Lee0655a912023-04-20 19:54:18 -07004631 if (std::chrono::abs(predictedPresentTime - expectedPresentTime) >=
4632 scheduler::VsyncConfig::kEarlyLatchMaxThreshold) {
Ady Abraham8db10102021-03-15 17:19:23 -07004633 return false;
4634 }
4635
Leon Scroggins III67388622023-02-06 20:36:20 -05004636 const Duration earlyLatchVsyncThreshold = mScheduler->getVsyncSchedule()->period() / 2;
Dominik Laskowski08fbd852022-07-14 08:53:42 -07004637
4638 return predictedPresentTime >= expectedPresentTime &&
4639 predictedPresentTime - expectedPresentTime >= earlyLatchVsyncThreshold;
Ady Abraham8db10102021-03-15 17:19:23 -07004640}
Dominik Laskowski08fbd852022-07-14 08:53:42 -07004641
Vishnu Nair4d9cef92023-06-24 22:34:41 +00004642bool SurfaceFlinger::shouldLatchUnsignaled(const layer_state_t& state, size_t numStates,
4643 bool firstTransaction) const {
Ady Abraham9dada822022-02-03 10:26:59 -08004644 if (enableLatchUnsignaledConfig == LatchUnsignaledConfig::Disabled) {
Ady Abraham005398b2023-06-05 13:59:41 -07004645 ATRACE_FORMAT_INSTANT("%s: false (LatchUnsignaledConfig::Disabled)", __func__);
Ady Abraham9dada822022-02-03 10:26:59 -08004646 return false;
4647 }
Ady Abraham8db10102021-03-15 17:19:23 -07004648
Ady Abraham9dada822022-02-03 10:26:59 -08004649 // We only want to latch unsignaled when a single layer is updated in this
4650 // transaction (i.e. not a blast sync transaction).
4651 if (numStates != 1) {
Ady Abraham005398b2023-06-05 13:59:41 -07004652 ATRACE_FORMAT_INSTANT("%s: false (numStates=%zu)", __func__, numStates);
Ady Abraham9dada822022-02-03 10:26:59 -08004653 return false;
4654 }
4655
Ady Abraham2739e832022-02-14 17:42:00 -08004656 if (enableLatchUnsignaledConfig == LatchUnsignaledConfig::AutoSingleLayer) {
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004657 if (!firstTransaction) {
Ady Abraham005398b2023-06-05 13:59:41 -07004658 ATRACE_FORMAT_INSTANT("%s: false (LatchUnsignaledConfig::AutoSingleLayer; not first "
4659 "transaction)",
4660 __func__);
Ady Abraham2739e832022-02-14 17:42:00 -08004661 return false;
4662 }
4663
4664 // We don't want to latch unsignaled if are in early / client composition
4665 // as it leads to jank due to RenderEngine waiting for unsignaled buffer
4666 // or window animations being slow.
Dominik Laskowski14956dc2023-02-22 13:43:57 -05004667 if (mScheduler->vsyncModulator().isVsyncConfigEarly()) {
Ady Abraham005398b2023-06-05 13:59:41 -07004668 ATRACE_FORMAT_INSTANT("%s: false (LatchUnsignaledConfig::AutoSingleLayer; "
4669 "isVsyncConfigEarly)",
4670 __func__);
Ady Abraham2739e832022-02-14 17:42:00 -08004671 return false;
4672 }
Ady Abraham9dada822022-02-03 10:26:59 -08004673 }
4674
Vishnu Nair4d9cef92023-06-24 22:34:41 +00004675 return true;
Ady Abraham9dada822022-02-03 10:26:59 -08004676}
4677
chaviw308ddba2020-08-11 16:23:51 -07004678status_t SurfaceFlinger::setTransactionState(
Vishnu Nair40fff5c2022-11-04 02:46:28 +00004679 const FrameTimelineInfo& frameTimelineInfo, Vector<ComposerState>& states,
Ady Abraham22c7b5c2020-09-22 19:33:40 -07004680 const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
Chavi Weingartenc78f53c2023-04-14 18:50:53 +00004681 InputWindowCommands inputWindowCommands, int64_t desiredPresentTime, bool isAutoTimestamp,
4682 const std::vector<client_cache_t>& uncacheBuffers, bool hasListenerCallbacks,
Pablo Gamito23780be2023-04-18 08:30:00 +00004683 const std::vector<ListenerCallbacks>& listenerCallbacks, uint64_t transactionId,
4684 const std::vector<uint64_t>& mergedTransactionIds) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07004685 ATRACE_CALL();
Robert Carr14167e02019-02-13 13:50:55 -08004686
Chavi Weingartenc78f53c2023-04-14 18:50:53 +00004687 IPCThreadState* ipc = IPCThreadState::self();
4688 const int originPid = ipc->getCallingPid();
4689 const int originUid = ipc->getCallingUid();
4690 uint32_t permissions = LayerStatePermissions::getTransactionPermissions(originPid, originUid);
4691 for (auto composerState : states) {
4692 composerState.state.sanitize(permissions);
Vishnu Nair24e3bba2021-02-23 14:19:36 -08004693 }
4694
Chavi Weingartenc78f53c2023-04-14 18:50:53 +00004695 for (DisplayState display : displays) {
4696 display.sanitize(permissions);
4697 }
4698
4699 if (!inputWindowCommands.empty() &&
4700 (permissions & layer_state_t::Permission::ACCESS_SURFACE_FLINGER) == 0) {
4701 ALOGE("Only privileged callers are allowed to send input commands.");
4702 inputWindowCommands.clear();
Leon Scroggins9a20f722021-12-28 14:43:12 +00004703 }
4704
Vishnu Nair884549f2022-12-01 17:20:59 -08004705 if (flags & (eEarlyWakeupStart | eEarlyWakeupEnd)) {
4706 const bool hasPermission =
4707 (permissions & layer_state_t::Permission::ACCESS_SURFACE_FLINGER) ||
4708 callingThreadHasPermission(sWakeupSurfaceFlinger);
4709 if (!hasPermission) {
4710 ALOGE("Caller needs permission android.permission.WAKEUP_SURFACE_FLINGER to use "
4711 "eEarlyWakeup[Start|End] flags");
4712 flags &= ~(eEarlyWakeupStart | eEarlyWakeupEnd);
4713 }
arthurhungf1b7c7b2021-03-03 17:42:23 +08004714 }
4715
Vishnu Nair24e3bba2021-02-23 14:19:36 -08004716 const int64_t postTime = systemTime();
4717
Patrick Williams6c6dd3b2023-02-13 22:53:06 +00004718 std::vector<uint64_t> uncacheBufferIds;
4719 uncacheBufferIds.reserve(uncacheBuffers.size());
4720 for (const auto& uncacheBuffer : uncacheBuffers) {
4721 sp<GraphicBuffer> buffer = ClientCache::getInstance().erase(uncacheBuffer);
4722 if (buffer != nullptr) {
4723 uncacheBufferIds.push_back(buffer->getId());
4724 }
4725 }
4726
Vishnu Nair40fff5c2022-11-04 02:46:28 +00004727 std::vector<ResolvedComposerState> resolvedStates;
4728 resolvedStates.reserve(states.size());
4729 for (auto& state : states) {
4730 resolvedStates.emplace_back(std::move(state));
4731 auto& resolvedState = resolvedStates.back();
4732 if (resolvedState.state.hasBufferChanges() && resolvedState.state.hasValidBuffer() &&
4733 resolvedState.state.surface) {
Vishnu Nairc6086dd2022-11-04 04:39:35 +00004734 sp<Layer> layer = LayerHandle::getLayer(resolvedState.state.surface);
4735 std::string layerName = (layer) ?
4736 layer->getDebugName() : std::to_string(resolvedState.state.layerId);
Vishnu Nair40fff5c2022-11-04 02:46:28 +00004737 resolvedState.externalTexture =
4738 getExternalTextureFromBufferData(*resolvedState.state.bufferData,
Vishnu Nairc6086dd2022-11-04 04:39:35 +00004739 layerName.c_str(), transactionId);
Vishnu Nair40fff5c2022-11-04 02:46:28 +00004740 mBufferCountTracker.increment(resolvedState.state.surface->localBinder());
4741 }
Vishnu Nair1391de22023-03-05 19:56:14 -08004742 resolvedState.layerId = LayerHandle::getLayerId(resolvedState.state.surface);
4743 if (resolvedState.state.what & layer_state_t::eReparent) {
4744 resolvedState.parentId =
4745 getLayerIdFromSurfaceControl(resolvedState.state.parentSurfaceControlForChild);
4746 }
4747 if (resolvedState.state.what & layer_state_t::eRelativeLayerChanged) {
4748 resolvedState.relativeParentId =
4749 getLayerIdFromSurfaceControl(resolvedState.state.relativeLayerSurfaceControl);
4750 }
4751 if (resolvedState.state.what & layer_state_t::eInputInfoChanged) {
4752 wp<IBinder>& touchableRegionCropHandle =
4753 resolvedState.state.windowInfoHandle->editInfo()->touchableRegionCropHandle;
4754 resolvedState.touchCropId =
4755 LayerHandle::getLayerId(touchableRegionCropHandle.promote());
4756 }
Vishnu Nair40fff5c2022-11-04 02:46:28 +00004757 }
4758
Patrick Williams6c6dd3b2023-02-13 22:53:06 +00004759 TransactionState state{frameTimelineInfo,
4760 resolvedStates,
4761 displays,
4762 flags,
4763 applyToken,
Chavi Weingartenc78f53c2023-04-14 18:50:53 +00004764 std::move(inputWindowCommands),
Patrick Williams6c6dd3b2023-02-13 22:53:06 +00004765 desiredPresentTime,
4766 isAutoTimestamp,
4767 std::move(uncacheBufferIds),
4768 postTime,
Patrick Williams6c6dd3b2023-02-13 22:53:06 +00004769 hasListenerCallbacks,
4770 listenerCallbacks,
4771 originPid,
4772 originUid,
Pablo Gamito23780be2023-04-18 08:30:00 +00004773 transactionId,
4774 mergedTransactionIds};
Vishnu Nair83df0342021-03-30 11:50:44 -07004775
Dominik Laskowski46471e62022-01-14 15:34:03 -08004776 if (mTransactionTracing) {
4777 mTransactionTracing->addQueuedTransaction(state);
Vishnu Nair7891e962021-11-11 12:07:21 -08004778 }
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004779
4780 const auto schedule = [](uint32_t flags) {
4781 if (flags & eEarlyWakeupEnd) return TransactionSchedule::EarlyEnd;
4782 if (flags & eEarlyWakeupStart) return TransactionSchedule::EarlyStart;
4783 return TransactionSchedule::Late;
4784 }(state.flags);
4785
4786 const auto frameHint = state.isFrameActive() ? FrameHint::kActive : FrameHint::kNone;
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07004787 mTransactionHandler.queueTransaction(std::move(state));
Vishnu Naire4f00c52023-01-31 20:20:18 -08004788 setTransactionFlags(eTransactionFlushNeeded, schedule, applyToken, frameHint);
Zhuoyao Zhang3d3540d2021-01-14 05:14:54 +00004789 return NO_ERROR;
4790}
Marissa Wall713b63f2018-10-17 15:42:43 -07004791
Vishnu Naircd52e2d2021-10-18 08:42:46 -07004792bool SurfaceFlinger::applyTransactionState(const FrameTimelineInfo& frameTimelineInfo,
Vishnu Nair40fff5c2022-11-04 02:46:28 +00004793 std::vector<ResolvedComposerState>& states,
Sally Qi6bb12822022-10-05 11:42:30 -07004794 Vector<DisplayState>& displays, uint32_t flags,
Arthur Hung58144272021-01-16 03:43:53 +00004795 const InputWindowCommands& inputWindowCommands,
4796 const int64_t desiredPresentTime, bool isAutoTimestamp,
Patrick Williams6c6dd3b2023-02-13 22:53:06 +00004797 const std::vector<uint64_t>& uncacheBufferIds,
Chavi Weingartenc78f53c2023-04-14 18:50:53 +00004798 const int64_t postTime, bool hasListenerCallbacks,
Arthur Hung58144272021-01-16 03:43:53 +00004799 const std::vector<ListenerCallbacks>& listenerCallbacks,
4800 int originPid, int originUid, uint64_t transactionId) {
Zhuoyao Zhang3d3540d2021-01-14 05:14:54 +00004801 uint32_t transactionFlags = 0;
Lloyd Pique30db6402023-06-26 18:56:51 +00004802 if (!mLayerLifecycleManagerEnabled) {
Vishnu Nair3af0ec02023-02-10 04:13:48 +00004803 for (DisplayState& display : displays) {
Vishnu Nair3af0ec02023-02-10 04:13:48 +00004804 transactionFlags |= setDisplayStateLocked(display);
4805 }
Jamie Gennisb8d69a52011-10-10 15:48:06 -07004806 }
4807
Jiakai Zhanga5505cb2021-11-09 11:46:30 +00004808 // start and end registration for listeners w/ no surface so they can get their callback. Note
4809 // that listeners with SurfaceControls will start registration during setClientStateLocked
4810 // below.
Valerie Hau9dab9732019-08-20 09:29:25 -07004811 for (const auto& listener : listenerCallbacks) {
Jiakai Zhanga5505cb2021-11-09 11:46:30 +00004812 mTransactionCallbackInvoker.addEmptyTransaction(listener);
Marissa Walld600d572019-03-26 15:38:50 -07004813 }
4814
Marissa Walle2ffb422018-10-12 11:33:52 -07004815 uint32_t clientStateFlags = 0;
Vishnu Nair40fff5c2022-11-04 02:46:28 +00004816 for (auto& resolvedState : states) {
Lloyd Pique30db6402023-06-26 18:56:51 +00004817 if (mLegacyFrontEndEnabled) {
Vishnu Nair3af0ec02023-02-10 04:13:48 +00004818 clientStateFlags |=
4819 setClientStateLocked(frameTimelineInfo, resolvedState, desiredPresentTime,
Chavi Weingartenc78f53c2023-04-14 18:50:53 +00004820 isAutoTimestamp, postTime, transactionId);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00004821
Lloyd Pique30db6402023-06-26 18:56:51 +00004822 } else /*mLayerLifecycleManagerEnabled*/ {
Vishnu Nair3af0ec02023-02-10 04:13:48 +00004823 clientStateFlags |= updateLayerCallbacksAndStats(frameTimelineInfo, resolvedState,
4824 desiredPresentTime, isAutoTimestamp,
Chavi Weingartenc78f53c2023-04-14 18:50:53 +00004825 postTime, transactionId);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00004826 }
Vishnu Nair40fff5c2022-11-04 02:46:28 +00004827 if ((flags & eAnimation) && resolvedState.state.surface) {
4828 if (const auto layer = LayerHandle::getLayer(resolvedState.state.surface)) {
Vishnu Nairef68d6d2023-02-28 06:18:27 +00004829 const auto layerProps = scheduler::LayerProps{
4830 .visible = layer->isVisible(),
4831 .bounds = layer->getBounds(),
4832 .transform = layer->getTransform(),
4833 .setFrameRateVote = layer->getFrameRateForLayerTree(),
4834 .frameRateSelectionPriority = layer->getFrameRateSelectionPriority(),
4835 };
4836 layer->recordLayerHistoryAnimationTx(layerProps);
Ady Abraham5def7332020-05-29 16:13:47 -07004837 }
4838 }
Marissa Wall3dad52d2019-03-22 14:03:19 -07004839 }
4840
Marissa Walle2ffb422018-10-12 11:33:52 -07004841 transactionFlags |= clientStateFlags;
Chavi Weingartenc78f53c2023-04-14 18:50:53 +00004842 transactionFlags |= addInputWindowCommands(inputWindowCommands);
chaviw273171b2018-12-26 11:46:30 -08004843
Patrick Williams6c6dd3b2023-02-13 22:53:06 +00004844 for (uint64_t uncacheBufferId : uncacheBufferIds) {
4845 mBufferIdsToUncache.push_back(uncacheBufferId);
Marissa Wall78b72202019-03-15 14:58:34 -07004846 }
4847
Jorim Jaggibdcf09c2017-08-08 15:22:08 +02004848 // If a synchronous transaction is explicitly requested without any changes, force a transaction
4849 // anyway. This can be used as a flush mechanism for previous async transactions.
4850 // Empty animation transaction can be used to simulate back-pressure, so also force a
4851 // transaction for empty animation transactions.
Vishnu Nair1523dad2022-09-29 16:05:18 -07004852 if (transactionFlags == 0 && (flags & eAnimation)) {
Robert Carr2a7dbb42016-05-24 11:41:28 -07004853 transactionFlags = eTransactionNeeded;
4854 }
4855
Vishnu Naircd52e2d2021-10-18 08:42:46 -07004856 bool needsTraversal = false;
Mathias Agopian386aa982011-11-07 21:58:03 -08004857 if (transactionFlags) {
Vishnu Nair3af0ec02023-02-10 04:13:48 +00004858 // We are on the main thread, we are about to perform a traversal. Clear the traversal bit
4859 // so we don't have to wake up again next frame to perform an unnecessary traversal.
Arthur Hung58144272021-01-16 03:43:53 +00004860 if (transactionFlags & eTraversalNeeded) {
4861 transactionFlags = transactionFlags & (~eTraversalNeeded);
Vishnu Naircd52e2d2021-10-18 08:42:46 -07004862 needsTraversal = true;
Arthur Hung1bedccb2020-09-24 10:09:25 +00004863 }
Arthur Hung58144272021-01-16 03:43:53 +00004864 if (transactionFlags) {
4865 setTransactionFlags(transactionFlags);
Arthur Hung1bedccb2020-09-24 10:09:25 +00004866 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004867 }
Vishnu Naircd52e2d2021-10-18 08:42:46 -07004868
4869 return needsTraversal;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004870}
4871
Vishnu Nair3af0ec02023-02-10 04:13:48 +00004872bool SurfaceFlinger::applyAndCommitDisplayTransactionStates(
4873 std::vector<TransactionState>& transactions) {
Dominik Laskowski16863742022-09-29 11:57:40 -04004874 Mutex::Autolock lock(mStateLock);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00004875 bool needsTraversal = false;
4876 uint32_t transactionFlags = 0;
4877 for (auto& transaction : transactions) {
4878 for (DisplayState& display : transaction.displays) {
Vishnu Nair3af0ec02023-02-10 04:13:48 +00004879 transactionFlags |= setDisplayStateLocked(display);
4880 }
4881 }
4882
4883 if (transactionFlags) {
4884 // We are on the main thread, we are about to perform a traversal. Clear the traversal bit
4885 // so we don't have to wake up again next frame to perform an unnecessary traversal.
4886 if (transactionFlags & eTraversalNeeded) {
4887 transactionFlags = transactionFlags & (~eTraversalNeeded);
4888 needsTraversal = true;
4889 }
4890 if (transactionFlags) {
4891 setTransactionFlags(transactionFlags);
4892 }
4893 }
4894
4895 mFrontEndDisplayInfosChanged = mTransactionFlags & eDisplayTransactionNeeded;
Lloyd Pique30db6402023-06-26 18:56:51 +00004896 if (mFrontEndDisplayInfosChanged && !mLegacyFrontEndEnabled) {
Vishnu Nair3af0ec02023-02-10 04:13:48 +00004897 processDisplayChangesLocked();
4898 mFrontEndDisplayInfos.clear();
4899 for (const auto& [_, display] : mDisplays) {
4900 mFrontEndDisplayInfos.try_emplace(display->getLayerStack(), display->getFrontEndInfo());
4901 }
Vishnu Naird47bcee2023-02-24 18:08:51 +00004902 needsTraversal = true;
Vishnu Nair3af0ec02023-02-10 04:13:48 +00004903 }
4904
4905 return needsTraversal;
4906}
4907
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07004908uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s) {
4909 const ssize_t index = mCurrentState.displays.indexOfKey(s.token);
4910 if (index < 0) return 0;
Jesse Hall9a143922012-10-04 16:29:19 -07004911
Mathias Agopiane57f2922012-08-09 16:29:12 -07004912 uint32_t flags = 0;
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07004913 DisplayDeviceState& state = mCurrentState.displays.editValueAt(index);
4914
4915 const uint32_t what = s.what;
4916 if (what & DisplayState::eSurfaceChanged) {
4917 if (IInterface::asBinder(state.surface) != IInterface::asBinder(s.surface)) {
4918 state.surface = s.surface;
4919 flags |= eDisplayTransactionNeeded;
Michael Lentine47e45402014-07-18 15:34:25 -07004920 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07004921 }
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07004922 if (what & DisplayState::eLayerStackChanged) {
4923 if (state.layerStack != s.layerStack) {
4924 state.layerStack = s.layerStack;
4925 flags |= eDisplayTransactionNeeded;
4926 }
4927 }
Evan Rosky2239b372021-05-20 13:43:47 -07004928 if (what & DisplayState::eFlagsChanged) {
4929 if (state.flags != s.flags) {
4930 state.flags = s.flags;
4931 flags |= eDisplayTransactionNeeded;
4932 }
4933 }
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07004934 if (what & DisplayState::eDisplayProjectionChanged) {
4935 if (state.orientation != s.orientation) {
4936 state.orientation = s.orientation;
4937 flags |= eDisplayTransactionNeeded;
4938 }
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02004939 if (state.orientedDisplaySpaceRect != s.orientedDisplaySpaceRect) {
4940 state.orientedDisplaySpaceRect = s.orientedDisplaySpaceRect;
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07004941 flags |= eDisplayTransactionNeeded;
4942 }
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02004943 if (state.layerStackSpaceRect != s.layerStackSpaceRect) {
4944 state.layerStackSpaceRect = s.layerStackSpaceRect;
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07004945 flags |= eDisplayTransactionNeeded;
4946 }
4947 }
4948 if (what & DisplayState::eDisplaySizeChanged) {
4949 if (state.width != s.width) {
4950 state.width = s.width;
4951 flags |= eDisplayTransactionNeeded;
4952 }
4953 if (state.height != s.height) {
4954 state.height = s.height;
4955 flags |= eDisplayTransactionNeeded;
4956 }
4957 }
4958
Mathias Agopiane57f2922012-08-09 16:29:12 -07004959 return flags;
4960}
4961
Steven Thomasd4071902020-03-24 16:02:53 -07004962bool SurfaceFlinger::callingThreadHasUnscopedSurfaceFlingerAccess(bool usePermissionCache) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07004963 IPCThreadState* ipc = IPCThreadState::self();
4964 const int pid = ipc->getCallingPid();
4965 const int uid = ipc->getCallingUid();
Robert Carrd4ae7f32018-06-07 16:10:57 -07004966 if ((uid != AID_GRAPHICS && uid != AID_SYSTEM) &&
Steven Thomasd4071902020-03-24 16:02:53 -07004967 (usePermissionCache ? !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)
4968 : !checkPermission(sAccessSurfaceFlinger, pid, uid))) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07004969 return false;
4970 }
4971 return true;
4972}
4973
Vishnu Naircd52e2d2021-10-18 08:42:46 -07004974uint32_t SurfaceFlinger::setClientStateLocked(const FrameTimelineInfo& frameTimelineInfo,
Vishnu Nair40fff5c2022-11-04 02:46:28 +00004975 ResolvedComposerState& composerState,
Vishnu Naircd52e2d2021-10-18 08:42:46 -07004976 int64_t desiredPresentTime, bool isAutoTimestamp,
Chavi Weingartenc78f53c2023-04-14 18:50:53 +00004977 int64_t postTime, uint64_t transactionId) {
Robert Carrde6d7b42022-01-07 18:23:06 -08004978 layer_state_t& s = composerState.state;
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07004979
4980 std::vector<ListenerCallbacks> filteredListeners;
Valerie Hau9dab9732019-08-20 09:29:25 -07004981 for (auto& listener : s.listeners) {
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07004982 // Starts a registration but separates the callback ids according to callback type. This
4983 // allows the callback invoker to send on latch callbacks earlier.
Valerie Hau9dab9732019-08-20 09:29:25 -07004984 // note that startRegistration will not re-register if the listener has
4985 // already be registered for a prior surface control
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07004986
4987 ListenerCallbacks onCommitCallbacks = listener.filter(CallbackId::Type::ON_COMMIT);
4988 if (!onCommitCallbacks.callbackIds.empty()) {
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07004989 filteredListeners.push_back(onCommitCallbacks);
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07004990 }
4991
4992 ListenerCallbacks onCompleteCallbacks = listener.filter(CallbackId::Type::ON_COMPLETE);
4993 if (!onCompleteCallbacks.callbackIds.empty()) {
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07004994 filteredListeners.push_back(onCompleteCallbacks);
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07004995 }
Valerie Hau9dab9732019-08-20 09:29:25 -07004996 }
4997
arthurhungdba591c2021-02-08 17:28:49 +08004998 const uint64_t what = s.what;
4999 uint32_t flags = 0;
Vishnu Nairdc6f5b92019-12-03 07:33:37 -08005000 sp<Layer> layer = nullptr;
5001 if (s.surface) {
Vishnu Nair07e2a482022-10-18 19:18:16 +00005002 layer = LayerHandle::getLayer(s.surface);
Vishnu Nairdc6f5b92019-12-03 07:33:37 -08005003 } else {
5004 // The client may provide us a null handle. Treat it as if the layer was removed.
5005 ALOGW("Attempt to set client state with a null layer handle");
5006 }
chaviw8b3871a2017-11-01 17:41:01 -07005007 if (layer == nullptr) {
Valerie Hau9dab9732019-08-20 09:29:25 -07005008 for (auto& [listener, callbackIds] : s.listeners) {
Pascal Muetschard81cef292023-02-06 12:18:52 +01005009 mTransactionCallbackInvoker.addCallbackHandle(sp<CallbackHandle>::make(listener,
5010 callbackIds,
5011 s.surface),
5012 std::vector<JankData>());
Marissa Wall88e20482019-06-24 10:49:42 -07005013 }
chaviw8b3871a2017-11-01 17:41:01 -07005014 return 0;
5015 }
Josh Gao194ff392022-09-08 16:19:29 -07005016 MUTEX_ALIAS(mStateLock, layer->mFlinger->mStateLock);
chaviw8b3871a2017-11-01 17:41:01 -07005017
Vishnu Nair73908d12022-10-24 21:46:42 -07005018 ui::LayerStack oldLayerStack = layer->getLayerStack(LayerVector::StateSet::Current);
Vishnu Nairafd527a2022-10-18 08:56:10 -07005019
Valerie Hau871d6352020-01-29 08:44:02 -08005020 // Only set by BLAST adapter layers
5021 if (what & layer_state_t::eProducerDisconnect) {
5022 layer->onDisconnect();
5023 }
5024
chaviw8b3871a2017-11-01 17:41:01 -07005025 if (what & layer_state_t::ePositionChanged) {
chaviw214c89d2019-09-04 16:03:53 -07005026 if (layer->setPosition(s.x, s.y)) {
chaviw8b3871a2017-11-01 17:41:01 -07005027 flags |= eTraversalNeeded;
Mathias Agopiane57f2922012-08-09 16:29:12 -07005028 }
chaviw8b3871a2017-11-01 17:41:01 -07005029 }
5030 if (what & layer_state_t::eLayerChanged) {
5031 // NOTE: index needs to be calculated before we update the state
Rob Carrc6d2d2b2021-10-25 16:51:49 +00005032 const auto& p = layer->getParent();
chaviw8b3871a2017-11-01 17:41:01 -07005033 if (p == nullptr) {
chaviw64f7b422017-07-12 10:31:58 -07005034 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
chaviw8b3871a2017-11-01 17:41:01 -07005035 if (layer->setLayer(s.z) && idx >= 0) {
Mathias Agopiane57f2922012-08-09 16:29:12 -07005036 mCurrentState.layersSortedByZ.removeAt(idx);
5037 mCurrentState.layersSortedByZ.add(layer);
5038 // we need traversal (state changed)
5039 // AND transaction (list changed)
5040 flags |= eTransactionNeeded|eTraversalNeeded;
5041 }
chaviw8b3871a2017-11-01 17:41:01 -07005042 } else {
5043 if (p->setChildLayer(layer, s.z)) {
chaviw06178942017-07-27 10:25:59 -07005044 flags |= eTransactionNeeded|eTraversalNeeded;
5045 }
5046 }
chaviw8b3871a2017-11-01 17:41:01 -07005047 }
5048 if (what & layer_state_t::eRelativeLayerChanged) {
Robert Carr503c7042017-09-27 15:06:08 -07005049 // NOTE: index needs to be calculated before we update the state
Rob Carrc6d2d2b2021-10-25 16:51:49 +00005050 const auto& p = layer->getParent();
Robert Carrbc384962021-01-27 15:44:50 -08005051 const auto& relativeHandle = s.relativeLayerSurfaceControl ?
5052 s.relativeLayerSurfaceControl->getHandle() : nullptr;
Robert Carr503c7042017-09-27 15:06:08 -07005053 if (p == nullptr) {
5054 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
Robert Carrbc384962021-01-27 15:44:50 -08005055 if (layer->setRelativeLayer(relativeHandle, s.z) &&
Pablo Gamito11dcc222020-09-12 15:49:39 +00005056 idx >= 0) {
Robert Carr503c7042017-09-27 15:06:08 -07005057 mCurrentState.layersSortedByZ.removeAt(idx);
5058 mCurrentState.layersSortedByZ.add(layer);
5059 // we need traversal (state changed)
5060 // AND transaction (list changed)
5061 flags |= eTransactionNeeded|eTraversalNeeded;
5062 }
5063 } else {
Robert Carrbc384962021-01-27 15:44:50 -08005064 if (p->setChildRelativeLayer(layer, relativeHandle, s.z)) {
Robert Carr503c7042017-09-27 15:06:08 -07005065 flags |= eTransactionNeeded|eTraversalNeeded;
5066 }
chaviw8b3871a2017-11-01 17:41:01 -07005067 }
5068 }
chaviw8b3871a2017-11-01 17:41:01 -07005069 if (what & layer_state_t::eAlphaChanged) {
Vishnu Nairbbceb462022-10-10 04:52:13 +00005070 if (layer->setAlpha(s.color.a)) flags |= eTraversalNeeded;
chaviw8b3871a2017-11-01 17:41:01 -07005071 }
5072 if (what & layer_state_t::eColorChanged) {
Vishnu Nairbbceb462022-10-10 04:52:13 +00005073 if (layer->setColor(s.color.rgb)) flags |= eTraversalNeeded;
chaviw8b3871a2017-11-01 17:41:01 -07005074 }
Peiyong Lind3788632018-09-18 16:01:31 -07005075 if (what & layer_state_t::eColorTransformChanged) {
5076 if (layer->setColorTransform(s.colorTransform)) {
5077 flags |= eTraversalNeeded;
5078 }
5079 }
Valerie Haudd0b7572019-01-29 14:59:27 -08005080 if (what & layer_state_t::eBackgroundColorChanged) {
Vishnu Naird47bcee2023-02-24 18:08:51 +00005081 if (layer->setBackgroundColor(s.bgColor.rgb, s.bgColor.a, s.bgColorDataspace)) {
Valerie Haudd0b7572019-01-29 14:59:27 -08005082 flags |= eTraversalNeeded;
5083 }
5084 }
chaviw8b3871a2017-11-01 17:41:01 -07005085 if (what & layer_state_t::eMatrixChanged) {
Robert Carrde6d7b42022-01-07 18:23:06 -08005086 if (layer->setMatrix(s.matrix)) flags |= eTraversalNeeded;
chaviw8b3871a2017-11-01 17:41:01 -07005087 }
5088 if (what & layer_state_t::eTransparentRegionChanged) {
5089 if (layer->setTransparentRegionHint(s.transparentRegion))
5090 flags |= eTraversalNeeded;
5091 }
5092 if (what & layer_state_t::eFlagsChanged) {
Robert Carrde6d7b42022-01-07 18:23:06 -08005093 if (layer->setFlags(s.flags, s.mask)) flags |= eTraversalNeeded;
chaviw8b3871a2017-11-01 17:41:01 -07005094 }
Lucas Dupin1b6531c2018-07-05 17:18:21 -07005095 if (what & layer_state_t::eCornerRadiusChanged) {
5096 if (layer->setCornerRadius(s.cornerRadius))
5097 flags |= eTraversalNeeded;
5098 }
Lloyd Pique30db6402023-06-26 18:56:51 +00005099 if (what & layer_state_t::eBackgroundBlurRadiusChanged && mSupportsBlur) {
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08005100 if (layer->setBackgroundBlurRadius(s.backgroundBlurRadius)) flags |= eTraversalNeeded;
5101 }
Galia Peychevae11d5752021-01-22 13:50:16 +00005102 if (what & layer_state_t::eBlurRegionsChanged) {
Lucas Dupinc3800b82020-10-02 16:24:48 -07005103 if (layer->setBlurRegions(s.blurRegions)) flags |= eTraversalNeeded;
5104 }
Tianhao Yao67dd7122022-02-22 17:48:33 +00005105 if (what & layer_state_t::eRenderBorderChanged) {
Tianhao Yao10cea3c2022-03-30 01:37:22 +00005106 if (layer->enableBorder(s.borderEnabled, s.borderWidth, s.borderColor)) {
Tianhao Yao67dd7122022-02-22 17:48:33 +00005107 flags |= eTraversalNeeded;
5108 }
5109 }
chaviw8b3871a2017-11-01 17:41:01 -07005110 if (what & layer_state_t::eLayerStackChanged) {
5111 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
5112 // We only allow setting layer stacks for top level layers,
5113 // everything else inherits layer stack from its parent.
5114 if (layer->hasParent()) {
5115 ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
Dominik Laskowski87a07e42019-10-10 20:38:02 -07005116 layer->getDebugName());
chaviw8b3871a2017-11-01 17:41:01 -07005117 } else if (idx < 0) {
5118 ALOGE("Attempt to set layer stack on layer without parent (%s) that "
Dominik Laskowski87a07e42019-10-10 20:38:02 -07005119 "that also does not appear in the top level layer list. Something"
5120 " has gone wrong.",
5121 layer->getDebugName());
chaviw8b3871a2017-11-01 17:41:01 -07005122 } else if (layer->setLayerStack(s.layerStack)) {
5123 mCurrentState.layersSortedByZ.removeAt(idx);
5124 mCurrentState.layersSortedByZ.add(layer);
5125 // we need traversal (state changed)
5126 // AND transaction (list changed)
Vishnu Nair6213bd92020-05-08 17:42:25 -07005127 flags |= eTransactionNeeded | eTraversalNeeded | eTransformHintUpdateNeeded;
chaviw8b3871a2017-11-01 17:41:01 -07005128 }
5129 }
Vishnu Nairbbceb462022-10-10 04:52:13 +00005130 if (what & layer_state_t::eBufferTransformChanged) {
5131 if (layer->setTransform(s.bufferTransform)) flags |= eTraversalNeeded;
Marissa Wall61c58622018-07-18 10:12:20 -07005132 }
5133 if (what & layer_state_t::eTransformToDisplayInverseChanged) {
5134 if (layer->setTransformToDisplayInverse(s.transformToDisplayInverse))
5135 flags |= eTraversalNeeded;
5136 }
5137 if (what & layer_state_t::eCropChanged) {
5138 if (layer->setCrop(s.crop)) flags |= eTraversalNeeded;
5139 }
Marissa Wall61c58622018-07-18 10:12:20 -07005140 if (what & layer_state_t::eDataspaceChanged) {
5141 if (layer->setDataspace(s.dataspace)) flags |= eTraversalNeeded;
5142 }
Marissa Wall61c58622018-07-18 10:12:20 -07005143 if (what & layer_state_t::eSurfaceDamageRegionChanged) {
5144 if (layer->setSurfaceDamageRegion(s.surfaceDamageRegion)) flags |= eTraversalNeeded;
5145 }
5146 if (what & layer_state_t::eApiChanged) {
5147 if (layer->setApi(s.api)) flags |= eTraversalNeeded;
5148 }
5149 if (what & layer_state_t::eSidebandStreamChanged) {
5150 if (layer->setSidebandStream(s.sidebandStream)) flags |= eTraversalNeeded;
5151 }
Robert Carr720e5062018-07-30 17:45:14 -07005152 if (what & layer_state_t::eInputInfoChanged) {
Robert Carrde6d7b42022-01-07 18:23:06 -08005153 layer->setInputInfo(*s.windowInfoHandle->getInfo());
5154 flags |= eTraversalNeeded;
Robert Carr720e5062018-07-30 17:45:14 -07005155 }
Vishnu Nairadf632b2021-01-07 14:05:08 -08005156 std::optional<nsecs_t> dequeueBufferTimestamp;
Evan Rosky1f6d6d52018-12-06 10:47:26 -08005157 if (what & layer_state_t::eMetadataChanged) {
Huihong Luod3d8f8e2022-03-08 14:48:46 -08005158 dequeueBufferTimestamp = s.metadata.getInt64(gui::METADATA_DEQUEUE_TIME);
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -07005159
Huihong Luod3d8f8e2022-03-08 14:48:46 -08005160 if (const int32_t gameMode = s.metadata.getInt32(gui::METADATA_GAME_MODE, -1);
5161 gameMode != -1) {
Adithya Srinivasanac977e62021-05-21 22:50:56 +00005162 // The transaction will be received on the Task layer and needs to be applied to all
5163 // child layers. Child layers that are added at a later point will obtain the game mode
5164 // info through addChild().
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -07005165 layer->setGameModeForTree(static_cast<GameMode>(gameMode));
Adithya Srinivasanac977e62021-05-21 22:50:56 +00005166 }
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -07005167
Vishnu Nair0a4fb002022-08-08 02:40:42 +00005168 if (layer->setMetadata(s.metadata)) {
5169 flags |= eTraversalNeeded;
5170 mLayerMetadataSnapshotNeeded = true;
5171 }
Evan Rosky1f6d6d52018-12-06 10:47:26 -08005172 }
Peiyong Linc502cb72019-03-01 15:00:23 -08005173 if (what & layer_state_t::eColorSpaceAgnosticChanged) {
5174 if (layer->setColorSpaceAgnostic(s.colorSpaceAgnostic)) {
5175 flags |= eTraversalNeeded;
5176 }
5177 }
Vishnu Nairc97b8db2019-10-29 18:19:35 -07005178 if (what & layer_state_t::eShadowRadiusChanged) {
5179 if (layer->setShadowRadius(s.shadowRadius)) flags |= eTraversalNeeded;
5180 }
Andy Labrada096227e2022-06-15 16:58:11 +00005181 if (what & layer_state_t::eDefaultFrameRateCompatibilityChanged) {
5182 const auto compatibility =
5183 Layer::FrameRate::convertCompatibility(s.defaultFrameRateCompatibility);
5184
5185 if (layer->setDefaultFrameRateCompatibility(compatibility)) {
5186 flags |= eTraversalNeeded;
5187 }
5188 }
Ana Krulecc84d09b2019-11-02 23:10:29 +01005189 if (what & layer_state_t::eFrameRateSelectionPriority) {
Robert Carrde6d7b42022-01-07 18:23:06 -08005190 if (layer->setFrameRateSelectionPriority(s.frameRateSelectionPriority)) {
Ana Krulecc84d09b2019-11-02 23:10:29 +01005191 flags |= eTraversalNeeded;
5192 }
5193 }
Steven Thomas3172e202020-01-06 19:25:30 -08005194 if (what & layer_state_t::eFrameRateChanged) {
Robert Carrde6d7b42022-01-07 18:23:06 -08005195 const auto compatibility =
5196 Layer::FrameRate::convertCompatibility(s.frameRateCompatibility);
5197 const auto strategy =
5198 Layer::FrameRate::convertChangeFrameRateStrategy(s.changeFrameRateStrategy);
Marin Shalamanovc5986772021-03-16 16:09:49 +01005199
Robert Carrde6d7b42022-01-07 18:23:06 -08005200 if (layer->setFrameRate(
5201 Layer::FrameRate(Fps::fromValue(s.frameRate), compatibility, strategy))) {
5202 flags |= eTraversalNeeded;
Steven Thomas62a4cf82020-01-31 12:04:03 -08005203 }
Steven Thomas3172e202020-01-06 19:25:30 -08005204 }
Vishnu Nair6213bd92020-05-08 17:42:25 -07005205 if (what & layer_state_t::eFixedTransformHintChanged) {
5206 if (layer->setFixedTransformHint(s.fixedTransformHint)) {
5207 flags |= eTraversalNeeded | eTransformHintUpdateNeeded;
5208 }
5209 }
Vishnu Naircf26a0a2020-11-13 12:56:20 -08005210 if (what & layer_state_t::eAutoRefreshChanged) {
5211 layer->setAutoRefresh(s.autoRefresh);
5212 }
Sally Qi421ffb02022-03-21 19:41:33 -07005213 if (what & layer_state_t::eDimmingEnabledChanged) {
5214 if (layer->setDimmingEnabled(s.dimmingEnabled)) flags |= eTraversalNeeded;
5215 }
John Reck68796592023-01-25 13:47:12 -05005216 if (what & layer_state_t::eExtendedRangeBrightnessChanged) {
Sally Qi963049b2023-03-23 14:06:21 -07005217 if (layer->setExtendedRangeBrightness(s.currentHdrSdrRatio, s.desiredHdrSdrRatio)) {
John Reck68796592023-01-25 13:47:12 -05005218 flags |= eTraversalNeeded;
5219 }
5220 }
Alec Mourif4af03e2023-02-11 00:25:24 +00005221 if (what & layer_state_t::eCachingHintChanged) {
5222 if (layer->setCachingHint(s.cachingHint)) {
5223 flags |= eTraversalNeeded;
5224 }
5225 }
John Reck68796592023-01-25 13:47:12 -05005226 if (what & layer_state_t::eHdrMetadataChanged) {
5227 if (layer->setHdrMetadata(s.hdrMetadata)) flags |= eTraversalNeeded;
5228 }
Winson Chunga30f7c92021-06-29 15:42:56 -07005229 if (what & layer_state_t::eTrustedOverlayChanged) {
Robert Carrde6d7b42022-01-07 18:23:06 -08005230 if (layer->setTrustedOverlay(s.isTrustedOverlay)) {
5231 flags |= eTraversalNeeded;
Winson Chunga30f7c92021-06-29 15:42:56 -07005232 }
5233 }
John Reckcdb4ed72021-02-04 13:39:33 -05005234 if (what & layer_state_t::eStretchChanged) {
5235 if (layer->setStretchEffect(s.stretchEffect)) {
5236 flags |= eTraversalNeeded;
5237 }
5238 }
chaviwf3f40fe2021-04-27 15:54:02 -05005239 if (what & layer_state_t::eBufferCropChanged) {
5240 if (layer->setBufferCrop(s.bufferCrop)) {
5241 flags |= eTraversalNeeded;
5242 }
5243 }
Vishnu Nair6bdec7d2021-05-10 15:01:13 -07005244 if (what & layer_state_t::eDestinationFrameChanged) {
5245 if (layer->setDestinationFrame(s.destinationFrame)) {
5246 flags |= eTraversalNeeded;
5247 }
5248 }
Vishnu Nair9cf4a4d2021-09-17 12:16:08 -07005249 if (what & layer_state_t::eDropInputModeChanged) {
Robert Carrde6d7b42022-01-07 18:23:06 -08005250 if (layer->setDropInputMode(s.dropInputMode)) {
5251 flags |= eTraversalNeeded;
Arthur Hung9ed43392022-05-27 06:31:57 +00005252 mUpdateInputInfo = true;
Vishnu Nair9cf4a4d2021-09-17 12:16:08 -07005253 }
5254 }
Vishnu Nair14d76922019-08-05 08:41:20 -07005255 // This has to happen after we reparent children because when we reparent to null we remove
5256 // child layers from current state and remove its relative z. If the children are reparented in
5257 // the same transaction, then we have to make sure we reparent the children first so we do not
5258 // lose its relative z order.
5259 if (what & layer_state_t::eReparent) {
5260 bool hadParent = layer->hasParent();
Pablo Gamito11dcc222020-09-12 15:49:39 +00005261 auto parentHandle = (s.parentSurfaceControlForChild)
5262 ? s.parentSurfaceControlForChild->getHandle()
5263 : nullptr;
5264 if (layer->reparent(parentHandle)) {
Vishnu Nair14d76922019-08-05 08:41:20 -07005265 if (!hadParent) {
Vishnu Nair14d218b2021-07-13 13:57:39 -07005266 layer->setIsAtRoot(false);
Vishnu Nair14d76922019-08-05 08:41:20 -07005267 mCurrentState.layersSortedByZ.remove(layer);
5268 }
5269 flags |= eTransactionNeeded | eTraversalNeeded;
5270 }
5271 }
Jiakai Zhanga5505cb2021-11-09 11:46:30 +00005272 std::vector<sp<CallbackHandle>> callbackHandles;
5273 if ((what & layer_state_t::eHasListenerCallbacksChanged) && (!filteredListeners.empty())) {
5274 for (auto& [listener, callbackIds] : filteredListeners) {
Ady Abrahamd11bade2022-08-01 16:18:03 -07005275 callbackHandles.emplace_back(
5276 sp<CallbackHandle>::make(listener, callbackIds, s.surface));
Jiakai Zhanga5505cb2021-11-09 11:46:30 +00005277 }
5278 }
Vishnu Nair6b7c5c92020-09-29 17:27:05 -07005279
Vishnu Nairdbbe3852022-01-12 20:22:11 -08005280 if (what & layer_state_t::eBufferChanged) {
Vishnu Nair40fff5c2022-11-04 02:46:28 +00005281 if (layer->setBuffer(composerState.externalTexture, *s.bufferData, postTime,
5282 desiredPresentTime, isAutoTimestamp, dequeueBufferTimestamp,
Brian Lindahl439afad2022-11-14 11:16:55 -07005283 frameTimelineInfo)) {
Vishnu Nairdbbe3852022-01-12 20:22:11 -08005284 flags |= eTraversalNeeded;
5285 }
Ady Abraham8db10102021-03-15 17:19:23 -07005286 } else if (frameTimelineInfo.vsyncId != FrameTimelineInfo::INVALID_VSYNC_ID) {
5287 layer->setFrameTimelineVsyncForBufferlessTransaction(frameTimelineInfo, postTime);
Marissa Wallebc2c052019-01-16 19:16:55 -08005288 }
Ady Abraham22c7b5c2020-09-22 19:33:40 -07005289
Vishnu Nairef68d6d2023-02-28 06:18:27 +00005290 if ((what & layer_state_t::eBufferChanged) == 0) {
5291 layer->setDesiredPresentTime(desiredPresentTime, isAutoTimestamp);
5292 }
5293
Chavi Weingarten076acac2023-01-19 17:20:43 +00005294 if (what & layer_state_t::eTrustedPresentationInfoChanged) {
Chavi Weingarten328a8312023-01-26 21:17:52 +00005295 if (layer->setTrustedPresentationInfo(s.trustedPresentationThresholds,
5296 s.trustedPresentationListener)) {
5297 flags |= eTraversalNeeded;
5298 }
Chavi Weingarten076acac2023-01-19 17:20:43 +00005299 }
5300
Pascal Muetschardb39918f2023-01-27 11:36:11 +01005301 if (what & layer_state_t::eFlushJankData) {
5302 // Do nothing. Processing the transaction completed listeners currently cause the flush.
5303 }
5304
Vishnu Nair3af0ec02023-02-10 04:13:48 +00005305 if (layer->setTransactionCompletedListeners(callbackHandles,
Vishnu Nair7ee4f462023-04-19 09:54:09 -07005306 layer->willPresentCurrentTransaction() ||
5307 layer->willReleaseBufferOnLatch())) {
Vishnu Naird6913222023-02-01 22:56:21 +00005308 flags |= eTraversalNeeded;
5309 }
5310
Marissa Walle2ffb422018-10-12 11:33:52 -07005311 // Do not put anything that updates layer state or modifies flags after
5312 // setTransactionCompletedListener
Vishnu Nairafd527a2022-10-18 08:56:10 -07005313
5314 // if the layer has been parented on to a new display, update its transform hint.
Vishnu Nair73908d12022-10-24 21:46:42 -07005315 if (((flags & eTransformHintUpdateNeeded) == 0) &&
5316 oldLayerStack != layer->getLayerStack(LayerVector::StateSet::Current)) {
Vishnu Nairafd527a2022-10-18 08:56:10 -07005317 flags |= eTransformHintUpdateNeeded;
5318 }
5319
Mathias Agopiane57f2922012-08-09 16:29:12 -07005320 return flags;
5321}
5322
Vishnu Nair3af0ec02023-02-10 04:13:48 +00005323uint32_t SurfaceFlinger::updateLayerCallbacksAndStats(const FrameTimelineInfo& frameTimelineInfo,
5324 ResolvedComposerState& composerState,
5325 int64_t desiredPresentTime,
5326 bool isAutoTimestamp, int64_t postTime,
Vishnu Nair3af0ec02023-02-10 04:13:48 +00005327 uint64_t transactionId) {
5328 layer_state_t& s = composerState.state;
Vishnu Nair3af0ec02023-02-10 04:13:48 +00005329
5330 std::vector<ListenerCallbacks> filteredListeners;
5331 for (auto& listener : s.listeners) {
5332 // Starts a registration but separates the callback ids according to callback type. This
5333 // allows the callback invoker to send on latch callbacks earlier.
5334 // note that startRegistration will not re-register if the listener has
5335 // already be registered for a prior surface control
5336
5337 ListenerCallbacks onCommitCallbacks = listener.filter(CallbackId::Type::ON_COMMIT);
5338 if (!onCommitCallbacks.callbackIds.empty()) {
5339 filteredListeners.push_back(onCommitCallbacks);
5340 }
5341
5342 ListenerCallbacks onCompleteCallbacks = listener.filter(CallbackId::Type::ON_COMPLETE);
5343 if (!onCompleteCallbacks.callbackIds.empty()) {
5344 filteredListeners.push_back(onCompleteCallbacks);
5345 }
5346 }
5347
5348 const uint64_t what = s.what;
5349 uint32_t flags = 0;
5350 sp<Layer> layer = nullptr;
5351 if (s.surface) {
5352 layer = LayerHandle::getLayer(s.surface);
5353 } else {
5354 // The client may provide us a null handle. Treat it as if the layer was removed.
5355 ALOGW("Attempt to set client state with a null layer handle");
5356 }
5357 if (layer == nullptr) {
5358 for (auto& [listener, callbackIds] : s.listeners) {
5359 mTransactionCallbackInvoker.addCallbackHandle(sp<CallbackHandle>::make(listener,
5360 callbackIds,
5361 s.surface),
5362 std::vector<JankData>());
5363 }
5364 return 0;
5365 }
5366 if (what & layer_state_t::eProducerDisconnect) {
5367 layer->onDisconnect();
5368 }
5369 std::optional<nsecs_t> dequeueBufferTimestamp;
5370 if (what & layer_state_t::eMetadataChanged) {
5371 dequeueBufferTimestamp = s.metadata.getInt64(gui::METADATA_DEQUEUE_TIME);
5372 }
5373
5374 std::vector<sp<CallbackHandle>> callbackHandles;
5375 if ((what & layer_state_t::eHasListenerCallbacksChanged) && (!filteredListeners.empty())) {
5376 for (auto& [listener, callbackIds] : filteredListeners) {
5377 callbackHandles.emplace_back(
5378 sp<CallbackHandle>::make(listener, callbackIds, s.surface));
5379 }
5380 }
Vishnu Naird47bcee2023-02-24 18:08:51 +00005381 // TODO(b/238781169) remove after screenshot refactor, currently screenshots
5382 // requires to read drawing state from binder thread. So we need to fix that
5383 // before removing this.
5384 if (what & layer_state_t::eCropChanged) {
5385 if (layer->setCrop(s.crop)) flags |= eTraversalNeeded;
5386 }
Vishnu Nair3af0ec02023-02-10 04:13:48 +00005387 if (what & layer_state_t::eSidebandStreamChanged) {
5388 if (layer->setSidebandStream(s.sidebandStream)) flags |= eTraversalNeeded;
5389 }
5390 if (what & layer_state_t::eBufferChanged) {
Vishnu Nairb76d99a2023-03-19 18:22:31 -07005391 std::optional<ui::Transform::RotationFlags> transformHint = std::nullopt;
5392 frontend::LayerSnapshot* snapshot = mLayerSnapshotBuilder.getSnapshot(layer->sequence);
5393 if (snapshot) {
5394 transformHint = snapshot->transformHint;
5395 }
5396 layer->setTransformHint(transformHint);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00005397 if (layer->setBuffer(composerState.externalTexture, *s.bufferData, postTime,
5398 desiredPresentTime, isAutoTimestamp, dequeueBufferTimestamp,
5399 frameTimelineInfo)) {
Vishnu Nair3af0ec02023-02-10 04:13:48 +00005400 flags |= eTraversalNeeded;
5401 }
5402 mLayersWithQueuedFrames.emplace(layer);
5403 } else if (frameTimelineInfo.vsyncId != FrameTimelineInfo::INVALID_VSYNC_ID) {
5404 layer->setFrameTimelineVsyncForBufferlessTransaction(frameTimelineInfo, postTime);
5405 }
5406
Vishnu Nairef68d6d2023-02-28 06:18:27 +00005407 if ((what & layer_state_t::eBufferChanged) == 0) {
5408 layer->setDesiredPresentTime(desiredPresentTime, isAutoTimestamp);
5409 }
5410
Vishnu Nair3af0ec02023-02-10 04:13:48 +00005411 if (what & layer_state_t::eTrustedPresentationInfoChanged) {
Chavi Weingarten328a8312023-01-26 21:17:52 +00005412 if (layer->setTrustedPresentationInfo(s.trustedPresentationThresholds,
5413 s.trustedPresentationListener)) {
5414 flags |= eTraversalNeeded;
5415 }
Vishnu Nair3af0ec02023-02-10 04:13:48 +00005416 }
5417
Vishnu Naird47bcee2023-02-24 18:08:51 +00005418 const auto& requestedLayerState = mLayerLifecycleManager.getLayerFromId(layer->getSequence());
Vishnu Nair7ee4f462023-04-19 09:54:09 -07005419 bool willPresentCurrentTransaction = requestedLayerState &&
5420 (requestedLayerState->hasReadyFrame() ||
5421 requestedLayerState->willReleaseBufferOnLatch());
Vishnu Nair3af0ec02023-02-10 04:13:48 +00005422 if (layer->setTransactionCompletedListeners(callbackHandles, willPresentCurrentTransaction))
5423 flags |= eTraversalNeeded;
Vishnu Naird47bcee2023-02-24 18:08:51 +00005424
Vishnu Nair3af0ec02023-02-10 04:13:48 +00005425 return flags;
5426}
5427
chaviw273171b2018-12-26 11:46:30 -08005428uint32_t SurfaceFlinger::addInputWindowCommands(const InputWindowCommands& inputWindowCommands) {
Arthur Hung58144272021-01-16 03:43:53 +00005429 bool hasChanges = mInputWindowCommands.merge(inputWindowCommands);
Vishnu Naire798b472020-07-23 13:52:21 -07005430 return hasChanges ? eTraversalNeeded : 0;
chaviw273171b2018-12-26 11:46:30 -08005431}
5432
Vishnu Nair84125ac2021-12-02 08:47:48 -08005433status_t SurfaceFlinger::mirrorLayer(const LayerCreationArgs& args,
Patrick Williamsa361de62022-10-06 20:34:10 +00005434 const sp<IBinder>& mirrorFromHandle,
5435 gui::CreateSurfaceResult& outResult) {
chaviwfe94a222019-08-21 13:52:59 -07005436 if (!mirrorFromHandle) {
5437 return NAME_NOT_FOUND;
5438 }
5439
5440 sp<Layer> mirrorLayer;
5441 sp<Layer> mirrorFrom;
Vishnu Nair81750622023-03-08 15:02:06 -08005442 LayerCreationArgs mirrorArgs = LayerCreationArgs::fromOtherArgs(args);
chaviwfe94a222019-08-21 13:52:59 -07005443 {
5444 Mutex::Autolock _l(mStateLock);
Vishnu Nair07e2a482022-10-18 19:18:16 +00005445 mirrorFrom = LayerHandle::getLayer(mirrorFromHandle);
chaviwfe94a222019-08-21 13:52:59 -07005446 if (!mirrorFrom) {
5447 return NAME_NOT_FOUND;
5448 }
Vishnu Nairb21272e2022-07-01 22:47:33 +00005449 mirrorArgs.flags |= ISurfaceComposerClient::eNoColorFill;
Vishnu Naircb8be502022-10-12 19:03:23 +00005450 mirrorArgs.mirrorLayerHandle = mirrorFromHandle;
5451 mirrorArgs.addToRoot = false;
Patrick Williamsa361de62022-10-06 20:34:10 +00005452 status_t result = createEffectLayer(mirrorArgs, &outResult.handle, &mirrorLayer);
chaviwfe94a222019-08-21 13:52:59 -07005453 if (result != NO_ERROR) {
5454 return result;
5455 }
5456
Vishnu Nairde177252023-04-21 12:44:10 -07005457 mirrorLayer->setClonedChild(mirrorFrom->createClone(mirrorLayer->getSequence()));
chaviwfe94a222019-08-21 13:52:59 -07005458 }
5459
Patrick Williamsa361de62022-10-06 20:34:10 +00005460 outResult.layerId = mirrorLayer->sequence;
5461 outResult.layerName = String16(mirrorLayer->getDebugName());
Vishnu Nair8319e362022-10-24 18:59:20 +00005462 return addClientLayer(mirrorArgs, outResult.handle, mirrorLayer /* layer */,
5463 nullptr /* parent */, nullptr /* outTransformHint */);
chaviwfe94a222019-08-21 13:52:59 -07005464}
5465
Chavi Weingarten7043a7d2022-07-19 23:40:35 +00005466status_t SurfaceFlinger::mirrorDisplay(DisplayId displayId, const LayerCreationArgs& args,
Patrick Williamsa361de62022-10-06 20:34:10 +00005467 gui::CreateSurfaceResult& outResult) {
Chavi Weingarten7043a7d2022-07-19 23:40:35 +00005468 IPCThreadState* ipc = IPCThreadState::self();
5469 const int uid = ipc->getCallingUid();
5470 if (uid != AID_ROOT && uid != AID_GRAPHICS && uid != AID_SYSTEM && uid != AID_SHELL) {
5471 ALOGE("Permission denied when trying to mirror display");
5472 return PERMISSION_DENIED;
5473 }
5474
5475 ui::LayerStack layerStack;
5476 sp<Layer> rootMirrorLayer;
5477 status_t result = 0;
5478
5479 {
5480 Mutex::Autolock lock(mStateLock);
5481
5482 const auto display = getDisplayDeviceLocked(displayId);
5483 if (!display) {
5484 return NAME_NOT_FOUND;
5485 }
5486
5487 layerStack = display->getLayerStack();
Vishnu Nair81750622023-03-08 15:02:06 -08005488 LayerCreationArgs mirrorArgs = LayerCreationArgs::fromOtherArgs(args);
Chavi Weingarten7043a7d2022-07-19 23:40:35 +00005489 mirrorArgs.flags |= ISurfaceComposerClient::eNoColorFill;
Vishnu Naircb8be502022-10-12 19:03:23 +00005490 mirrorArgs.addToRoot = true;
Vishnu Nair3af0ec02023-02-10 04:13:48 +00005491 mirrorArgs.layerStackToMirror = layerStack;
Patrick Williamsa361de62022-10-06 20:34:10 +00005492 result = createEffectLayer(mirrorArgs, &outResult.handle, &rootMirrorLayer);
5493 outResult.layerId = rootMirrorLayer->sequence;
5494 outResult.layerName = String16(rootMirrorLayer->getDebugName());
Vishnu Nair8319e362022-10-24 18:59:20 +00005495 result |= addClientLayer(mirrorArgs, outResult.handle, rootMirrorLayer /* layer */,
Vishnu Naircb8be502022-10-12 19:03:23 +00005496 nullptr /* parent */, nullptr /* outTransformHint */);
Chavi Weingarten7043a7d2022-07-19 23:40:35 +00005497 }
5498
5499 if (result != NO_ERROR) {
5500 return result;
5501 }
5502
Lloyd Pique30db6402023-06-26 18:56:51 +00005503 if (mLegacyFrontEndEnabled) {
Chavi Weingarten7043a7d2022-07-19 23:40:35 +00005504 std::scoped_lock<std::mutex> lock(mMirrorDisplayLock);
Patrick Williamsa361de62022-10-06 20:34:10 +00005505 mMirrorDisplays.emplace_back(layerStack, outResult.handle, args.client);
Chavi Weingarten7043a7d2022-07-19 23:40:35 +00005506 }
5507
5508 setTransactionFlags(eTransactionFlushNeeded);
5509 return NO_ERROR;
5510}
5511
Vishnu Naircb8be502022-10-12 19:03:23 +00005512status_t SurfaceFlinger::createLayer(LayerCreationArgs& args, gui::CreateSurfaceResult& outResult) {
Mathias Agopian4d9b8222013-03-12 17:11:48 -07005513 status_t result = NO_ERROR;
5514
5515 sp<Layer> layer;
5516
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08005517 switch (args.flags & ISurfaceComposerClient::eFXSurfaceMask) {
Marissa Wall61c58622018-07-18 10:12:20 -07005518 case ISurfaceComposerClient::eFXSurfaceBufferQueue:
Vishnu Nairbc4ee5c2022-08-16 03:19:37 +00005519 case ISurfaceComposerClient::eFXSurfaceContainer:
5520 case ISurfaceComposerClient::eFXSurfaceBufferState:
5521 args.flags |= ISurfaceComposerClient::eNoColorFill;
5522 FMT_FALLTHROUGH;
5523 case ISurfaceComposerClient::eFXSurfaceEffect: {
Patrick Williamsa361de62022-10-06 20:34:10 +00005524 result = createBufferStateLayer(args, &outResult.handle, &layer);
Vishnu Nair8eda69e2021-02-26 10:42:10 -08005525 std::atomic<int32_t>* pendingBufferCounter = layer->getPendingBufferCounter();
5526 if (pendingBufferCounter) {
5527 std::string counterName = layer->getPendingBufferCounterName();
Patrick Williamsa361de62022-10-06 20:34:10 +00005528 mBufferCountTracker.add(outResult.handle->localBinder(), counterName,
Vishnu Nair8eda69e2021-02-26 10:42:10 -08005529 pendingBufferCounter);
5530 }
5531 } break;
Mathias Agopian4d9b8222013-03-12 17:11:48 -07005532 default:
5533 result = BAD_VALUE;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005534 break;
5535 }
5536
Dan Stoza7d89d062015-04-30 13:29:25 -07005537 if (result != NO_ERROR) {
5538 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005539 }
Dan Stoza7d89d062015-04-30 13:29:25 -07005540
Vishnu Naircb8be502022-10-12 19:03:23 +00005541 args.addToRoot = args.addToRoot && callingThreadHasUnscopedSurfaceFlingerAccess();
Vishnu Nair07e2a482022-10-18 19:18:16 +00005542 // We can safely promote the parent layer in binder thread because we have a strong reference
5543 // to the layer's handle inside this scope.
5544 sp<Layer> parent = LayerHandle::getLayer(args.parentHandle.promote());
Vishnu Naircb8be502022-10-12 19:03:23 +00005545 if (args.parentHandle != nullptr && parent == nullptr) {
Vishnu Nair07e2a482022-10-18 19:18:16 +00005546 ALOGE("Invalid parent handle %p", args.parentHandle.promote().get());
Vishnu Naircb8be502022-10-12 19:03:23 +00005547 args.addToRoot = false;
Garfield Tandbc93d72021-10-26 18:28:57 -07005548 }
Dan Stoza7d89d062015-04-30 13:29:25 -07005549
Patrick Williamsa361de62022-10-06 20:34:10 +00005550 uint32_t outTransformHint;
Vishnu Naircb8be502022-10-12 19:03:23 +00005551 result = addClientLayer(args, outResult.handle, layer, parent, &outTransformHint);
Vishnu Nair047fb332021-12-09 09:54:36 -08005552 if (result != NO_ERROR) {
5553 return result;
5554 }
5555
Patrick Williamsa361de62022-10-06 20:34:10 +00005556 outResult.transformHint = static_cast<int32_t>(outTransformHint);
5557 outResult.layerId = layer->sequence;
5558 outResult.layerName = String16(layer->getDebugName());
Mathias Agopian4d9b8222013-03-12 17:11:48 -07005559 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005560}
5561
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08005562status_t SurfaceFlinger::createBufferStateLayer(LayerCreationArgs& args, sp<IBinder>* handle,
Vishnu Nair6213bd92020-05-08 17:42:25 -07005563 sp<Layer>* outLayer) {
chaviwb4c6e582019-08-16 14:35:07 -07005564 args.textureName = getNewTexture();
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08005565 *outLayer = getFactory().createBufferStateLayer(args);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07005566 *handle = (*outLayer)->getHandle();
Mathias Agopian4d9b8222013-03-12 17:11:48 -07005567 return NO_ERROR;
Mathias Agopian118d0242011-10-13 16:02:48 -07005568}
5569
Vishnu Nair84125ac2021-12-02 08:47:48 -08005570status_t SurfaceFlinger::createEffectLayer(const LayerCreationArgs& args, sp<IBinder>* handle,
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08005571 sp<Layer>* outLayer) {
5572 *outLayer = getFactory().createEffectLayer(args);
5573 *handle = (*outLayer)->getHandle();
5574 return NO_ERROR;
5575}
5576
Robert Carr6fb1a7e2018-12-11 12:07:25 -08005577void SurfaceFlinger::markLayerPendingRemovalLocked(const sp<Layer>& layer) {
Robert Carr2e102c92018-10-23 12:11:15 -07005578 mLayersPendingRemoval.add(layer);
5579 mLayersRemoved = true;
5580 setTransactionFlags(eTransactionNeeded);
5581}
5582
Vishnu Nair3af0ec02023-02-10 04:13:48 +00005583void SurfaceFlinger::onHandleDestroyed(BBinder* handle, sp<Layer>& layer, uint32_t layerId) {
5584 {
5585 std::scoped_lock<std::mutex> lock(mCreatedLayersLock);
5586 mDestroyedHandles.emplace_back(layerId);
5587 }
5588
Robert Carr2e102c92018-10-23 12:11:15 -07005589 Mutex::Autolock lock(mStateLock);
Robert Carr6fb1a7e2018-12-11 12:07:25 -08005590 markLayerPendingRemovalLocked(layer);
Vishnu Nair787aa782023-03-17 13:46:46 -07005591 layer->onHandleDestroyed();
Vishnu Nairf9096652021-07-20 18:49:42 -07005592 mBufferCountTracker.remove(handle);
Robert Carr695d5282018-12-18 15:27:58 -08005593 layer.clear();
Vishnu Nair3af0ec02023-02-10 04:13:48 +00005594
5595 setTransactionFlags(eTransactionFlushNeeded);
Rob Carr4bba3702018-10-08 21:53:30 +00005596}
5597
Dominik Laskowskib5f40e52022-09-29 13:25:05 -04005598void SurfaceFlinger::initializeDisplays() {
Dominik Laskowski16863742022-09-29 11:57:40 -04005599 const auto display = FTL_FAKE_GUARD(mStateLock, getDefaultDisplayDeviceLocked());
Dominik Laskowski83b88212018-12-11 13:34:06 -08005600 if (!display) return;
5601
5602 const sp<IBinder> token = display->getDisplayToken().promote();
5603 LOG_ALWAYS_FATAL_IF(token == nullptr);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07005604
Vishnu Naira7caedc2023-02-26 03:24:58 +00005605 TransactionState state;
5606 state.inputWindowCommands = mInputWindowCommands;
Dominik Laskowski16863742022-09-29 11:57:40 -04005607 const nsecs_t now = systemTime();
Vishnu Naira7caedc2023-02-26 03:24:58 +00005608 state.desiredPresentTime = now;
5609 state.postTime = now;
Lloyd Pique30db6402023-06-26 18:56:51 +00005610 state.originPid = mPid;
Vishnu Naira7caedc2023-02-26 03:24:58 +00005611 state.originUid = static_cast<int>(getuid());
Lloyd Pique30db6402023-06-26 18:56:51 +00005612 const uint64_t transactionId = (static_cast<uint64_t>(mPid) << 32) | mUniqueTransactionId++;
Vishnu Naira7caedc2023-02-26 03:24:58 +00005613 state.id = transactionId;
5614
Jesse Hall01e29052013-02-19 16:13:35 -08005615 // reset screen orientation and use primary layer stack
Andy McFadden13a082e2012-08-24 10:16:42 -07005616 Vector<DisplayState> displays;
5617 DisplayState d;
Jesse Hall01e29052013-02-19 16:13:35 -08005618 d.what = DisplayState::eDisplayProjectionChanged |
5619 DisplayState::eLayerStackChanged;
Dominik Laskowski83b88212018-12-11 13:34:06 -08005620 d.token = token;
Dominik Laskowski29fa1462021-04-27 15:51:50 -07005621 d.layerStack = ui::DEFAULT_LAYER_STACK;
Dominik Laskowski718f9602019-11-09 20:01:35 -08005622 d.orientation = ui::ROTATION_0;
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02005623 d.orientedDisplaySpaceRect.makeInvalid();
5624 d.layerStackSpaceRect.makeInvalid();
Michael Lentine47e45402014-07-18 15:34:25 -07005625 d.width = 0;
5626 d.height = 0;
Vishnu Naira7caedc2023-02-26 03:24:58 +00005627 state.displays.add(d);
Arthur Hung58144272021-01-16 03:43:53 +00005628
Vishnu Naira7caedc2023-02-26 03:24:58 +00005629 std::vector<TransactionState> transactions;
5630 transactions.emplace_back(state);
Vishnu Nair7891e962021-11-11 12:07:21 -08005631
Lloyd Pique30db6402023-06-26 18:56:51 +00005632 if (mLegacyFrontEndEnabled) {
Dominik Laskowski16863742022-09-29 11:57:40 -04005633 applyTransactions(transactions, VsyncId{0});
Vishnu Naira7caedc2023-02-26 03:24:58 +00005634 } else {
5635 applyAndCommitDisplayTransactionStates(transactions);
5636 }
Jamie Gennis6547ff42013-07-16 20:12:42 -07005637
Dominik Laskowski16863742022-09-29 11:57:40 -04005638 {
5639 ftl::FakeGuard guard(mStateLock);
5640 setPowerModeInternal(display, hal::PowerMode::ON);
5641 }
Andy McFadden13a082e2012-08-24 10:16:42 -07005642}
5643
Peiyong Lin65248e02020-04-18 21:15:07 -07005644void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& display, hal::PowerMode mode) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07005645 if (display->isVirtual()) {
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08005646 ALOGE("%s: Invalid operation on virtual display", __func__);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07005647 return;
5648 }
5649
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02005650 const auto displayId = display->getPhysicalId();
5651 ALOGD("Setting power mode %d on display %s", mode, to_string(displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07005652
Dominik Laskowskib4ff7d92022-11-22 13:59:53 -05005653 const auto currentModeOpt = display->getPowerMode();
5654 if (currentModeOpt == mode) {
Prashant Malani2c9b11f2014-05-25 01:36:31 -07005655 return;
5656 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07005657
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07005658 const bool isInternalDisplay = mPhysicalDisplays.get(displayId)
5659 .transform(&PhysicalDisplay::isInternal)
5660 .value_or(false);
5661
Dominik Laskowskie591b552022-09-09 10:44:56 -07005662 const auto activeDisplay = getDisplayDeviceLocked(mActiveDisplayId);
Dominik Laskowskic132a152022-11-30 15:44:52 -05005663
Dominik Laskowski31afdda2022-12-08 19:15:15 -05005664 ALOGW_IF(display != activeDisplay && isInternalDisplay && activeDisplay &&
5665 activeDisplay->isPoweredOn(),
Dominik Laskowskic132a152022-11-30 15:44:52 -05005666 "Trying to change power mode on inactive display without powering off active display");
Ady Abraham4f960d12021-10-13 16:59:49 -07005667
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005668 display->setPowerMode(mode);
5669
Ady Abrahamace3d052022-11-17 16:25:05 -08005670 const auto refreshRate = display->refreshRateSelector().getActiveMode().modePtr->getFps();
Dominik Laskowskib4ff7d92022-11-22 13:59:53 -05005671 if (!currentModeOpt || *currentModeOpt == hal::PowerMode::OFF) {
Ady Abraham4f960d12021-10-13 16:59:49 -07005672 // Turn on the display
Dominik Laskowski31afdda2022-12-08 19:15:15 -05005673
Dominik Laskowskia39e32f2023-02-08 16:40:13 -05005674 // Activate the display (which involves a modeset to the active mode) when the inner or
5675 // outer display of a foldable is powered on. This condition relies on the above
5676 // DisplayDevice::setPowerMode. If `display` and `activeDisplay` are the same display,
5677 // then the `activeDisplay->isPoweredOn()` below is true, such that the display is not
5678 // activated every time it is powered on.
Dominik Laskowski31afdda2022-12-08 19:15:15 -05005679 //
5680 // TODO(b/255635821): Remove the concept of active display.
Dominik Laskowskia39e32f2023-02-08 16:40:13 -05005681 if (isInternalDisplay && (!activeDisplay || !activeDisplay->isPoweredOn())) {
Dominik Laskowski39dfc942023-02-08 16:27:05 -05005682 onActiveDisplayChangedLocked(activeDisplay.get(), *display);
Ady Abrahamed3290f2021-05-17 15:12:14 -07005683 }
Dominik Laskowski31afdda2022-12-08 19:15:15 -05005684
Dominik Laskowskicf0bb432023-05-09 11:49:16 -04005685 if (displayId == mActiveDisplayId) {
5686 // TODO(b/281692563): Merge the syscalls. For now, keep uclamp in a separate syscall and
5687 // set it before SCHED_FIFO due to b/190237315.
5688 if (setSchedAttr(true) != NO_ERROR) {
5689 ALOGW("Failed to set uclamp.min after powering on active display: %s",
5690 strerror(errno));
5691 }
5692 if (setSchedFifo(true) != NO_ERROR) {
5693 ALOGW("Failed to set SCHED_FIFO after powering on active display: %s",
5694 strerror(errno));
5695 }
Wei Wang23aa5a62021-06-04 15:56:57 -07005696 }
Dominik Laskowskicf0bb432023-05-09 11:49:16 -04005697
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02005698 getHwComposer().setPowerMode(displayId, mode);
Dominik Laskowskie99b98c2023-02-02 12:37:23 -05005699 if (displayId == mActiveDisplayId && mode != hal::PowerMode::DOZE_SUSPEND) {
Dominik Laskowski66295432023-03-14 12:25:36 -04005700 const bool enable =
5701 mScheduler->getVsyncSchedule(displayId)->getPendingHardwareVsyncState();
5702 requestHardwareVsync(displayId, enable);
5703
Dominik Laskowskie99b98c2023-02-02 12:37:23 -05005704 mScheduler->enableSyntheticVsync(false);
Dominik Laskowski66295432023-03-14 12:25:36 -04005705
5706 constexpr bool kAllowToEnable = true;
5707 mScheduler->resyncToHardwareVsync(displayId, kAllowToEnable, refreshRate);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07005708 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005709
Prashant Malani2c9b11f2014-05-25 01:36:31 -07005710 mVisibleRegionsDirty = true;
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07005711 scheduleComposite(FrameHint::kActive);
Peiyong Lin65248e02020-04-18 21:15:07 -07005712 } else if (mode == hal::PowerMode::OFF) {
Tim Murrayf9d4e442016-08-02 15:43:59 -07005713 // Turn off the display
Dominik Laskowskicf0bb432023-05-09 11:49:16 -04005714
5715 if (displayId == mActiveDisplayId) {
5716 if (setSchedFifo(false) != NO_ERROR) {
5717 ALOGW("Failed to set SCHED_OTHER after powering off active display: %s",
5718 strerror(errno));
5719 }
5720 if (setSchedAttr(false) != NO_ERROR) {
5721 ALOGW("Failed set uclamp.min after powering off active display: %s",
5722 strerror(errno));
5723 }
5724
5725 if (*currentModeOpt != hal::PowerMode::DOZE_SUSPEND) {
5726 mScheduler->disableHardwareVsync(displayId, true);
5727 mScheduler->enableSyntheticVsync();
5728 }
Mathias Agopiancde87a32012-09-13 14:09:01 -07005729 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07005730
Dominik Laskowski66295432023-03-14 12:25:36 -04005731 // Disable VSYNC before turning off the display.
5732 requestHardwareVsync(displayId, false);
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02005733 getHwComposer().setPowerMode(displayId, mode);
Dominik Laskowski66295432023-03-14 12:25:36 -04005734
Prashant Malani2c9b11f2014-05-25 01:36:31 -07005735 mVisibleRegionsDirty = true;
5736 // from this point on, SF will stop drawing on this display
Peiyong Lin65248e02020-04-18 21:15:07 -07005737 } else if (mode == hal::PowerMode::DOZE || mode == hal::PowerMode::ON) {
Zheng Zhang8a43fe62017-03-17 11:19:39 +01005738 // Update display while dozing
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02005739 getHwComposer().setPowerMode(displayId, mode);
Dominik Laskowskie99b98c2023-02-02 12:37:23 -05005740 if (displayId == mActiveDisplayId && *currentModeOpt == hal::PowerMode::DOZE_SUSPEND) {
Yifei Zhangf0bd62e2021-06-16 15:27:05 -07005741 ALOGI("Force repainting for DOZE_SUSPEND -> DOZE or ON.");
5742 mVisibleRegionsDirty = true;
5743 scheduleRepaint();
Dominik Laskowskie99b98c2023-02-02 12:37:23 -05005744 mScheduler->enableSyntheticVsync(false);
Leon Scroggins III67388622023-02-06 20:36:20 -05005745 mScheduler->resyncToHardwareVsync(displayId, true /* allowToEnable */, refreshRate);
Zheng Zhang8a43fe62017-03-17 11:19:39 +01005746 }
Peiyong Lin65248e02020-04-18 21:15:07 -07005747 } else if (mode == hal::PowerMode::DOZE_SUSPEND) {
Zheng Zhang8a43fe62017-03-17 11:19:39 +01005748 // Leave display going to doze
Dominik Laskowskie99b98c2023-02-02 12:37:23 -05005749 if (displayId == mActiveDisplayId) {
Leon Scroggins III67388622023-02-06 20:36:20 -05005750 mScheduler->disableHardwareVsync(displayId, true);
Dominik Laskowskie99b98c2023-02-02 12:37:23 -05005751 mScheduler->enableSyntheticVsync();
Zheng Zhang8a43fe62017-03-17 11:19:39 +01005752 }
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02005753 getHwComposer().setPowerMode(displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07005754 } else {
Matthew Bouyack38d49612017-05-12 12:49:32 -07005755 ALOGE("Attempting to set unknown power mode: %d\n", mode);
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02005756 getHwComposer().setPowerMode(displayId, mode);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07005757 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005758
Dominik Laskowskie99b98c2023-02-02 12:37:23 -05005759 if (displayId == mActiveDisplayId) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08005760 mTimeStats->setPowerMode(mode);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07005761 mRefreshRateStats->setPowerMode(mode);
Yiwei Zhang3a226d22018-10-16 09:23:03 -07005762 }
5763
Dominik Laskowski66295432023-03-14 12:25:36 -04005764 mScheduler->setDisplayPowerMode(displayId, mode);
5765
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02005766 ALOGD("Finished setting power mode %d on display %s", mode, to_string(displayId).c_str());
Andy McFaddenc01a79d2012-09-27 16:02:06 -07005767}
5768
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005769void SurfaceFlinger::setPowerMode(const sp<IBinder>& displayToken, int mode) {
Dominik Laskowskif8734e02022-08-26 09:06:59 -07005770 auto future = mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) FTL_FAKE_GUARD(
5771 kMainThreadContext) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005772 const auto display = getDisplayDeviceLocked(displayToken);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005773 if (!display) {
5774 ALOGE("Attempt to set power mode %d for invalid display token %p", mode,
5775 displayToken.get());
5776 } else if (display->isVirtual()) {
5777 ALOGW("Attempt to set power mode %d for virtual display", mode);
5778 } else {
Peiyong Lin65248e02020-04-18 21:15:07 -07005779 setPowerModeInternal(display, static_cast<hal::PowerMode>(mode));
Andy McFaddenc01a79d2012-09-27 16:02:06 -07005780 }
Dominik Laskowski756b7892021-08-04 12:53:59 -07005781 });
5782
5783 future.wait();
Mathias Agopianb60314a2012-04-10 22:09:54 -07005784}
5785
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07005786status_t SurfaceFlinger::doDump(int fd, const DumpArgs& args, bool asProto) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08005787 std::string result;
Mathias Agopian99b49842011-06-27 16:05:52 -07005788
Mathias Agopianbd115332013-04-18 16:41:04 -07005789 IPCThreadState* ipc = IPCThreadState::self();
5790 const int pid = ipc->getCallingPid();
5791 const int uid = ipc->getCallingUid();
Vishnu Nair6a408532017-10-24 09:11:27 -07005792
Mathias Agopianbd115332013-04-18 16:41:04 -07005793 if ((uid != AID_SHELL) &&
5794 !PermissionCache::checkPermission(sDump, pid, uid)) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08005795 StringAppendF(&result, "Permission Denial: can't dump SurfaceFlinger from pid=%d, uid=%d\n",
5796 pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005797 } else {
Dominik Laskowskic2867142019-01-21 11:33:38 -08005798 static const std::unordered_map<std::string, Dumper> dumpers = {
Dominik Laskowski0acc3842022-04-07 11:23:42 -07005799 {"--comp-displays"s, dumper(&SurfaceFlinger::dumpCompositionDisplays)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08005800 {"--display-id"s, dumper(&SurfaceFlinger::dumpDisplayIdentificationData)},
Dominik Laskowski0acc3842022-04-07 11:23:42 -07005801 {"--displays"s, dumper(&SurfaceFlinger::dumpDisplays)},
Dominik Laskowskib6e54372019-09-04 14:06:28 -07005802 {"--edid"s, argsDumper(&SurfaceFlinger::dumpRawDisplayIdentificationData)},
Dominik Laskowski03cfce82022-11-02 12:13:29 -04005803 {"--events"s, dumper(&SurfaceFlinger::dumpEvents)},
5804 {"--frametimeline"s, argsDumper(&SurfaceFlinger::dumpFrameTimeline)},
Vishnu Nair3cc15a42023-06-30 06:20:22 +00005805 {"--hwclayers"s, dumper(&SurfaceFlinger::dumpHwcLayersMinidumpLockedLegacy)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08005806 {"--latency"s, argsDumper(&SurfaceFlinger::dumpStatsLocked)},
5807 {"--latency-clear"s, argsDumper(&SurfaceFlinger::clearStatsLocked)},
5808 {"--list"s, dumper(&SurfaceFlinger::listLayersLocked)},
Dan Stoza269dc4d2021-01-15 15:07:43 -08005809 {"--planner"s, argsDumper(&SurfaceFlinger::dumpPlannerInfo)},
Dominik Laskowski03cfce82022-11-02 12:13:29 -04005810 {"--scheduler"s, dumper(&SurfaceFlinger::dumpScheduler)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08005811 {"--timestats"s, protoDumper(&SurfaceFlinger::dumpTimeStats)},
Dominik Laskowski03cfce82022-11-02 12:13:29 -04005812 {"--vsync"s, dumper(&SurfaceFlinger::dumpVsync)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08005813 {"--wide-color"s, dumper(&SurfaceFlinger::dumpWideColorInfo)},
5814 };
Mathias Agopian25e66fc2012-01-28 22:31:55 -08005815
Dominik Laskowskic2867142019-01-21 11:33:38 -08005816 const auto flag = args.empty() ? ""s : std::string(String8(args[0]));
Mathias Agopian25e66fc2012-01-28 22:31:55 -08005817
Alec Mouri67617332022-09-26 21:37:01 +00005818 // Traversal of drawing state must happen on the main thread.
5819 // Otherwise, SortedVector may have shared ownership during concurrent
5820 // traversals, which can result in use-after-frees.
5821 std::string compositionLayers;
5822 mScheduler
Vishnu Nair3cc15a42023-06-30 06:20:22 +00005823 ->schedule([&]() FTL_FAKE_GUARD(mStateLock) FTL_FAKE_GUARD(kMainThreadContext) {
5824 if (!mLayerLifecycleManagerEnabled) {
5825 StringAppendF(&compositionLayers, "Composition layers\n");
5826 mDrawingState.traverseInZOrder([&](Layer* layer) {
5827 auto* compositionState = layer->getCompositionState();
5828 if (!compositionState || !compositionState->isVisible) return;
5829 android::base::StringAppendF(&compositionLayers, "* Layer %p (%s)\n",
5830 layer,
5831 layer->getDebugName()
5832 ? layer->getDebugName()
5833 : "<unknown>");
5834 compositionState->dump(compositionLayers);
5835 });
5836 } else {
5837 std::ostringstream out;
5838 out << "\nComposition list\n";
5839 ui::LayerStack lastPrintedLayerStackHeader = ui::INVALID_LAYER_STACK;
5840 mLayerSnapshotBuilder.forEachVisibleSnapshot(
5841 [&](std::unique_ptr<frontend::LayerSnapshot>& snapshot) {
5842 if (snapshot->hasSomethingToDraw()) {
5843 if (lastPrintedLayerStackHeader !=
5844 snapshot->outputFilter.layerStack) {
5845 lastPrintedLayerStackHeader =
5846 snapshot->outputFilter.layerStack;
5847 out << "LayerStack=" << lastPrintedLayerStackHeader.id
5848 << "\n";
5849 }
5850 out << " " << *snapshot << "\n";
5851 }
5852 });
Alec Mouri67617332022-09-26 21:37:01 +00005853
Vishnu Nair3cc15a42023-06-30 06:20:22 +00005854 out << "\nInput list\n";
5855 lastPrintedLayerStackHeader = ui::INVALID_LAYER_STACK;
5856 mLayerSnapshotBuilder.forEachInputSnapshot(
5857 [&](const frontend::LayerSnapshot& snapshot) {
5858 if (lastPrintedLayerStackHeader !=
5859 snapshot.outputFilter.layerStack) {
5860 lastPrintedLayerStackHeader =
5861 snapshot.outputFilter.layerStack;
5862 out << "LayerStack=" << lastPrintedLayerStackHeader.id
5863 << "\n";
5864 }
5865 out << " " << snapshot << "\n";
5866 });
5867
5868 out << "\nLayer Hierarchy\n"
5869 << mLayerHierarchyBuilder.getHierarchy() << "\n\n";
5870 compositionLayers = out.str();
5871 dumpHwcLayersMinidump(compositionLayers);
5872 }
Alec Mouri67617332022-09-26 21:37:01 +00005873 })
5874 .get();
5875
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07005876 bool dumpLayers = true;
5877 {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08005878 TimedLock lock(mStateLock, s2ns(1), __func__);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07005879 if (!lock.locked()) {
5880 StringAppendF(&result, "Dumping without lock after timeout: %s (%d)\n",
5881 strerror(-lock.status), lock.status);
5882 }
5883
5884 if (const auto it = dumpers.find(flag); it != dumpers.end()) {
5885 (it->second)(args, asProto, result);
5886 dumpLayers = false;
5887 } else if (!asProto) {
Alec Mouri67617332022-09-26 21:37:01 +00005888 dumpAllLocked(args, compositionLayers, result);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07005889 }
Mathias Agopian48b888a2011-01-19 16:15:53 -08005890 }
5891
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07005892 if (dumpLayers) {
Vishnu Nair00b90132021-11-05 14:03:40 -07005893 LayersTraceFileProto traceFileProto = mLayerTracing.createTraceFileProto();
chaviw0a398992021-08-13 10:13:01 -05005894 LayersTraceProto* layersTrace = traceFileProto.add_entry();
5895 LayersProto layersProto = dumpProtoFromMainThread();
5896 layersTrace->mutable_layers()->Swap(&layersProto);
Vishnu Nair81750622023-03-08 15:02:06 -08005897 auto displayProtos = dumpDisplayProto();
5898 layersTrace->mutable_displays()->Swap(&displayProtos);
chaviw0a398992021-08-13 10:13:01 -05005899
Dominik Laskowski46470112019-08-02 13:13:11 -07005900 if (asProto) {
chaviw0a398992021-08-13 10:13:01 -05005901 result.append(traceFileProto.SerializeAsString());
Dominik Laskowski46470112019-08-02 13:13:11 -07005902 } else {
Vishnu Nair0f085c62019-08-30 08:49:12 -07005903 // Dump info that we need to access from the main thread
chaviwa2b9fab2021-09-08 14:46:30 -05005904 const auto layerTree = LayerProtoParser::generateLayerTree(layersTrace->layers());
Dominik Laskowski46470112019-08-02 13:13:11 -07005905 result.append(LayerProtoParser::layerTreeToString(layerTree));
5906 result.append("\n");
Vishnu Nair0f085c62019-08-30 08:49:12 -07005907 dumpOffscreenLayers(result);
Dominik Laskowski46470112019-08-02 13:13:11 -07005908 }
Vishnu Nair8406fd72019-07-30 11:29:31 -07005909 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005910 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08005911 write(fd, result.c_str(), result.size());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005912 return NO_ERROR;
5913}
5914
Nataniel Borges8e7dc722019-02-28 15:10:28 -08005915status_t SurfaceFlinger::dumpCritical(int fd, const DumpArgs&, bool asProto) {
Nataniel Borges8e7dc722019-02-28 15:10:28 -08005916 return doDump(fd, DumpArgs(), asProto);
5917}
5918
Dominik Laskowskic2867142019-01-21 11:33:38 -08005919void SurfaceFlinger::listLayersLocked(std::string& result) const {
Yiwei Zhang5434a782018-12-05 18:06:32 -08005920 mCurrentState.traverseInZOrder(
Dominik Laskowski87a07e42019-10-10 20:38:02 -07005921 [&](Layer* layer) { StringAppendF(&result, "%s\n", layer->getDebugName()); });
Mathias Agopian25e66fc2012-01-28 22:31:55 -08005922}
5923
Dominik Laskowskic2867142019-01-21 11:33:38 -08005924void SurfaceFlinger::dumpStatsLocked(const DumpArgs& args, std::string& result) const {
Ady Abraham2492a022020-07-24 11:09:55 -07005925 StringAppendF(&result, "%" PRId64 "\n", getVsyncPeriodFromHWC());
Dominik Laskowski66296b22022-07-12 08:20:36 -07005926 if (args.size() < 2) return;
Jamie Gennis4b0eba92013-02-05 13:30:24 -08005927
Dominik Laskowski66296b22022-07-12 08:20:36 -07005928 const auto name = String8(args[1]);
5929 mCurrentState.traverseInZOrder([&](Layer* layer) {
5930 if (layer->getName() == name.string()) {
5931 layer->dumpFrameStats(result);
5932 }
5933 });
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005934}
5935
Dominik Laskowskic2867142019-01-21 11:33:38 -08005936void SurfaceFlinger::clearStatsLocked(const DumpArgs& args, std::string&) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07005937 const bool clearAll = args.size() < 2;
5938 const auto name = clearAll ? String8() : String8(args[1]);
5939
Edgar Arriaga844fa672020-01-16 14:21:42 -08005940 mCurrentState.traverse([&](Layer* layer) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07005941 if (clearAll || layer->getName() == name.string()) {
Svetoslavd85084b2014-03-20 10:28:31 -07005942 layer->clearFrameStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08005943 }
Robert Carr2047fae2016-11-28 14:09:09 -08005944 });
Mathias Agopian25e66fc2012-01-28 22:31:55 -08005945}
5946
Dominik Laskowskic2867142019-01-21 11:33:38 -08005947void SurfaceFlinger::dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const {
5948 mTimeStats->parseArgs(asProto, args, result);
5949}
5950
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -07005951void SurfaceFlinger::dumpFrameTimeline(const DumpArgs& args, std::string& result) const {
5952 mFrameTimeline->parseArgs(args, result);
5953}
5954
Dominik Laskowski8792c112022-07-12 09:03:39 -07005955void SurfaceFlinger::logFrameStats(TimePoint now) {
Dominik Laskowski8792c112022-07-12 09:03:39 -07005956 static TimePoint sTimestamp = now;
5957 if (now - sTimestamp < 30min) return;
5958 sTimestamp = now;
5959
5960 ATRACE_CALL();
Dominik Laskowski66296b22022-07-12 08:20:36 -07005961 mDrawingState.traverse([&](Layer* layer) { layer->logFrameStats(); });
Jamie Gennis6547ff42013-07-16 20:12:42 -07005962}
5963
Yiwei Zhang5434a782018-12-05 18:06:32 -08005964void SurfaceFlinger::appendSfConfigString(std::string& result) const {
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08005965 result.append(" [sf");
Fabien Sanglardc93afd52017-03-13 13:02:42 -07005966
Lloyd Pique30db6402023-06-26 18:56:51 +00005967 StringAppendF(&result, " PRESENT_TIME_OFFSET=%" PRId64, dispSyncPresentTimeOffset);
5968 StringAppendF(&result, " FORCE_HWC_FOR_RBG_TO_YUV=%d", useHwcForRgbToYuv);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08005969 StringAppendF(&result, " MAX_VIRT_DISPLAY_DIM=%zu",
5970 getHwComposer().getMaxVirtualDisplayDimension());
Lloyd Pique30db6402023-06-26 18:56:51 +00005971 StringAppendF(&result, " RUNNING_WITHOUT_SYNC_FRAMEWORK=%d", !hasSyncFramework);
Yiwei Zhang5434a782018-12-05 18:06:32 -08005972 StringAppendF(&result, " NUM_FRAMEBUFFER_SURFACE_BUFFERS=%" PRId64,
Lloyd Pique30db6402023-06-26 18:56:51 +00005973 maxFrameBufferAcquiredBuffers);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08005974 result.append("]");
Andy McFadden4803b742012-09-24 19:07:20 -07005975}
5976
Dominik Laskowski03cfce82022-11-02 12:13:29 -04005977void SurfaceFlinger::dumpScheduler(std::string& result) const {
5978 utils::Dumper dumper{result};
5979
5980 mScheduler->dump(dumper);
5981
Dominik Laskowski03cfce82022-11-02 12:13:29 -04005982 // TODO(b/241285876): Move to DisplayModeController.
5983 dumper.dump("debugDisplayModeSetByBackdoor"sv, mDebugDisplayModeSetByBackdoor);
5984 dumper.eol();
Dominik Laskowski98041832019-08-01 18:35:59 -07005985
Steven Thomas2bbaabe2019-08-28 16:08:35 -07005986 mRefreshRateStats->dump(result);
Dominik Laskowski03cfce82022-11-02 12:13:29 -04005987 dumper.eol();
Dominik Laskowski98041832019-08-01 18:35:59 -07005988
Ady Abraham8287e852020-08-12 14:44:58 -07005989 mVsyncConfiguration->dump(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08005990 StringAppendF(&result,
Dominik Laskowski03cfce82022-11-02 12:13:29 -04005991 " present offset: %9" PRId64 " ns\t VSYNC period: %9" PRId64
5992 " ns\n\n",
Lloyd Pique30db6402023-06-26 18:56:51 +00005993 dispSyncPresentTimeOffset, getVsyncPeriodFromHWC());
Dominik Laskowski03cfce82022-11-02 12:13:29 -04005994}
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08005995
Dominik Laskowski03cfce82022-11-02 12:13:29 -04005996void SurfaceFlinger::dumpEvents(std::string& result) const {
Ana Krulecc2870422019-01-29 19:00:58 -08005997 mScheduler->dump(mAppConnectionHandle, result);
Dominik Laskowski03cfce82022-11-02 12:13:29 -04005998}
5999
6000void SurfaceFlinger::dumpVsync(std::string& result) const {
Ady Abraham8cb21882020-08-26 18:22:05 -07006001 mScheduler->dumpVsync(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08006002}
6003
Dan Stoza269dc4d2021-01-15 15:07:43 -08006004void SurfaceFlinger::dumpPlannerInfo(const DumpArgs& args, std::string& result) const {
6005 for (const auto& [token, display] : mDisplays) {
6006 const auto compositionDisplay = display->getCompositionDisplay();
6007 compositionDisplay->dumpPlannerInfo(args, result);
6008 }
6009}
6010
Dominik Laskowski0acc3842022-04-07 11:23:42 -07006011void SurfaceFlinger::dumpCompositionDisplays(std::string& result) const {
6012 for (const auto& [token, display] : mDisplays) {
6013 display->getCompositionDisplay()->dump(result);
6014 result += '\n';
6015 }
6016}
6017
6018void SurfaceFlinger::dumpDisplays(std::string& result) const {
Dominik Laskowskie70461a2022-08-30 14:42:01 -07006019 utils::Dumper dumper{result};
6020
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07006021 for (const auto& [id, display] : mPhysicalDisplays) {
Dominik Laskowski5d7de5f2022-11-03 12:38:32 -04006022 utils::Dumper::Section section(dumper, ftl::Concat("Display ", id.value).str());
6023
6024 display.snapshot().dump(dumper);
6025
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07006026 if (const auto device = getDisplayDeviceLocked(id)) {
Dominik Laskowskie70461a2022-08-30 14:42:01 -07006027 device->dump(dumper);
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07006028 }
Dominik Laskowski0acc3842022-04-07 11:23:42 -07006029 }
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07006030
6031 for (const auto& [token, display] : mDisplays) {
6032 if (display->isVirtual()) {
Dominik Laskowski5d7de5f2022-11-03 12:38:32 -04006033 const auto displayId = display->getId();
6034 utils::Dumper::Section section(dumper,
6035 ftl::Concat("Virtual Display ", displayId.value).str());
Dominik Laskowskie70461a2022-08-30 14:42:01 -07006036 display->dump(dumper);
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07006037 }
6038 }
Dominik Laskowski0acc3842022-04-07 11:23:42 -07006039}
6040
Yiwei Zhang5434a782018-12-05 18:06:32 -08006041void SurfaceFlinger::dumpDisplayIdentificationData(std::string& result) const {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07006042 for (const auto& [token, display] : mDisplays) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02006043 const auto displayId = PhysicalDisplayId::tryCast(display->getId());
Dominik Laskowski075d3172018-05-24 15:50:06 -07006044 if (!displayId) {
6045 continue;
6046 }
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02006047 const auto hwcDisplayId = getHwComposer().fromPhysicalDisplayId(*displayId);
Dominik Laskowski7e045462018-05-30 13:02:02 -07006048 if (!hwcDisplayId) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07006049 continue;
6050 }
6051
Yiwei Zhang5434a782018-12-05 18:06:32 -08006052 StringAppendF(&result,
6053 "Display %s (HWC display %" PRIu64 "): ", to_string(*displayId).c_str(),
6054 *hwcDisplayId);
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07006055 uint8_t port;
6056 DisplayIdentificationData data;
Dominik Laskowski7e045462018-05-30 13:02:02 -07006057 if (!getHwComposer().getDisplayIdentificationData(*hwcDisplayId, &port, &data)) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07006058 result.append("no identification data\n");
6059 continue;
6060 }
6061
6062 if (!isEdid(data)) {
Dominik Laskowskib6e54372019-09-04 14:06:28 -07006063 result.append("unknown identification data\n");
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07006064 continue;
6065 }
6066
6067 const auto edid = parseEdid(data);
6068 if (!edid) {
Dominik Laskowskib6e54372019-09-04 14:06:28 -07006069 result.append("invalid EDID\n");
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07006070 continue;
6071 }
6072
Yiwei Zhang5434a782018-12-05 18:06:32 -08006073 StringAppendF(&result, "port=%u pnpId=%s displayName=\"", port, edid->pnpId.data());
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07006074 result.append(edid->displayName.data(), edid->displayName.length());
6075 result.append("\"\n");
6076 }
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07006077}
6078
Dominik Laskowskib6e54372019-09-04 14:06:28 -07006079void SurfaceFlinger::dumpRawDisplayIdentificationData(const DumpArgs& args,
6080 std::string& result) const {
Peiyong Line9d809e2020-04-14 13:10:48 -07006081 hal::HWDisplayId hwcDisplayId;
Dominik Laskowskib6e54372019-09-04 14:06:28 -07006082 uint8_t port;
6083 DisplayIdentificationData data;
6084
6085 if (args.size() > 1 && base::ParseUint(String8(args[1]), &hwcDisplayId) &&
6086 getHwComposer().getDisplayIdentificationData(hwcDisplayId, &port, &data)) {
6087 result.append(reinterpret_cast<const char*>(data.data()), data.size());
6088 }
6089}
6090
Yiwei Zhang5434a782018-12-05 18:06:32 -08006091void SurfaceFlinger::dumpWideColorInfo(std::string& result) const {
Lloyd Pique30db6402023-06-26 18:56:51 +00006092 StringAppendF(&result, "Device supports wide color: %d\n", mSupportsWideColor);
Yiwei Zhang5434a782018-12-05 18:06:32 -08006093 StringAppendF(&result, "Device uses color management: %d\n", useColorManagement);
6094 StringAppendF(&result, "DisplayColorSetting: %s\n",
6095 decodeDisplayColorSetting(mDisplayColorSetting).c_str());
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06006096
6097 // TODO: print out if wide-color mode is active or not
6098
Dominik Laskowski788945b2022-08-30 12:10:56 -07006099 for (const auto& [id, display] : mPhysicalDisplays) {
6100 StringAppendF(&result, "Display %s color modes:\n", to_string(id).c_str());
6101 for (const auto mode : display.snapshot().colorModes()) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08006102 StringAppendF(&result, " %s (%d)\n", decodeColorMode(mode).c_str(), mode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06006103 }
6104
Dominik Laskowski788945b2022-08-30 12:10:56 -07006105 if (const auto display = getDisplayDeviceLocked(id)) {
6106 ui::ColorMode currentMode = display->getCompositionDisplay()->getState().colorMode;
6107 StringAppendF(&result, " Current color mode: %s (%d)\n",
6108 decodeColorMode(currentMode).c_str(), currentMode);
6109 }
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06006110 }
6111 result.append("\n");
6112}
6113
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07006114LayersProto SurfaceFlinger::dumpDrawingStateProto(uint32_t traceFlags) const {
Nataniel Borges63b3c872022-11-03 16:22:24 +00006115 std::unordered_set<uint64_t> stackIdsToSkip;
6116
6117 // Determine if virtual layers display should be skipped
6118 if ((traceFlags & LayerTracing::TRACE_VIRTUAL_DISPLAYS) == 0) {
6119 for (const auto& [_, display] : FTL_FAKE_GUARD(mStateLock, mDisplays)) {
6120 if (display->isVirtual()) {
6121 stackIdsToSkip.insert(display->getLayerStack().id);
6122 }
6123 }
6124 }
6125
Lloyd Pique30db6402023-06-26 18:56:51 +00006126 if (mLegacyFrontEndEnabled) {
Vishnu Nairea6ff812023-02-27 17:41:39 +00006127 LayersProto layersProto;
6128 for (const sp<Layer>& layer : mDrawingState.layersSortedByZ) {
6129 if (stackIdsToSkip.find(layer->getLayerStack().id) != stackIdsToSkip.end()) {
6130 continue;
6131 }
6132 layer->writeToProto(layersProto, traceFlags);
Nataniel Borges63b3c872022-11-03 16:22:24 +00006133 }
Vishnu Nairea6ff812023-02-27 17:41:39 +00006134 return layersProto;
chaviw08f3cb22020-01-13 13:17:21 -08006135 }
Alec Mouri6b9e9912020-01-21 10:50:24 -08006136
Vishnu Nair22be3492023-04-20 10:08:21 -07006137 return LayerProtoFromSnapshotGenerator(mLayerSnapshotBuilder, mFrontEndDisplayInfos,
6138 mLegacyLayers, traceFlags)
Vishnu Naird0183602023-03-16 18:52:15 +00006139 .generate(mLayerHierarchyBuilder.getHierarchy());
chaviw1d044282017-09-27 12:19:28 -07006140}
6141
Vishnu Nair81750622023-03-08 15:02:06 -08006142google::protobuf::RepeatedPtrField<DisplayProto> SurfaceFlinger::dumpDisplayProto() const {
6143 google::protobuf::RepeatedPtrField<DisplayProto> displays;
Dominik Laskowski298b08e2022-02-15 13:45:02 -08006144 for (const auto& [_, display] : FTL_FAKE_GUARD(mStateLock, mDisplays)) {
Vishnu Nair81750622023-03-08 15:02:06 -08006145 DisplayProto* displayProto = displays.Add();
chaviw0a398992021-08-13 10:13:01 -05006146 displayProto->set_id(display->getId().value);
6147 displayProto->set_name(display->getDisplayName());
6148 displayProto->set_layer_stack(display->getLayerStack().id);
DoÄŸancan Emekfc4b6ed2023-07-26 15:24:04 +00006149
6150 if (!display->isVirtual()) {
6151 const auto dpi = display->refreshRateSelector().getActiveMode().modePtr->getDpi();
6152 displayProto->set_dpi_x(dpi.x);
6153 displayProto->set_dpi_y(dpi.y);
6154 }
6155
chaviw0a398992021-08-13 10:13:01 -05006156 LayerProtoHelper::writeSizeToProto(display->getWidth(), display->getHeight(),
6157 [&]() { return displayProto->mutable_size(); });
6158 LayerProtoHelper::writeToProto(display->getLayerStackSpaceRect(), [&]() {
6159 return displayProto->mutable_layer_stack_space_rect();
6160 });
6161 LayerProtoHelper::writeTransformToProto(display->getTransform(),
6162 displayProto->mutable_transform());
Vishnu Nair791d48a2021-12-02 16:55:13 -08006163 displayProto->set_is_virtual(display->isVirtual());
chaviw0a398992021-08-13 10:13:01 -05006164 }
Vishnu Nair81750622023-03-08 15:02:06 -08006165 return displays;
chaviw0a398992021-08-13 10:13:01 -05006166}
6167
Alec Mouri6b9e9912020-01-21 10:50:24 -08006168void SurfaceFlinger::dumpHwc(std::string& result) const {
6169 getHwComposer().dump(result);
6170}
6171
Vishnu Nair0f085c62019-08-30 08:49:12 -07006172void SurfaceFlinger::dumpOffscreenLayersProto(LayersProto& layersProto, uint32_t traceFlags) const {
6173 // Add a fake invisible root layer to the proto output and parent all the offscreen layers to
6174 // it.
6175 LayerProto* rootProto = layersProto.add_layers();
6176 const int32_t offscreenRootLayerId = INT32_MAX - 2;
6177 rootProto->set_id(offscreenRootLayerId);
6178 rootProto->set_name("Offscreen Root");
Vishnu Naird5aeb612019-09-20 14:39:39 -07006179 rootProto->set_parent(-1);
Vishnu Nair0f085c62019-08-30 08:49:12 -07006180
6181 for (Layer* offscreenLayer : mOffscreenLayers) {
6182 // Add layer as child of the fake root
6183 rootProto->add_children(offscreenLayer->sequence);
6184
6185 // Add layer
Vishnu Naird8f5e9f2022-02-03 10:23:28 -08006186 LayerProto* layerProto = offscreenLayer->writeToProto(layersProto, traceFlags);
Vishnu Nair0f085c62019-08-30 08:49:12 -07006187 layerProto->set_parent(offscreenRootLayerId);
Vishnu Nair0f085c62019-08-30 08:49:12 -07006188 }
6189}
6190
Vishnu Nair8406fd72019-07-30 11:29:31 -07006191LayersProto SurfaceFlinger::dumpProtoFromMainThread(uint32_t traceFlags) {
Dominik Laskowski756b7892021-08-04 12:53:59 -07006192 return mScheduler->schedule([=] { return dumpDrawingStateProto(traceFlags); }).get();
Vishnu Nair8406fd72019-07-30 11:29:31 -07006193}
6194
Vishnu Nair0f085c62019-08-30 08:49:12 -07006195void SurfaceFlinger::dumpOffscreenLayers(std::string& result) {
Dominik Laskowski756b7892021-08-04 12:53:59 -07006196 auto future = mScheduler->schedule([this] {
6197 std::string result;
6198 for (Layer* offscreenLayer : mOffscreenLayers) {
6199 offscreenLayer->traverse(LayerVector::StateSet::Drawing,
Vishnu Nair76554eb2022-12-09 03:38:36 +00006200 [&](Layer* layer) { layer->dumpOffscreenDebugInfo(result); });
Dominik Laskowski756b7892021-08-04 12:53:59 -07006201 }
6202 return result;
6203 });
6204
Vishnu Nair0f085c62019-08-30 08:49:12 -07006205 result.append("Offscreen Layers:\n");
Dominik Laskowski756b7892021-08-04 12:53:59 -07006206 result.append(future.get());
Vishnu Nair0f085c62019-08-30 08:49:12 -07006207}
6208
Vishnu Nair3cc15a42023-06-30 06:20:22 +00006209void SurfaceFlinger::dumpHwcLayersMinidumpLockedLegacy(std::string& result) const {
Ady Abraham5ad28d62022-08-11 11:26:57 -07006210 for (const auto& [token, display] : mDisplays) {
6211 const auto displayId = HalDisplayId::tryCast(display->getId());
6212 if (!displayId) {
6213 continue;
6214 }
6215
6216 StringAppendF(&result, "Display %s (%s) HWC layers:\n", to_string(*displayId).c_str(),
Dominik Laskowskie591b552022-09-09 10:44:56 -07006217 displayId == mActiveDisplayId ? "active" : "inactive");
Ady Abraham5ad28d62022-08-11 11:26:57 -07006218 Layer::miniDumpHeader(result);
6219
6220 const DisplayDevice& ref = *display;
Vishnu Nair3cc15a42023-06-30 06:20:22 +00006221 mDrawingState.traverseInZOrder([&](Layer* layer) { layer->miniDumpLegacy(result, ref); });
6222 result.append("\n");
6223 }
6224}
6225
6226void SurfaceFlinger::dumpHwcLayersMinidump(std::string& result) const {
6227 for (const auto& [token, display] : mDisplays) {
6228 const auto displayId = HalDisplayId::tryCast(display->getId());
6229 if (!displayId) {
6230 continue;
6231 }
6232
6233 StringAppendF(&result, "Display %s (%s) HWC layers:\n", to_string(*displayId).c_str(),
6234 displayId == mActiveDisplayId ? "active" : "inactive");
6235 Layer::miniDumpHeader(result);
6236
6237 const DisplayDevice& ref = *display;
6238 mLayerSnapshotBuilder.forEachVisibleSnapshot([&](const frontend::LayerSnapshot& snapshot) {
6239 if (!snapshot.hasSomethingToDraw() ||
6240 ref.getLayerStack() != snapshot.outputFilter.layerStack) {
6241 return;
6242 }
6243 auto it = mLegacyLayers.find(snapshot.sequence);
6244 LOG_ALWAYS_FATAL_IF(it == mLegacyLayers.end(), "Couldnt find layer object for %s",
6245 snapshot.getDebugString().c_str());
6246 it->second->miniDump(result, snapshot, ref);
6247 });
Ady Abraham5ad28d62022-08-11 11:26:57 -07006248 result.append("\n");
6249 }
6250}
6251
Alec Mouri67617332022-09-26 21:37:01 +00006252void SurfaceFlinger::dumpAllLocked(const DumpArgs& args, const std::string& compositionLayers,
6253 std::string& result) const {
Dominik Laskowskic2867142019-01-21 11:33:38 -08006254 const bool colorize = !args.empty() && args[0] == String16("--color");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02006255 Colorizer colorizer(colorize);
6256
Mathias Agopian82d7ab62012-01-19 18:34:40 -08006257 // figure out if we're stuck somewhere
6258 const nsecs_t now = systemTime();
Mathias Agopian82d7ab62012-01-19 18:34:40 -08006259 const nsecs_t inTransaction(mDebugInTransaction);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08006260 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
6261
6262 /*
Andy McFadden4803b742012-09-24 19:07:20 -07006263 * Dump library configuration.
6264 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02006265
6266 colorizer.bold(result);
Andy McFadden4803b742012-09-24 19:07:20 -07006267 result.append("Build configuration:");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02006268 colorizer.reset(result);
Andy McFadden4803b742012-09-24 19:07:20 -07006269 appendSfConfigString(result);
Andy McFadden4803b742012-09-24 19:07:20 -07006270 result.append("\n");
6271
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07006272 result.append("\nDisplay identification data:\n");
6273 dumpDisplayIdentificationData(result);
6274
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06006275 result.append("\nWide-Color information:\n");
6276 dumpWideColorInfo(result);
6277
Mathias Agopian3e25fd82013-04-22 17:52:16 +02006278 colorizer.bold(result);
Mathias Agopianca088332013-03-28 17:44:13 -07006279 result.append("Sync configuration: ");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02006280 colorizer.reset(result);
Mathias Agopianca088332013-03-28 17:44:13 -07006281 result.append(SyncFeatures::getInstance().toString());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08006282 result.append("\n\n");
Mathias Agopianca088332013-03-28 17:44:13 -07006283
Andy McFadden41d67d72014-04-25 16:58:34 -07006284 colorizer.bold(result);
Dominik Laskowski98041832019-08-01 18:35:59 -07006285 result.append("Scheduler:\n");
Andy McFadden41d67d72014-04-25 16:58:34 -07006286 colorizer.reset(result);
Dominik Laskowski03cfce82022-11-02 12:13:29 -04006287 dumpScheduler(result);
6288 dumpEvents(result);
6289 dumpVsync(result);
Dan Stozab90cf072015-03-05 11:05:59 -08006290 result.append("\n");
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08006291
Andy McFadden4803b742012-09-24 19:07:20 -07006292 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08006293 * Dump the visible layer list
6294 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02006295 colorizer.bold(result);
Vishnu Nair3cc15a42023-06-30 06:20:22 +00006296 StringAppendF(&result, "SurfaceFlinger New Frontend Enabled:%s\n",
6297 mLayerLifecycleManagerEnabled ? "true" : "false");
6298 StringAppendF(&result, "Active Layers - layers with client handles (count = %zu)\n",
6299 mNumLayers.load());
Mathias Agopian3e25fd82013-04-22 17:52:16 +02006300 colorizer.reset(result);
chaviw1d044282017-09-27 12:19:28 -07006301
Alec Mouri67617332022-09-26 21:37:01 +00006302 result.append(compositionLayers);
Lloyd Pique207def92019-02-28 16:09:52 -08006303
Mathias Agopian3e25fd82013-04-22 17:52:16 +02006304 colorizer.bold(result);
Yiwei Zhang5434a782018-12-05 18:06:32 -08006305 StringAppendF(&result, "Displays (%zu entries)\n", mDisplays.size());
Mathias Agopian3e25fd82013-04-22 17:52:16 +02006306 colorizer.reset(result);
Dominik Laskowski0acc3842022-04-07 11:23:42 -07006307 dumpDisplays(result);
6308 dumpCompositionDisplays(result);
6309 result.push_back('\n');
Lloyd Piquec3cb7292019-05-17 15:25:14 -07006310
6311 mCompositionEngine->dump(result);
6312
6313 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08006314 * Dump SurfaceFlinger global state
6315 */
6316
Mathias Agopian3e25fd82013-04-22 17:52:16 +02006317 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02006318 result.append("SurfaceFlinger global state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02006319 colorizer.reset(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08006320
Lloyd Piqueb97e04f2018-10-18 17:07:05 -07006321 getRenderEngine().dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08006322
Robert Carrbeba6f02021-02-10 21:06:27 -08006323 result.append("ClientCache state:\n");
6324 ClientCache::getInstance().dump(result);
Ady Abrahama3b08ef2019-07-15 18:43:10 -07006325 DebugEGLImageTracker::getInstance()->dump(result);
6326
Dominik Laskowski075d3172018-05-24 15:50:06 -07006327 if (const auto display = getDefaultDisplayDeviceLocked()) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07006328 display->getCompositionDisplay()->getState().undefinedRegion.dump(result,
6329 "undefinedRegion");
Dominik Laskowski718f9602019-11-09 20:01:35 -08006330 StringAppendF(&result, " orientation=%s, isPoweredOn=%d\n",
6331 toCString(display->getOrientation()), display->isPoweredOn());
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08006332 }
Carlos Martinez Romero779dc1f2022-10-27 23:23:30 +00006333 StringAppendF(&result, " transaction-flags : %08x\n", mTransactionFlags.load());
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07006334
Marin Shalamanov045b7002021-01-07 16:56:24 +01006335 if (const auto display = getDefaultDisplayDeviceLocked()) {
Marin Shalamanov9afcbd82020-08-19 12:34:59 +02006336 std::string fps, xDpi, yDpi;
Ady Abrahamace3d052022-11-17 16:25:05 -08006337 if (const auto activeModePtr =
6338 display->refreshRateSelector().getActiveMode().modePtr.get()) {
Dominik Laskowski02bb2072022-08-26 15:02:52 -07006339 fps = to_string(activeModePtr->getFps());
Dominik Laskowskib0054a22022-03-03 09:03:06 -08006340
Dominik Laskowski02bb2072022-08-26 15:02:52 -07006341 const auto dpi = activeModePtr->getDpi();
Dominik Laskowskib0054a22022-03-03 09:03:06 -08006342 xDpi = base::StringPrintf("%.2f", dpi.x);
6343 yDpi = base::StringPrintf("%.2f", dpi.y);
Marin Shalamanov9afcbd82020-08-19 12:34:59 +02006344 } else {
6345 fps = "unknown";
6346 xDpi = "unknown";
6347 yDpi = "unknown";
6348 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08006349 StringAppendF(&result,
Marin Shalamanov9afcbd82020-08-19 12:34:59 +02006350 " refresh-rate : %s\n"
6351 " x-dpi : %s\n"
6352 " y-dpi : %s\n",
6353 fps.c_str(), xDpi.c_str(), yDpi.c_str());
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07006354 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08006355
Yiwei Zhang5434a782018-12-05 18:06:32 -08006356 StringAppendF(&result, " transaction time: %f us\n", inTransactionDuration / 1000.0);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08006357
Dan Stozae22aec72016-08-01 13:20:59 -07006358 /*
Yichi Chenadc69612018-09-15 14:51:18 +08006359 * Tracing state
6360 */
Vishnu Nair00b90132021-11-05 14:03:40 -07006361 mLayerTracing.dump(result);
Dominik Laskowski46471e62022-01-14 15:34:03 -08006362
6363 result.append("\nTransaction tracing: ");
6364 if (mTransactionTracing) {
6365 result.append("enabled\n");
6366 mTransactionTracing->dump(result);
6367 } else {
6368 result.append("disabled\n");
6369 }
6370 result.push_back('\n');
Yichi Chenadc69612018-09-15 14:51:18 +08006371
Vishnu Nair3cc15a42023-06-30 06:20:22 +00006372 if (mLegacyFrontEndEnabled) {
6373 dumpHwcLayersMinidumpLockedLegacy(result);
6374 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08006375
Ady Abraham2790e9f2021-04-28 13:14:20 -07006376 {
6377 DumpArgs plannerArgs;
6378 plannerArgs.add(); // first argument is ignored
6379 plannerArgs.add(String16("--layers"));
6380 dumpPlannerInfo(plannerArgs, result);
6381 }
6382
Mathias Agopian82d7ab62012-01-19 18:34:40 -08006383 /*
6384 * Dump HWComposer state
6385 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02006386 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02006387 result.append("h/w composer state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02006388 colorizer.reset(result);
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07006389 const bool hwcDisabled = mDebugDisableHWC || mDebugFlashDelay;
Yiwei Zhang5434a782018-12-05 18:06:32 -08006390 StringAppendF(&result, " h/w composer %s\n", hwcDisabled ? "disabled" : "enabled");
Ady Abrahamc4acf512022-02-18 17:11:59 -08006391 dumpHwc(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08006392
6393 /*
6394 * Dump gralloc state
6395 */
6396 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
6397 alloc.dump(result);
Karthik Ravi Shankar171155a2017-06-28 15:40:24 -07006398
rnleea2ecd832021-07-29 13:58:30 -07006399 /*
6400 * Dump flag/property manager state
6401 */
Robert Carr9b623c32022-03-21 15:55:22 -07006402 mFlagManager.dump(result);
rnleea2ecd832021-07-29 13:58:30 -07006403
Yiwei Zhang7eb58b72019-04-22 19:00:02 -07006404 result.append(mTimeStats->miniDump());
6405 result.append("\n");
Patrick Williamsd828f302023-04-28 17:52:08 -05006406
6407 result.append("Window Infos:\n");
Patrick Williams6681c022023-05-15 13:38:16 -05006408 auto windowInfosDebug = mWindowInfosListenerInvoker->getDebugInfo();
6409 StringAppendF(&result, " max send vsync id: %" PRId64 "\n",
6410 ftl::to_underlying(windowInfosDebug.maxSendDelayVsyncId));
6411 StringAppendF(&result, " max send delay (ns): %" PRId64 " ns\n",
6412 windowInfosDebug.maxSendDelayDuration);
Patrick Williamsacd22582023-07-12 13:47:28 -05006413 StringAppendF(&result, " unsent messages: %zu\n", windowInfosDebug.pendingMessageCount);
Patrick Williamsd828f302023-04-28 17:52:08 -05006414 result.append("\n");
Mathias Agopian82d7ab62012-01-19 18:34:40 -08006415}
6416
chaviw17ac24b2021-01-28 18:50:05 -08006417mat4 SurfaceFlinger::calculateColorMatrix(float saturation) {
6418 if (saturation == 1) {
6419 return mat4();
Chia-I Wu28f320b2018-05-03 11:02:56 -07006420 }
6421
chaviw17ac24b2021-01-28 18:50:05 -08006422 float3 luminance{0.213f, 0.715f, 0.072f};
6423 luminance *= 1.0f - saturation;
6424 mat4 saturationMatrix = mat4(vec4{luminance.r + saturation, luminance.r, luminance.r, 0.0f},
6425 vec4{luminance.g, luminance.g + saturation, luminance.g, 0.0f},
6426 vec4{luminance.b, luminance.b, luminance.b + saturation, 0.0f},
6427 vec4{0.0f, 0.0f, 0.0f, 1.0f});
6428 return saturationMatrix;
6429}
6430
6431void SurfaceFlinger::updateColorMatrixLocked() {
6432 mat4 colorMatrix =
6433 mClientColorMatrix * calculateColorMatrix(mGlobalSaturationFactor) * mDaltonizer();
6434
Chia-I Wu28f320b2018-05-03 11:02:56 -07006435 if (mCurrentState.colorMatrix != colorMatrix) {
6436 mCurrentState.colorMatrix = colorMatrix;
6437 mCurrentState.colorMatrixChanged = true;
6438 setTransactionFlags(eTransactionNeeded);
6439 }
6440}
6441
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07006442status_t SurfaceFlinger::CheckTransactCodeCredentials(uint32_t code) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00006443#pragma clang diagnostic push
6444#pragma clang diagnostic error "-Wswitch-enum"
6445 switch (static_cast<ISurfaceComposerTag>(code)) {
6446 // These methods should at minimum make sure that the client requested
6447 // access to SF.
Ana Krulec13be8ad2018-08-21 02:43:56 +00006448 case GET_HDR_CAPABILITIES:
Galia Peycheva5492cb52019-10-30 14:13:16 +01006449 case GET_AUTO_LOW_LATENCY_MODE_SUPPORT:
Galia Peycheva5492cb52019-10-30 14:13:16 +01006450 case GET_GAME_CONTENT_TYPE_SUPPORT:
Steven Thomasd4071902020-03-24 16:02:53 -07006451 case ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN: {
Marin Shalamanovfa39ee72021-11-01 14:04:27 +01006452 // OVERRIDE_HDR_TYPES is used by CTS tests, which acquire the necessary
6453 // permission dynamically. Don't use the permission cache for this check.
6454 bool usePermissionCache = code != OVERRIDE_HDR_TYPES;
Steven Thomasd4071902020-03-24 16:02:53 -07006455 if (!callingThreadHasUnscopedSurfaceFlingerAccess(usePermissionCache)) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07006456 IPCThreadState* ipc = IPCThreadState::self();
6457 ALOGE("Permission Denial: can't access SurfaceFlinger pid=%d, uid=%d",
6458 ipc->getCallingPid(), ipc->getCallingUid());
Mathias Agopian375f5632009-06-15 18:24:59 -07006459 return PERMISSION_DENIED;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08006460 }
Robert Carr1db73f62016-12-21 12:58:51 -08006461 return OK;
6462 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00006463 // The following calls are currently used by clients that do not
6464 // request necessary permissions. However, they do not expose any secret
6465 // information, so it is OK to pass them.
Peiyong Lind1fedb42019-03-11 17:48:41 -07006466 case GET_ACTIVE_COLOR_MODE:
Marin Shalamanova7fe3042021-01-29 21:02:08 +01006467 case GET_ACTIVE_DISPLAY_MODE:
Ana Krulec13be8ad2018-08-21 02:43:56 +00006468 case GET_DISPLAY_COLOR_MODES:
Marin Shalamanova7fe3042021-01-29 21:02:08 +01006469 case GET_DISPLAY_MODES:
Ana Krulec13be8ad2018-08-21 02:43:56 +00006470 // Calling setTransactionState is safe, because you need to have been
6471 // granted a reference to Client* and Handle* to do anything with it.
Huihong Luod3d8f8e2022-03-08 14:48:46 -08006472 case SET_TRANSACTION_STATE: {
Ady Abraham564f9de2021-02-03 18:34:33 -08006473 // This is not sensitive information, so should not require permission control.
Ana Krulec13be8ad2018-08-21 02:43:56 +00006474 return OK;
6475 }
Huihong Luo1b0c49f2022-03-15 19:18:21 -07006476 case BOOT_FINISHED:
6477 // Used by apps to hook Choreographer to SurfaceFlinger.
6478 case CREATE_DISPLAY_EVENT_CONNECTION:
Huihong Luod3d8f8e2022-03-08 14:48:46 -08006479 case CREATE_CONNECTION:
Huihong Luo07e72362022-02-14 14:26:04 -08006480 case CREATE_DISPLAY:
6481 case DESTROY_DISPLAY:
6482 case GET_PRIMARY_PHYSICAL_DISPLAY_ID:
6483 case GET_PHYSICAL_DISPLAY_IDS:
6484 case GET_PHYSICAL_DISPLAY_TOKEN:
Huihong Luo3bdef862022-03-03 11:57:19 -08006485 case AUTHENTICATE_SURFACE:
Huihong Luo37396db2022-02-15 10:43:00 -08006486 case SET_POWER_MODE:
Huihong Luo0a81aa32022-02-22 16:02:36 -08006487 case GET_SUPPORTED_FRAME_TIMESTAMPS:
Huihong Luoaa7fc2e2022-02-15 10:43:00 -08006488 case GET_DISPLAY_STATE:
6489 case GET_DISPLAY_STATS:
Huihong Luoa79ddf42022-02-17 00:01:38 -08006490 case GET_STATIC_DISPLAY_INFO:
Huihong Luo38603fd2022-02-21 14:32:54 -08006491 case GET_DYNAMIC_DISPLAY_INFO:
Huihong Luoca3d9a42022-02-22 11:07:34 -08006492 case GET_DISPLAY_NATIVE_PRIMARIES:
6493 case SET_ACTIVE_COLOR_MODE:
6494 case SET_BOOT_DISPLAY_MODE:
Huihong Luo37396db2022-02-15 10:43:00 -08006495 case CLEAR_BOOT_DISPLAY_MODE:
6496 case GET_BOOT_DISPLAY_MODE_SUPPORT:
6497 case SET_AUTO_LOW_LATENCY_MODE:
6498 case SET_GAME_CONTENT_TYPE:
Huihong Luof5029222021-12-16 14:33:46 -08006499 case CAPTURE_LAYERS:
6500 case CAPTURE_DISPLAY:
6501 case CAPTURE_DISPLAY_BY_ID:
Huihong Luo4ed1c912022-02-22 14:30:01 -08006502 case CLEAR_ANIMATION_FRAME_STATS:
6503 case GET_ANIMATION_FRAME_STATS:
Huihong Luo05539a12022-02-23 10:29:40 -08006504 case OVERRIDE_HDR_TYPES:
6505 case ON_PULL_ATOM:
6506 case ENABLE_VSYNC_INJECTIONS:
6507 case INJECT_VSYNC:
6508 case GET_LAYER_DEBUG_INFO:
6509 case GET_COLOR_MANAGEMENT:
6510 case GET_COMPOSITION_PREFERENCE:
6511 case GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES:
6512 case SET_DISPLAY_CONTENT_SAMPLING_ENABLED:
Huihong Luo3bdef862022-03-03 11:57:19 -08006513 case GET_DISPLAYED_CONTENT_SAMPLE:
Huihong Luo05539a12022-02-23 10:29:40 -08006514 case GET_PROTECTED_CONTENT_SUPPORT:
Huihong Luo37396db2022-02-15 10:43:00 -08006515 case IS_WIDE_COLOR_DISPLAY:
Huihong Luo02186fb2022-02-23 14:21:54 -08006516 case ADD_REGION_SAMPLING_LISTENER:
6517 case REMOVE_REGION_SAMPLING_LISTENER:
6518 case ADD_FPS_LISTENER:
6519 case REMOVE_FPS_LISTENER:
6520 case ADD_TUNNEL_MODE_ENABLED_LISTENER:
6521 case REMOVE_TUNNEL_MODE_ENABLED_LISTENER:
6522 case ADD_WINDOW_INFOS_LISTENER:
6523 case REMOVE_WINDOW_INFOS_LISTENER:
6524 case SET_DESIRED_DISPLAY_MODE_SPECS:
6525 case GET_DESIRED_DISPLAY_MODE_SPECS:
Huihong Luo37396db2022-02-15 10:43:00 -08006526 case GET_DISPLAY_BRIGHTNESS_SUPPORT:
6527 case SET_DISPLAY_BRIGHTNESS:
6528 case ADD_HDR_LAYER_INFO_LISTENER:
6529 case REMOVE_HDR_LAYER_INFO_LISTENER:
6530 case NOTIFY_POWER_BOOST:
Huihong Luo3bdef862022-03-03 11:57:19 -08006531 case SET_GLOBAL_SHADOW_SETTINGS:
6532 case GET_DISPLAY_DECORATION_SUPPORT:
6533 case SET_FRAME_RATE:
6534 case SET_OVERRIDE_FRAME_RATE:
6535 case SET_FRAME_TIMELINE_INFO:
Huihong Luo02186fb2022-02-23 14:21:54 -08006536 case ADD_TRANSACTION_TRACE_LISTENER:
6537 case GET_GPU_CONTEXT_PRIORITY:
6538 case GET_MAX_ACQUIRED_BUFFER_COUNT:
Huihong Luo07e72362022-02-14 14:26:04 -08006539 LOG_FATAL("Deprecated opcode: %d, migrated to AIDL", code);
Huihong Luof5029222021-12-16 14:33:46 -08006540 return PERMISSION_DENIED;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08006541 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00006542
6543 // These codes are used for the IBinder protocol to either interrogate the recipient
6544 // side of the transaction for its canonical interface descriptor or to dump its state.
6545 // We let them pass by default.
6546 if (code == IBinder::INTERFACE_TRANSACTION || code == IBinder::DUMP_TRANSACTION ||
6547 code == IBinder::PING_TRANSACTION || code == IBinder::SHELL_COMMAND_TRANSACTION ||
6548 code == IBinder::SYSPROPS_TRANSACTION) {
6549 return OK;
6550 }
Brian Johnson51d8d5d2023-07-28 10:18:47 -07006551 // Numbers from 1000 to 1044 are currently used for backdoors. The code
Ana Krulec13be8ad2018-08-21 02:43:56 +00006552 // in onTransact verifies that the user is root, and has access to use SF.
Brian Johnson51d8d5d2023-07-28 10:18:47 -07006553 if (code >= 1000 && code <= 1044) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00006554 ALOGV("Accessing SurfaceFlinger through backdoor code: %u", code);
6555 return OK;
6556 }
6557 ALOGE("Permission Denial: SurfaceFlinger did not recognize request code: %u", code);
6558 return PERMISSION_DENIED;
6559#pragma clang diagnostic pop
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07006560}
6561
Ana Krulec13be8ad2018-08-21 02:43:56 +00006562status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
6563 uint32_t flags) {
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07006564 if (const status_t error = CheckTransactCodeCredentials(code); error != OK) {
6565 return error;
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07006566 }
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07006567
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08006568 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
6569 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
Mathias Agopianb8a55602009-06-26 19:06:36 -07006570 CHECK_INTERFACE(ISurfaceComposer, data, reply);
Romain Guy8c6bbd62017-06-05 13:51:43 -07006571 IPCThreadState* ipc = IPCThreadState::self();
6572 const int uid = ipc->getCallingUid();
6573 if (CC_UNLIKELY(uid != AID_SYSTEM
6574 && !PermissionCache::checkCallingPermission(sHardwareTest))) {
Mathias Agopian375f5632009-06-15 18:24:59 -07006575 const int pid = ipc->getCallingPid();
Steve Blocke6f43dd2012-01-06 19:20:56 +00006576 ALOGE("Permission Denial: "
Mathias Agopian375f5632009-06-15 18:24:59 -07006577 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08006578 return PERMISSION_DENIED;
6579 }
6580 int n;
6581 switch (code) {
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07006582 case 1000: // Unused.
6583 case 1001:
6584 return NAME_NOT_FOUND;
6585 case 1002: // Toggle flashing on surface damage.
6586 if (const int delay = data.readInt32(); delay > 0) {
6587 mDebugFlashDelay = delay;
6588 } else {
6589 mDebugFlashDelay = mDebugFlashDelay ? 0 : 1;
6590 }
6591 scheduleRepaint();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08006592 return NO_ERROR;
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07006593 case 1004: // Force composite ahead of next VSYNC.
Dominik Laskowski46f3e3b2021-08-10 11:44:24 -07006594 case 1006:
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07006595 scheduleComposite(FrameHint::kActive);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08006596 return NO_ERROR;
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07006597 case 1005: { // Force commit ahead of next VSYNC.
6598 Mutex::Autolock lock(mStateLock);
6599 setTransactionFlags(eTransactionNeeded | eDisplayTransactionNeeded |
6600 eTraversalNeeded);
Mathias Agopiancbb288b2009-09-07 16:32:45 -07006601 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08006602 }
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07006603 case 1007: // Unused.
6604 return NAME_NOT_FOUND;
6605 case 1008: // Toggle forced GPU composition.
6606 mDebugDisableHWC = data.readInt32() != 0;
6607 scheduleRepaint();
Mathias Agopian53331da2011-08-22 21:44:41 -07006608 return NO_ERROR;
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07006609 case 1009: // Toggle use of transform hint.
6610 mDebugDisableTransformHint = data.readInt32() != 0;
6611 scheduleRepaint();
Mathias Agopiana4583642011-08-23 18:03:18 -07006612 return NO_ERROR;
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07006613 case 1010: // Interrogate.
Mathias Agopian01b76682009-04-16 20:04:08 -07006614 reply->writeInt32(0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08006615 reply->writeInt32(0);
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07006616 reply->writeInt32(mDebugFlashDelay);
Mathias Agopianb9494d52012-04-18 02:28:45 -07006617 reply->writeInt32(0);
Dianne Hackborn12839be2012-02-06 21:21:05 -08006618 reply->writeInt32(mDebugDisableHWC);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08006619 return NO_ERROR;
Dominik Laskowski8792c112022-07-12 09:03:39 -07006620 case 1013: // Unused.
6621 return NAME_NOT_FOUND;
Mathias Agopianff2ed702013-09-01 21:36:12 -07006622 case 1014: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07006623 Mutex::Autolock _l(mStateLock);
Mathias Agopianff2ed702013-09-01 21:36:12 -07006624 // daltonize
6625 n = data.readInt32();
6626 switch (n % 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07006627 case 1:
6628 mDaltonizer.setType(ColorBlindnessType::Protanomaly);
6629 break;
6630 case 2:
6631 mDaltonizer.setType(ColorBlindnessType::Deuteranomaly);
6632 break;
6633 case 3:
6634 mDaltonizer.setType(ColorBlindnessType::Tritanomaly);
6635 break;
6636 default:
6637 mDaltonizer.setType(ColorBlindnessType::None);
6638 break;
Mathias Agopianff2ed702013-09-01 21:36:12 -07006639 }
6640 if (n >= 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07006641 mDaltonizer.setMode(ColorBlindnessMode::Correction);
Mathias Agopianff2ed702013-09-01 21:36:12 -07006642 } else {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07006643 mDaltonizer.setMode(ColorBlindnessMode::Simulation);
Mathias Agopianff2ed702013-09-01 21:36:12 -07006644 }
Chia-I Wu28f320b2018-05-03 11:02:56 -07006645
6646 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07006647 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08006648 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07006649 case 1015: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07006650 Mutex::Autolock _l(mStateLock);
Alan Viverette9c5a3332013-09-12 20:04:35 -07006651 // apply a color matrix
6652 n = data.readInt32();
Alan Viverette9c5a3332013-09-12 20:04:35 -07006653 if (n) {
Romain Guy0147a172017-06-01 13:53:56 -07006654 // color matrix is sent as a column-major mat4 matrix
Alan Viverette794c5ba2013-10-03 16:40:52 -07006655 for (size_t i = 0 ; i < 4; i++) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07006656 for (size_t j = 0; j < 4; j++) {
Chia-I Wu28f320b2018-05-03 11:02:56 -07006657 mClientColorMatrix[i][j] = data.readFloat();
Dan Stoza9f26a9c2016-06-22 14:51:09 -07006658 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07006659 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07006660 } else {
Chia-I Wu28f320b2018-05-03 11:02:56 -07006661 mClientColorMatrix = mat4();
Alan Viverette9c5a3332013-09-12 20:04:35 -07006662 }
Romain Guy88d37dd2017-05-26 17:57:05 -07006663
6664 // Check that supplied matrix's last row is {0,0,0,1} so we can avoid
6665 // the division by w in the fragment shader
Chia-I Wu28f320b2018-05-03 11:02:56 -07006666 float4 lastRow(transpose(mClientColorMatrix)[3]);
Romain Guy88d37dd2017-05-26 17:57:05 -07006667 if (any(greaterThan(abs(lastRow - float4{0, 0, 0, 1}), float4{1e-4f}))) {
6668 ALOGE("The color transform's last row must be (0, 0, 0, 1)");
6669 }
6670
Chia-I Wu28f320b2018-05-03 11:02:56 -07006671 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07006672 return NO_ERROR;
6673 }
Dominik Laskowski8d32ddc2019-08-07 11:25:35 -07006674 case 1016: { // Unused.
6675 return NAME_NOT_FOUND;
Ruchi Kandoif52b3c82014-04-24 16:42:35 -07006676 }
Dan Stozaee44edd2015-03-23 15:50:23 -07006677 case 1017: {
6678 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07006679 mForceFullDamage = n != 0;
Dan Stozaee44edd2015-03-23 15:50:23 -07006680 return NO_ERROR;
6681 }
Ady Abraham9c53ee72020-07-22 21:16:18 -07006682 case 1018: { // Modify Choreographer's duration
Dan Stozadb4ac3c2015-04-14 11:34:01 -07006683 n = data.readInt32();
Ady Abraham9c53ee72020-07-22 21:16:18 -07006684 mScheduler->setDuration(mAppConnectionHandle, std::chrono::nanoseconds(n), 0ns);
Dan Stozadb4ac3c2015-04-14 11:34:01 -07006685 return NO_ERROR;
6686 }
Ady Abraham9c53ee72020-07-22 21:16:18 -07006687 case 1019: { // Modify SurfaceFlinger's duration
Dan Stozadb4ac3c2015-04-14 11:34:01 -07006688 n = data.readInt32();
Ady Abraham9c53ee72020-07-22 21:16:18 -07006689 mScheduler->setDuration(mSfConnectionHandle, std::chrono::nanoseconds(n), 0ns);
Dan Stozadb4ac3c2015-04-14 11:34:01 -07006690 return NO_ERROR;
6691 }
Huihong Luoab8ffef2022-08-18 13:02:26 -07006692 case 1020: { // Unused
6693 return NAME_NOT_FOUND;
Irvel468051e2016-06-13 16:44:44 -07006694 }
Dan Stoza8cf150a2016-08-02 10:27:31 -07006695 case 1021: { // Disable HWC virtual displays
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08006696 const bool enable = data.readInt32() != 0;
Dominik Laskowski756b7892021-08-04 12:53:59 -07006697 static_cast<void>(
6698 mScheduler->schedule([this, enable] { enableHalVirtualDisplays(enable); }));
Dan Stoza8cf150a2016-08-02 10:27:31 -07006699 return NO_ERROR;
6700 }
Romain Guy0147a172017-06-01 13:53:56 -07006701 case 1022: { // Set saturation boost
Chia-I Wu28f320b2018-05-03 11:02:56 -07006702 Mutex::Autolock _l(mStateLock);
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08006703 mGlobalSaturationFactor = std::max(0.0f, std::min(data.readFloat(), 2.0f));
Romain Guy0147a172017-06-01 13:53:56 -07006704
Chia-I Wu28f320b2018-05-03 11:02:56 -07006705 updateColorMatrixLocked();
Romain Guy0147a172017-06-01 13:53:56 -07006706 return NO_ERROR;
6707 }
Dominik Laskowski788945b2022-08-30 12:10:56 -07006708 case 1023: { // Set color mode.
Chia-I Wu0d711262018-05-21 15:19:35 -07006709 mDisplayColorSetting = static_cast<DisplayColorSetting>(data.readInt32());
Dominik Laskowski788945b2022-08-30 12:10:56 -07006710
6711 if (int32_t colorMode; data.readInt32(&colorMode) == NO_ERROR) {
6712 mForceColorMode = static_cast<ui::ColorMode>(colorMode);
Daniel Solomon7c7ede22019-07-11 16:35:40 -07006713 }
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07006714 scheduleRepaint();
Romain Guy54f154a2017-10-24 21:40:32 +01006715 return NO_ERROR;
6716 }
Peiyong Lin4bac91c2018-10-25 09:48:33 -07006717 // Deprecate, use 1030 to check whether the device is color managed.
6718 case 1024: {
6719 return NAME_NOT_FOUND;
Romain Guy54f154a2017-10-24 21:40:32 +01006720 }
Vishnu Nair87704c92018-01-08 15:32:57 -08006721 case 1025: { // Set layer tracing
Adrian Roos1e1a1282017-11-01 19:05:31 +01006722 n = data.readInt32();
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07006723 bool tracingEnabledChanged;
Vishnu Naird8f5e9f2022-02-03 10:23:28 -08006724 if (n == 1) {
6725 int64_t fixedStartingTime = data.readInt64();
Yichi Chenadc69612018-09-15 14:51:18 +08006726 ALOGD("LayerTracing enabled");
Vishnu Nair00b90132021-11-05 14:03:40 -07006727 tracingEnabledChanged = mLayerTracing.enable();
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07006728 if (tracingEnabledChanged) {
Dominik Laskowski16a345b2023-04-27 17:07:33 -04006729 const TimePoint startingTime = fixedStartingTime
6730 ? TimePoint::fromNs(fixedStartingTime)
6731 : TimePoint::now();
6732
Vishnu Nairb64a3b42022-01-13 15:29:32 -08006733 mScheduler
Dominik Laskowski16a345b2023-04-27 17:07:33 -04006734 ->schedule([this, startingTime]() FTL_FAKE_GUARD(
6735 mStateLock) FTL_FAKE_GUARD(kMainThreadContext) {
6736 constexpr bool kVisibleRegionDirty = true;
6737 addToLayerTracing(kVisibleRegionDirty, startingTime,
6738 mLastCommittedVsyncId);
Vishnu Nairb64a3b42022-01-13 15:29:32 -08006739 })
Dominik Laskowski756b7892021-08-04 12:53:59 -07006740 .wait();
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07006741 }
Vishnu Naird8f5e9f2022-02-03 10:23:28 -08006742 } else if (n == 2) {
6743 std::string filename = std::string(data.readCString());
6744 ALOGD("LayerTracing disabled. Trace wrote to %s", filename.c_str());
6745 tracingEnabledChanged = mLayerTracing.disable(filename.c_str());
Adrian Roos1e1a1282017-11-01 19:05:31 +01006746 } else {
Yichi Chenadc69612018-09-15 14:51:18 +08006747 ALOGD("LayerTracing disabled");
Vishnu Nair00b90132021-11-05 14:03:40 -07006748 tracingEnabledChanged = mLayerTracing.disable();
Adrian Roos1e1a1282017-11-01 19:05:31 +01006749 }
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07006750 mTracingEnabledChanged = tracingEnabledChanged;
6751 reply->writeInt32(NO_ERROR);
Adrian Roos1e1a1282017-11-01 19:05:31 +01006752 return NO_ERROR;
6753 }
Vishnu Nair87704c92018-01-08 15:32:57 -08006754 case 1026: { // Get layer tracing status
Vishnu Nair00b90132021-11-05 14:03:40 -07006755 reply->writeBool(mLayerTracing.isEnabled());
Vishnu Nair87704c92018-01-08 15:32:57 -08006756 return NO_ERROR;
6757 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08006758 // Is a DisplayColorSetting supported?
6759 case 1027: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07006760 const auto display = getDefaultDisplayDevice();
6761 if (!display) {
Chia-I Wu0d711262018-05-21 15:19:35 -07006762 return NAME_NOT_FOUND;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08006763 }
Chia-I Wu0d711262018-05-21 15:19:35 -07006764
6765 DisplayColorSetting setting = static_cast<DisplayColorSetting>(data.readInt32());
6766 switch (setting) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -08006767 case DisplayColorSetting::kManaged:
Peiyong Lin13effd12018-07-24 17:01:47 -07006768 reply->writeBool(useColorManagement);
Chia-I Wu0d711262018-05-21 15:19:35 -07006769 break;
Lloyd Pique6a3b4462019-03-07 20:58:12 -08006770 case DisplayColorSetting::kUnmanaged:
Chia-I Wu0d711262018-05-21 15:19:35 -07006771 reply->writeBool(true);
6772 break;
Lloyd Pique6a3b4462019-03-07 20:58:12 -08006773 case DisplayColorSetting::kEnhanced:
Dominik Laskowskieecd6592018-05-29 10:25:41 -07006774 reply->writeBool(display->hasRenderIntent(RenderIntent::ENHANCE));
Chia-I Wu0d711262018-05-21 15:19:35 -07006775 break;
6776 default: // vendor display color setting
Dominik Laskowskieecd6592018-05-29 10:25:41 -07006777 reply->writeBool(
6778 display->hasRenderIntent(static_cast<RenderIntent>(setting)));
Chia-I Wu0d711262018-05-21 15:19:35 -07006779 break;
6780 }
6781 return NO_ERROR;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08006782 }
Alec Mouri9c58bcd2020-09-09 18:57:07 -07006783 case 1028: { // Unused.
6784 return NAME_NOT_FOUND;
Steven Thomas97f1f4c2018-06-01 12:04:16 -07006785 }
Nataniel Borges2b796da2019-02-15 13:32:18 -08006786 // Set buffer size for SF tracing (value in KB)
6787 case 1029: {
6788 n = data.readInt32();
6789 if (n <= 0 || n > MAX_TRACING_MEMORY) {
6790 ALOGW("Invalid buffer size: %d KB", n);
6791 reply->writeInt32(BAD_VALUE);
6792 return BAD_VALUE;
6793 }
6794
6795 ALOGD("Updating trace buffer to %d KB", n);
Vishnu Nair00b90132021-11-05 14:03:40 -07006796 mLayerTracing.setBufferSize(n * 1024);
Nataniel Borges2b796da2019-02-15 13:32:18 -08006797 reply->writeInt32(NO_ERROR);
6798 return NO_ERROR;
6799 }
Peiyong Lin13effd12018-07-24 17:01:47 -07006800 // Is device color managed?
6801 case 1030: {
6802 reply->writeBool(useColorManagement);
6803 return NO_ERROR;
6804 }
Peiyong Lin9d846a52018-11-05 13:18:20 -08006805 // Override default composition data space
6806 // adb shell service call SurfaceFlinger 1031 i32 1 DATASPACE_NUMBER DATASPACE_NUMBER \
6807 // && adb shell stop zygote && adb shell start zygote
6808 // to restore: adb shell service call SurfaceFlinger 1031 i32 0 && \
6809 // adb shell stop zygote && adb shell start zygote
6810 case 1031: {
6811 Mutex::Autolock _l(mStateLock);
6812 n = data.readInt32();
6813 if (n) {
6814 n = data.readInt32();
6815 if (n) {
6816 Dataspace dataspace = static_cast<Dataspace>(n);
6817 if (!validateCompositionDataspace(dataspace)) {
6818 return BAD_VALUE;
6819 }
Lloyd Pique30db6402023-06-26 18:56:51 +00006820 mDefaultCompositionDataspace = dataspace;
Peiyong Lin9d846a52018-11-05 13:18:20 -08006821 }
6822 n = data.readInt32();
6823 if (n) {
6824 Dataspace dataspace = static_cast<Dataspace>(n);
6825 if (!validateCompositionDataspace(dataspace)) {
6826 return BAD_VALUE;
6827 }
Lloyd Pique30db6402023-06-26 18:56:51 +00006828 mWideColorGamutCompositionDataspace = dataspace;
Peiyong Lin9d846a52018-11-05 13:18:20 -08006829 }
6830 } else {
Lloyd Pique30db6402023-06-26 18:56:51 +00006831 // restore composition data space.
6832 mDefaultCompositionDataspace = defaultCompositionDataspace;
6833 mWideColorGamutCompositionDataspace = wideColorGamutCompositionDataspace;
Peiyong Lin9d846a52018-11-05 13:18:20 -08006834 }
6835 return NO_ERROR;
6836 }
Vishnu Nair9245d3b2019-03-22 13:38:56 -07006837 // Set trace flags
6838 case 1033: {
6839 n = data.readUint32();
6840 ALOGD("Updating trace flags to 0x%x", n);
Vishnu Nair00b90132021-11-05 14:03:40 -07006841 mLayerTracing.setTraceFlags(n);
Vishnu Nair9245d3b2019-03-22 13:38:56 -07006842 reply->writeInt32(NO_ERROR);
6843 return NO_ERROR;
6844 }
Ady Abraham03b02dd2019-03-21 15:40:11 -07006845 case 1034: {
Dominik Laskowski02bb2072022-08-26 15:02:52 -07006846 auto future = mScheduler->schedule(
6847 [&]() FTL_FAKE_GUARD(mStateLock) FTL_FAKE_GUARD(kMainThreadContext) {
6848 switch (n = data.readInt32()) {
6849 case 0:
6850 case 1:
6851 enableRefreshRateOverlay(static_cast<bool>(n));
6852 break;
6853 default:
6854 reply->writeBool(isRefreshRateOverlayEnabled());
6855 }
6856 });
Dominik Laskowski756b7892021-08-04 12:53:59 -07006857
6858 future.wait();
Ady Abraham03b02dd2019-03-21 15:40:11 -07006859 return NO_ERROR;
6860 }
Ady Abraham34392f72019-04-10 11:29:27 -07006861 case 1035: {
Marin Shalamanov5801c942020-12-17 17:00:13 +01006862 const int modeId = data.readInt32();
Marin Shalamanov5801c942020-12-17 17:00:13 +01006863
Dominik Laskowskif1833852021-03-23 15:06:50 -07006864 const auto display = [&]() -> sp<IBinder> {
6865 uint64_t value;
6866 if (data.readUint64(&value) != NO_ERROR) {
Ady Abrahamed3290f2021-05-17 15:12:14 -07006867 return getDefaultDisplayDevice()->getDisplayToken().promote();
Ady Abrahamfb853662021-04-09 11:46:40 -07006868 }
6869
Dominik Laskowskif1833852021-03-23 15:06:50 -07006870 if (const auto id = DisplayId::fromValue<PhysicalDisplayId>(value)) {
6871 return getPhysicalDisplayToken(*id);
6872 }
6873
6874 ALOGE("Invalid physical display ID");
6875 return nullptr;
Ady Abrahamfb853662021-04-09 11:46:40 -07006876 }();
6877
Shiyong Li2bcece92021-08-30 20:38:50 +00006878 mDebugDisplayModeSetByBackdoor = false;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07006879 const status_t result = setActiveModeFromBackdoor(display, DisplayModeId{modeId});
Dominik Laskowskif1833852021-03-23 15:06:50 -07006880 mDebugDisplayModeSetByBackdoor = result == NO_ERROR;
6881 return result;
Ady Abraham34392f72019-04-10 11:29:27 -07006882 }
Marin Shalamanovfa39ee72021-11-01 14:04:27 +01006883 // Turn on/off frame rate flexibility mode. When turned on it overrides the display
6884 // manager frame rate policy a new policy which allows switching between all refresh
6885 // rates.
Ady Abraham07e54702020-04-16 15:05:37 -07006886 case 1036: {
Marin Shalamanovfa39ee72021-11-01 14:04:27 +01006887 if (data.readInt32() > 0) { // turn on
Dominik Laskowski756b7892021-08-04 12:53:59 -07006888 return mScheduler
Dominik Laskowski36dced82022-09-02 09:24:00 -07006889 ->schedule([this]() FTL_FAKE_GUARD(kMainThreadContext) {
Dominik Laskowski756b7892021-08-04 12:53:59 -07006890 const auto display =
Dominik Laskowski298b08e2022-02-15 13:45:02 -08006891 FTL_FAKE_GUARD(mStateLock, getDefaultDisplayDeviceLocked());
Marin Shalamanovfa39ee72021-11-01 14:04:27 +01006892
Dominik Laskowski756b7892021-08-04 12:53:59 -07006893 // This is a little racy, but not in a way that hurts anything. As
6894 // we grab the defaultMode from the display manager policy, we could
6895 // be setting a new display manager policy, leaving us using a stale
6896 // defaultMode. The defaultMode doesn't matter for the override
6897 // policy though, since we set allowGroupSwitching to true, so it's
6898 // not a problem.
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04006899 scheduler::RefreshRateSelector::OverridePolicy overridePolicy;
6900 overridePolicy.defaultMode = display->refreshRateSelector()
Dominik Laskowski756b7892021-08-04 12:53:59 -07006901 .getDisplayManagerPolicy()
6902 .defaultMode;
6903 overridePolicy.allowGroupSwitching = true;
Dominik Laskowski36dced82022-09-02 09:24:00 -07006904 return setDesiredDisplayModeSpecsInternal(display, overridePolicy);
Dominik Laskowski756b7892021-08-04 12:53:59 -07006905 })
Marin Shalamanovfa39ee72021-11-01 14:04:27 +01006906 .get();
6907 } else { // turn off
Dominik Laskowski756b7892021-08-04 12:53:59 -07006908 return mScheduler
Dominik Laskowski36dced82022-09-02 09:24:00 -07006909 ->schedule([this]() FTL_FAKE_GUARD(kMainThreadContext) {
Dominik Laskowski756b7892021-08-04 12:53:59 -07006910 const auto display =
Dominik Laskowski298b08e2022-02-15 13:45:02 -08006911 FTL_FAKE_GUARD(mStateLock, getDefaultDisplayDeviceLocked());
Dominik Laskowski36dced82022-09-02 09:24:00 -07006912 return setDesiredDisplayModeSpecsInternal(
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04006913 display,
6914 scheduler::RefreshRateSelector::NoOverridePolicy{});
Dominik Laskowski756b7892021-08-04 12:53:59 -07006915 })
Marin Shalamanovfa39ee72021-11-01 14:04:27 +01006916 .get();
Ady Abraham07e54702020-04-16 15:05:37 -07006917 }
Ady Abraham07e54702020-04-16 15:05:37 -07006918 }
Marin Shalamanove6332b02020-09-03 11:30:37 +02006919 // Inject a hotplug connected event for the primary display. This will deallocate and
6920 // reallocate the display state including framebuffers.
6921 case 1037: {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07006922 const hal::HWDisplayId hwcId =
6923 (Mutex::Autolock(mStateLock), getHwComposer().getPrimaryHwcDisplayId());
6924
6925 onComposerHalHotplug(hwcId, hal::Connection::CONNECTED);
Marin Shalamanove6332b02020-09-03 11:30:37 +02006926 return NO_ERROR;
6927 }
Adithya Srinivasan2d736322020-10-01 16:53:48 -07006928 // Modify the max number of display frames stored within FrameTimeline
6929 case 1038: {
6930 n = data.readInt32();
6931 if (n < 0 || n > MAX_ALLOWED_DISPLAY_FRAMES) {
6932 ALOGW("Invalid max size. Maximum allowed is %d", MAX_ALLOWED_DISPLAY_FRAMES);
6933 return BAD_VALUE;
6934 }
6935 if (n == 0) {
6936 // restore to default
6937 mFrameTimeline->reset();
6938 return NO_ERROR;
6939 }
6940 mFrameTimeline->setMaxDisplayFrames(n);
6941 return NO_ERROR;
6942 }
Ady Abraham0bb6a472020-10-12 10:22:13 -07006943 case 1039: {
Ady Abraham62f216c2020-10-13 19:07:23 -07006944 PhysicalDisplayId displayId = [&]() {
6945 Mutex::Autolock lock(mStateLock);
6946 return getDefaultDisplayDeviceLocked()->getPhysicalId();
6947 }();
6948
6949 auto inUid = static_cast<uid_t>(data.readInt32());
6950 const auto refreshRate = data.readFloat();
Ady Abraham62a0be22020-12-08 16:54:10 -08006951 mScheduler->setPreferredRefreshRateForUid(FrameRateOverride{inUid, refreshRate});
6952 mScheduler->onFrameRateOverridesChanged(mAppConnectionHandle, displayId);
Ady Abraham0bb6a472020-10-12 10:22:13 -07006953 return NO_ERROR;
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08006954 }
Alec Mouridd8bf2d2021-05-08 16:36:33 -07006955 // Toggle caching feature
6956 // First argument is an int32 - nonzero enables caching and zero disables caching
6957 // Second argument is an optional uint64 - if present, then limits enabling/disabling
6958 // caching to a particular physical display
6959 case 1040: {
Dominik Laskowski756b7892021-08-04 12:53:59 -07006960 auto future = mScheduler->schedule([&] {
6961 n = data.readInt32();
6962 std::optional<PhysicalDisplayId> inputId = std::nullopt;
6963 if (uint64_t inputDisplayId; data.readUint64(&inputDisplayId) == NO_ERROR) {
6964 inputId = DisplayId::fromValue<PhysicalDisplayId>(inputDisplayId);
6965 if (!inputId || getPhysicalDisplayToken(*inputId)) {
6966 ALOGE("No display with id: %" PRIu64, inputDisplayId);
6967 return NAME_NOT_FOUND;
6968 }
6969 }
6970 {
6971 Mutex::Autolock lock(mStateLock);
Lloyd Pique30db6402023-06-26 18:56:51 +00006972 mLayerCachingEnabled = n != 0;
Dominik Laskowski756b7892021-08-04 12:53:59 -07006973 for (const auto& [_, display] : mDisplays) {
6974 if (!inputId || *inputId == display->getPhysicalId()) {
Lloyd Pique30db6402023-06-26 18:56:51 +00006975 display->enableLayerCaching(mLayerCachingEnabled);
Alec Mouricdd722b2021-05-19 14:29:05 -07006976 }
Dominik Laskowski756b7892021-08-04 12:53:59 -07006977 }
6978 }
6979 return OK;
6980 });
Alec Mouricdd722b2021-05-19 14:29:05 -07006981
Dominik Laskowski756b7892021-08-04 12:53:59 -07006982 if (const status_t error = future.get(); error != OK) {
Alec Mouricdd722b2021-05-19 14:29:05 -07006983 return error;
Alec Mouridd8bf2d2021-05-08 16:36:33 -07006984 }
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07006985 scheduleRepaint();
Alec Mouridd8bf2d2021-05-08 16:36:33 -07006986 return NO_ERROR;
6987 }
Vishnu Nair7891e962021-11-11 12:07:21 -08006988 case 1041: { // Transaction tracing
Dominik Laskowski46471e62022-01-14 15:34:03 -08006989 if (mTransactionTracing) {
6990 if (data.readInt32()) {
6991 // Transaction tracing is always running but allow the user to temporarily
6992 // increase the buffer when actively debugging.
6993 mTransactionTracing->setBufferSize(
6994 TransactionTracing::ACTIVE_TRACING_BUFFER_SIZE);
6995 } else {
Vishnu Naird1f74982023-06-15 20:16:51 -07006996 TransactionTraceWriter::getInstance().invoke("", /* overwrite= */ true);
Dominik Laskowski46471e62022-01-14 15:34:03 -08006997 mTransactionTracing->setBufferSize(
6998 TransactionTracing::CONTINUOUS_TRACING_BUFFER_SIZE);
Dominik Laskowski46471e62022-01-14 15:34:03 -08006999 }
Vishnu Nair7891e962021-11-11 12:07:21 -08007000 }
7001 reply->writeInt32(NO_ERROR);
7002 return NO_ERROR;
7003 }
Nataniel Borges533c2f82022-01-21 12:07:02 +01007004 case 1042: { // Write layers trace or transaction trace to file
7005 if (mTransactionTracing) {
7006 mTransactionTracing->writeToFile();
7007 }
7008 if (mLayerTracingEnabled) {
7009 mLayerTracing.writeToFile();
7010 }
7011 reply->writeInt32(NO_ERROR);
7012 return NO_ERROR;
7013 }
Sally Qi147581b2023-06-27 11:55:34 -07007014 // hdr sdr ratio overlay
7015 case 1043: {
7016 auto future = mScheduler->schedule(
7017 [&]() FTL_FAKE_GUARD(mStateLock) FTL_FAKE_GUARD(kMainThreadContext) {
7018 n = data.readInt32();
7019 mHdrSdrRatioOverlay = n != 0;
7020 switch (n) {
7021 case 0:
7022 case 1:
7023 enableHdrSdrRatioOverlay(mHdrSdrRatioOverlay);
7024 break;
7025 default:
7026 reply->writeBool(isHdrSdrRatioOverlayEnabled());
7027 }
7028 });
7029 future.wait();
7030 return NO_ERROR;
7031 }
Brian Johnson51d8d5d2023-07-28 10:18:47 -07007032
7033 case 1044: { // Enable/Disable mirroring from one display to another
7034 /*
7035 * Mirror one display onto another.
7036 * Ensure the source and destination displays are on.
7037 * Commands:
7038 * 0: Mirror one display to another
7039 * 1: Disable mirroring to a previously mirrored display
7040 * 2: Disable mirroring on previously mirrored displays
7041 *
7042 * Ex:
7043 * Get the display ids:
7044 * adb shell dumpsys SurfaceFlinger --display-id
7045 * Mirror first display to the second:
7046 * adb shell service call SurfaceFlinger 1044 i64 0 i64 4619827677550801152 i64
7047 * 4619827677550801153
7048 * Stop mirroring:
7049 * adb shell service call SurfaceFlinger 1044 i64 1
7050 */
7051
7052 int64_t arg0 = data.readInt64();
7053
7054 switch (arg0) {
7055 case 0: {
7056 // Mirror arg1 to arg2
7057 int64_t arg1 = data.readInt64();
7058 int64_t arg2 = data.readInt64();
7059 // Enable mirroring for one display
7060 const auto display1id = DisplayId::fromValue(arg1);
7061 auto mirrorRoot = SurfaceComposerClient::getDefault()->mirrorDisplay(
7062 display1id.value());
7063 auto id2 = DisplayId::fromValue<PhysicalDisplayId>(arg2);
7064 const auto token2 = getPhysicalDisplayToken(*id2);
7065 ui::LayerStack layerStack;
7066 {
7067 Mutex::Autolock lock(mStateLock);
7068 sp<DisplayDevice> display = getDisplayDeviceLocked(token2);
7069 layerStack = display->getLayerStack();
7070 }
7071 SurfaceComposerClient::Transaction t;
7072 t.setDisplayLayerStack(token2, layerStack);
7073 t.setLayer(mirrorRoot, INT_MAX); // Top-most layer
7074 t.setLayerStack(mirrorRoot, layerStack);
7075 t.apply();
7076
7077 mMirrorMapForDebug.emplace_or_replace(arg2, mirrorRoot);
7078 break;
7079 }
7080
7081 case 1: {
7082 // Disable mirroring for arg1
7083 int64_t arg1 = data.readInt64();
7084 mMirrorMapForDebug.erase(arg1);
7085 break;
7086 }
7087
7088 case 2: {
7089 // Disable mirroring for all displays
7090 mMirrorMapForDebug.clear();
7091 break;
7092 }
7093
7094 default:
7095 return BAD_VALUE;
7096 }
7097 return NO_ERROR;
7098 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08007099 }
7100 }
7101 return err;
7102}
7103
Ady Abrahama09852a2020-02-20 14:23:42 -08007104void SurfaceFlinger::kernelTimerChanged(bool expired) {
7105 static bool updateOverlay =
7106 property_get_bool("debug.sf.kernel_idle_timer_update_overlay", true);
Dominik Laskowski20134642020-04-20 22:36:44 -07007107 if (!updateOverlay) return;
Ady Abrahama09852a2020-02-20 14:23:42 -08007108
7109 // Update the overlay on the main thread to avoid race conditions with
Ady Abrahamace3d052022-11-17 16:25:05 -08007110 // RefreshRateSelector::getActiveMode
Dominik Laskowski756b7892021-08-04 12:53:59 -07007111 static_cast<void>(mScheduler->schedule([=] {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08007112 const auto display = FTL_FAKE_GUARD(mStateLock, getDefaultDisplayDeviceLocked());
Ady Abraham3efa3942021-06-24 19:01:25 -07007113 if (!display) {
7114 ALOGW("%s: default display is null", __func__);
7115 return;
7116 }
Adrian Salidoa942af82022-02-17 19:22:31 -08007117 if (!display->isRefreshRateOverlayEnabled()) return;
Ady Abraham690f4612021-07-01 23:24:03 -07007118
7119 const auto desiredActiveMode = display->getDesiredActiveMode();
7120 const std::optional<DisplayModeId> desiredModeId = desiredActiveMode
Ady Abrahamace3d052022-11-17 16:25:05 -08007121 ? std::make_optional(desiredActiveMode->modeOpt->modePtr->getId())
7122
Ady Abraham690f4612021-07-01 23:24:03 -07007123 : std::nullopt;
7124
7125 const bool timerExpired = mKernelIdleTimerEnabled && expired;
7126
Ady Abraham1b11bc62021-06-03 19:51:19 -07007127 if (display->onKernelTimerChanged(desiredModeId, timerExpired)) {
Dominik Laskowski46f3e3b2021-08-10 11:44:24 -07007128 mScheduler->scheduleFrame();
Ady Abrahama09852a2020-02-20 14:23:42 -08007129 }
7130 }));
7131}
7132
ramindani32cf0602022-03-02 02:30:29 +00007133std::pair<std::optional<KernelIdleTimerController>, std::chrono::milliseconds>
7134SurfaceFlinger::getKernelIdleTimerProperties(DisplayId displayId) {
7135 const bool isKernelIdleTimerHwcSupported = getHwComposer().getComposer()->isSupported(
7136 android::Hwc2::Composer::OptionalFeature::KernelIdleTimer);
7137 const auto timeout = getIdleTimerTimeout(displayId);
7138 if (isKernelIdleTimerHwcSupported) {
7139 if (const auto id = PhysicalDisplayId::tryCast(displayId);
7140 getHwComposer().hasDisplayIdleTimerCapability(*id)) {
7141 // In order to decide if we can use the HWC api for idle timer
7142 // we query DisplayCapability::DISPLAY_IDLE_TIMER directly on the composer
7143 // without relying on hasDisplayCapability.
7144 // hasDisplayCapability relies on DisplayCapabilities
7145 // which are updated after we set the PowerMode::ON.
7146 // DISPLAY_IDLE_TIMER is a display driver property
7147 // and is available before the PowerMode::ON
7148 return {KernelIdleTimerController::HwcApi, timeout};
7149 }
7150 return {std::nullopt, timeout};
7151 }
7152 if (getKernelIdleTimerSyspropConfig(displayId)) {
7153 return {KernelIdleTimerController::Sysprop, timeout};
7154 }
7155
7156 return {std::nullopt, timeout};
7157}
7158
7159void SurfaceFlinger::updateKernelIdleTimer(std::chrono::milliseconds timeout,
7160 KernelIdleTimerController controller,
7161 PhysicalDisplayId displayId) {
7162 switch (controller) {
7163 case KernelIdleTimerController::HwcApi: {
7164 getHwComposer().setIdleTimerEnabled(displayId, timeout);
7165 break;
7166 }
7167 case KernelIdleTimerController::Sysprop: {
7168 base::SetProperty(KERNEL_IDLE_TIMER_PROP, timeout > 0ms ? "true" : "false");
7169 break;
7170 }
7171 }
7172}
7173
Ana Krulecb9afd792020-06-11 13:16:15 -07007174void SurfaceFlinger::toggleKernelIdleTimer() {
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04007175 using KernelIdleTimerAction = scheduler::RefreshRateSelector::KernelIdleTimerAction;
Ana Krulecb9afd792020-06-11 13:16:15 -07007176
Ady Abraham3efa3942021-06-24 19:01:25 -07007177 const auto display = getDefaultDisplayDeviceLocked();
7178 if (!display) {
7179 ALOGW("%s: default display is null", __func__);
7180 return;
7181 }
Ana Krulecb9afd792020-06-11 13:16:15 -07007182
Ady Abrahame9316b72021-09-24 17:04:36 -07007183 // If the support for kernel idle timer is disabled for the active display,
7184 // don't do anything.
ramindani32cf0602022-03-02 02:30:29 +00007185 const std::optional<KernelIdleTimerController> kernelIdleTimerController =
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04007186 display->refreshRateSelector().kernelIdleTimerController();
ramindani32cf0602022-03-02 02:30:29 +00007187 if (!kernelIdleTimerController.has_value()) {
Ady Abrahame9316b72021-09-24 17:04:36 -07007188 return;
7189 }
7190
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04007191 const KernelIdleTimerAction action = display->refreshRateSelector().getIdleTimerAction();
ramindani32cf0602022-03-02 02:30:29 +00007192
Ana Krulecb9afd792020-06-11 13:16:15 -07007193 switch (action) {
7194 case KernelIdleTimerAction::TurnOff:
7195 if (mKernelIdleTimerEnabled) {
7196 ATRACE_INT("KernelIdleTimer", 0);
ramindani32cf0602022-03-02 02:30:29 +00007197 std::chrono::milliseconds constexpr kTimerDisabledTimeout = 0ms;
7198 updateKernelIdleTimer(kTimerDisabledTimeout, kernelIdleTimerController.value(),
7199 display->getPhysicalId());
Ana Krulecb9afd792020-06-11 13:16:15 -07007200 mKernelIdleTimerEnabled = false;
7201 }
7202 break;
7203 case KernelIdleTimerAction::TurnOn:
7204 if (!mKernelIdleTimerEnabled) {
7205 ATRACE_INT("KernelIdleTimer", 1);
ramindani32cf0602022-03-02 02:30:29 +00007206 const std::chrono::milliseconds timeout =
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04007207 display->refreshRateSelector().getIdleTimerTimeout();
ramindani32cf0602022-03-02 02:30:29 +00007208 updateKernelIdleTimer(timeout, kernelIdleTimerController.value(),
7209 display->getPhysicalId());
Ana Krulecb9afd792020-06-11 13:16:15 -07007210 mKernelIdleTimerEnabled = true;
7211 }
7212 break;
Ana Krulecb9afd792020-06-11 13:16:15 -07007213 }
7214}
7215
Dan Stoza2b6d38e2017-06-01 16:40:30 -07007216// A simple RAII class to disconnect from an ANativeWindow* when it goes out of scope
7217class WindowDisconnector {
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07007218public:
Dan Stoza2b6d38e2017-06-01 16:40:30 -07007219 WindowDisconnector(ANativeWindow* window, int api) : mWindow(window), mApi(api) {}
7220 ~WindowDisconnector() {
7221 native_window_api_disconnect(mWindow, mApi);
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07007222 }
7223
Dan Stoza2b6d38e2017-06-01 16:40:30 -07007224private:
7225 ANativeWindow* mWindow;
7226 const int mApi;
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07007227};
7228
chaviwf5bb97b2021-04-28 15:35:37 -05007229static bool hasCaptureBlackoutContentPermission() {
7230 IPCThreadState* ipc = IPCThreadState::self();
7231 const int pid = ipc->getCallingPid();
7232 const int uid = ipc->getCallingUid();
7233 return uid == AID_GRAPHICS || uid == AID_SYSTEM ||
7234 PermissionCache::checkPermission(sCaptureBlackoutContent, pid, uid);
7235}
7236
chaviw4b9d5e12020-08-04 18:30:35 -07007237static status_t validateScreenshotPermissions(const CaptureArgs& captureArgs) {
7238 IPCThreadState* ipc = IPCThreadState::self();
7239 const int pid = ipc->getCallingPid();
7240 const int uid = ipc->getCallingUid();
7241 if (uid == AID_GRAPHICS || PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
7242 return OK;
7243 }
7244
7245 // If the caller doesn't have the correct permissions but is only attempting to screenshot
7246 // itself, we allow it to continue.
7247 if (captureArgs.uid == uid) {
7248 return OK;
7249 }
7250
7251 ALOGE("Permission Denial: can't take screenshot pid=%d, uid=%d", pid, uid);
7252 return PERMISSION_DENIED;
7253}
7254
Peiyong Lin05cc0112020-10-14 16:16:37 -07007255status_t SurfaceFlinger::setSchedFifo(bool enabled) {
7256 static constexpr int kFifoPriority = 2;
7257 static constexpr int kOtherPriority = 0;
7258
7259 struct sched_param param = {0};
7260 int sched_policy;
7261 if (enabled) {
7262 sched_policy = SCHED_FIFO;
7263 param.sched_priority = kFifoPriority;
7264 } else {
7265 sched_policy = SCHED_OTHER;
7266 param.sched_priority = kOtherPriority;
7267 }
7268
7269 if (sched_setscheduler(0, sched_policy, &param) != 0) {
7270 return -errno;
7271 }
Wei Wang23aa5a62021-06-04 15:56:57 -07007272
7273 return NO_ERROR;
7274}
7275
7276status_t SurfaceFlinger::setSchedAttr(bool enabled) {
7277 static const unsigned int kUclampMin =
7278 base::GetUintProperty<unsigned int>("ro.surface_flinger.uclamp.min", 0U);
7279
7280 if (!kUclampMin) {
7281 // uclamp.min set to 0 (default), skip setting
7282 return NO_ERROR;
7283 }
7284
7285 // Currently, there is no wrapper in bionic: b/183240349.
7286 struct sched_attr {
7287 uint32_t size;
7288 uint32_t sched_policy;
7289 uint64_t sched_flags;
7290 int32_t sched_nice;
7291 uint32_t sched_priority;
7292 uint64_t sched_runtime;
7293 uint64_t sched_deadline;
7294 uint64_t sched_period;
7295 uint32_t sched_util_min;
7296 uint32_t sched_util_max;
7297 };
7298
7299 sched_attr attr = {};
7300 attr.size = sizeof(attr);
7301
7302 attr.sched_flags = (SCHED_FLAG_KEEP_ALL | SCHED_FLAG_UTIL_CLAMP);
7303 attr.sched_util_min = enabled ? kUclampMin : 0;
7304 attr.sched_util_max = 1024;
7305
7306 if (syscall(__NR_sched_setattr, 0, &attr, 0)) {
7307 return -errno;
7308 }
7309
Peiyong Lin05cc0112020-10-14 16:16:37 -07007310 return NO_ERROR;
7311}
7312
Alec Mouri3e5965f2023-04-07 18:00:58 +00007313namespace {
7314
7315ui::Dataspace pickBestDataspace(ui::Dataspace requestedDataspace, const DisplayDevice* display,
7316 bool capturingHdrLayers, bool hintForSeamlessTransition) {
7317 if (requestedDataspace != ui::Dataspace::UNKNOWN || display == nullptr) {
7318 return requestedDataspace;
7319 }
7320
7321 const auto& state = display->getCompositionDisplay()->getState();
7322
7323 const auto dataspaceForColorMode = ui::pickDataspaceFor(state.colorMode);
7324
Alec Mouri29640722023-05-16 23:22:41 +00007325 // TODO: Enable once HDR screenshots are ready.
7326 if constexpr (/* DISABLES CODE */ (false)) {
Alec Mouri3e5965f2023-04-07 18:00:58 +00007327 // For now since we only support 8-bit screenshots, just use HLG and
7328 // assume that 1.0 >= display max luminance. This isn't quite as future
7329 // proof as PQ is, but is good enough.
7330 // Consider using PQ once we support 16-bit screenshots and we're able
7331 // to consistently supply metadata to image encoders.
7332 return ui::Dataspace::BT2020_HLG;
7333 }
7334
7335 return dataspaceForColorMode;
7336}
7337
7338} // namespace
7339
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007340static void invokeScreenCaptureError(const status_t status,
7341 const sp<IScreenCaptureListener>& captureListener) {
7342 ScreenCaptureResults captureResults;
7343 captureResults.fenceResult = base::unexpected(status);
7344 captureListener->onScreenCaptureCompleted(captureResults);
7345}
7346
7347void SurfaceFlinger::captureDisplay(const DisplayCaptureArgs& args,
7348 const sp<IScreenCaptureListener>& captureListener) {
chaviwd2432892020-07-24 17:42:39 -07007349 ATRACE_CALL();
7350
chaviw4b9d5e12020-08-04 18:30:35 -07007351 status_t validate = validateScreenshotPermissions(args);
7352 if (validate != OK) {
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007353 invokeScreenCaptureError(validate, captureListener);
7354 return;
chaviw4b9d5e12020-08-04 18:30:35 -07007355 }
7356
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007357 if (!args.displayToken) {
7358 invokeScreenCaptureError(BAD_VALUE, captureListener);
7359 return;
7360 }
chaviwd2432892020-07-24 17:42:39 -07007361
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -07007362 wp<const DisplayDevice> displayWeak;
chaviwd2432892020-07-24 17:42:39 -07007363 ui::LayerStack layerStack;
7364 ui::Size reqSize(args.width, args.height);
Ajinkya Chalke02844632023-03-01 12:10:14 +00007365 std::unordered_set<uint32_t> excludeLayerIds;
chaviwd2432892020-07-24 17:42:39 -07007366 {
7367 Mutex::Autolock lock(mStateLock);
7368 sp<DisplayDevice> display = getDisplayDeviceLocked(args.displayToken);
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007369 if (!display) {
7370 invokeScreenCaptureError(NAME_NOT_FOUND, captureListener);
7371 return;
7372 }
chaviwd2432892020-07-24 17:42:39 -07007373 displayWeak = display;
7374 layerStack = display->getLayerStack();
7375
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02007376 // set the requested width/height to the logical display layer stack rect size by default
chaviwd2432892020-07-24 17:42:39 -07007377 if (args.width == 0 || args.height == 0) {
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02007378 reqSize = display->getLayerStackSpaceRect().getSize();
chaviwd2432892020-07-24 17:42:39 -07007379 }
7380
Ajinkya Chalke02844632023-03-01 12:10:14 +00007381 for (const auto& handle : args.excludeHandles) {
7382 uint32_t excludeLayer = LayerHandle::getLayerId(handle);
7383 if (excludeLayer != UNASSIGNED_LAYER_ID) {
7384 excludeLayerIds.emplace(excludeLayer);
7385 } else {
7386 ALOGW("Invalid layer handle passed as excludeLayer to captureDisplay");
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007387 invokeScreenCaptureError(NAME_NOT_FOUND, captureListener);
7388 return;
Ajinkya Chalke02844632023-03-01 12:10:14 +00007389 }
7390 }
chaviwd2432892020-07-24 17:42:39 -07007391 }
7392
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -08007393 RenderAreaFuture renderAreaFuture = ftl::defer([=] {
Alec Mouric44a1ff2023-05-19 23:49:05 +00007394 return DisplayRenderArea::create(displayWeak, args.sourceCrop, reqSize, args.dataspace,
7395 args.useIdentityTransform, args.hintForSeamlessTransition,
7396 args.captureSecureLayers);
chaviwd2432892020-07-24 17:42:39 -07007397 });
7398
Vishnu Nair3af0ec02023-02-10 04:13:48 +00007399 GetLayerSnapshotsFunction getLayerSnapshots;
Lloyd Pique30db6402023-06-26 18:56:51 +00007400 if (mLayerLifecycleManagerEnabled) {
Vishnu Nairc5a5b6e2023-02-28 00:19:07 +00007401 getLayerSnapshots =
Ajinkya Chalke02844632023-03-01 12:10:14 +00007402 getLayerSnapshotsForScreenshots(layerStack, args.uid, std::move(excludeLayerIds));
Vishnu Nair3af0ec02023-02-10 04:13:48 +00007403 } else {
Ajinkya Chalke02844632023-03-01 12:10:14 +00007404 auto traverseLayers = [this, args, excludeLayerIds,
7405 layerStack](const LayerVector::Visitor& visitor) {
7406 traverseLayersInLayerStack(layerStack, args.uid, std::move(excludeLayerIds), visitor);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00007407 };
7408 getLayerSnapshots = RenderArea::fromTraverseLayersLambda(traverseLayers);
7409 }
chaviw03900772020-08-18 12:34:51 -07007410
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007411 captureScreenCommon(std::move(renderAreaFuture), getLayerSnapshots, reqSize, args.pixelFormat,
7412 args.allowProtected, args.grayscale, captureListener);
chaviw93df2ea2019-04-30 16:45:12 -07007413}
7414
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007415void SurfaceFlinger::captureDisplay(DisplayId displayId,
7416 const sp<IScreenCaptureListener>& captureListener) {
Marin Shalamanov1c434292020-06-12 01:47:29 +02007417 ui::LayerStack layerStack;
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -07007418 wp<const DisplayDevice> displayWeak;
Marin Shalamanov1c434292020-06-12 01:47:29 +02007419 ui::Size size;
chaviw93df2ea2019-04-30 16:45:12 -07007420 {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07007421 Mutex::Autolock lock(mStateLock);
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -07007422
Dominik Laskowskif1833852021-03-23 15:06:50 -07007423 const auto display = getDisplayDeviceLocked(displayId);
chaviw93df2ea2019-04-30 16:45:12 -07007424 if (!display) {
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007425 invokeScreenCaptureError(NAME_NOT_FOUND, captureListener);
7426 return;
chaviw93df2ea2019-04-30 16:45:12 -07007427 }
7428
chaviw93df2ea2019-04-30 16:45:12 -07007429 displayWeak = display;
Dominik Laskowskif1833852021-03-23 15:06:50 -07007430 layerStack = display->getLayerStack();
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02007431 size = display->getLayerStackSpaceRect().getSize();
chaviw93df2ea2019-04-30 16:45:12 -07007432 }
7433
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -08007434 RenderAreaFuture renderAreaFuture = ftl::defer([=] {
Alec Mouri3e5965f2023-04-07 18:00:58 +00007435 return DisplayRenderArea::create(displayWeak, Rect(), size, ui::Dataspace::UNKNOWN,
chaviwc6ad8af2020-08-03 11:33:30 -07007436 false /* useIdentityTransform */,
Alec Mouri3e5965f2023-04-07 18:00:58 +00007437 false /* hintForSeamlessTransition */,
chaviwd2432892020-07-24 17:42:39 -07007438 false /* captureSecureLayers */);
Marin Shalamanov1c434292020-06-12 01:47:29 +02007439 });
chaviw93df2ea2019-04-30 16:45:12 -07007440
Vishnu Nair3af0ec02023-02-10 04:13:48 +00007441 GetLayerSnapshotsFunction getLayerSnapshots;
Lloyd Pique30db6402023-06-26 18:56:51 +00007442 if (mLayerLifecycleManagerEnabled) {
Vishnu Nairc5a5b6e2023-02-28 00:19:07 +00007443 getLayerSnapshots = getLayerSnapshotsForScreenshots(layerStack, CaptureArgs::UNSET_UID,
7444 /*snapshotFilterFn=*/nullptr);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00007445 } else {
7446 auto traverseLayers = [this, layerStack](const LayerVector::Visitor& visitor) {
Ajinkya Chalke02844632023-03-01 12:10:14 +00007447 traverseLayersInLayerStack(layerStack, CaptureArgs::UNSET_UID, {}, visitor);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00007448 };
7449 getLayerSnapshots = RenderArea::fromTraverseLayersLambda(traverseLayers);
7450 }
Marin Shalamanov1c434292020-06-12 01:47:29 +02007451
Sally Qi59a9f502021-10-12 18:53:23 +00007452 if (captureListener == nullptr) {
7453 ALOGE("capture screen must provide a capture listener callback");
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007454 invokeScreenCaptureError(BAD_VALUE, captureListener);
7455 return;
Sally Qi59a9f502021-10-12 18:53:23 +00007456 }
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07007457
7458 constexpr bool kAllowProtected = false;
7459 constexpr bool kGrayscale = false;
7460
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007461 captureScreenCommon(std::move(renderAreaFuture), getLayerSnapshots, size,
7462 ui::PixelFormat::RGBA_8888, kAllowProtected, kGrayscale, captureListener);
chaviw93df2ea2019-04-30 16:45:12 -07007463}
7464
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007465void SurfaceFlinger::captureLayers(const LayerCaptureArgs& args,
7466 const sp<IScreenCaptureListener>& captureListener) {
chaviwa76b2712017-09-20 12:02:26 -07007467 ATRACE_CALL();
7468
chaviw4b9d5e12020-08-04 18:30:35 -07007469 status_t validate = validateScreenshotPermissions(args);
7470 if (validate != OK) {
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007471 invokeScreenCaptureError(validate, captureListener);
7472 return;
chaviw4b9d5e12020-08-04 18:30:35 -07007473 }
7474
Marin Shalamanov1c434292020-06-12 01:47:29 +02007475 ui::Size reqSize;
Robert Carrc0df3122019-04-11 13:18:21 -07007476 sp<Layer> parent;
chaviw3efadb12020-07-27 10:07:15 -07007477 Rect crop(args.sourceCrop);
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00007478 std::unordered_set<uint32_t> excludeLayerIds;
Alec Mouri3e5965f2023-04-07 18:00:58 +00007479 ui::Dataspace dataspace = args.dataspace;
chaviwf5bb97b2021-04-28 15:35:37 -05007480
7481 // Call this before holding mStateLock to avoid any deadlocking.
7482 bool canCaptureBlackoutContent = hasCaptureBlackoutContentPermission();
7483
Robert Carrc0df3122019-04-11 13:18:21 -07007484 {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07007485 Mutex::Autolock lock(mStateLock);
chaviw7206d492017-11-10 16:16:12 -08007486
Vishnu Nair07e2a482022-10-18 19:18:16 +00007487 parent = LayerHandle::getLayer(args.layerHandle);
chaviw79468ab2021-10-27 11:11:24 -05007488 if (parent == nullptr) {
Robert Carrc0df3122019-04-11 13:18:21 -07007489 ALOGE("captureLayers called with an invalid or removed parent");
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007490 invokeScreenCaptureError(NAME_NOT_FOUND, captureListener);
7491 return;
Robert Carrc0df3122019-04-11 13:18:21 -07007492 }
7493
chaviwf5bb97b2021-04-28 15:35:37 -05007494 if (!canCaptureBlackoutContent &&
Robert Carr6a160312021-05-17 12:08:20 -07007495 parent->getDrawingState().flags & layer_state_t::eLayerSecure) {
Robert Carrc0df3122019-04-11 13:18:21 -07007496 ALOGW("Attempting to capture secure layer: PERMISSION_DENIED");
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007497 invokeScreenCaptureError(PERMISSION_DENIED, captureListener);
7498 return;
Robert Carrc0df3122019-04-11 13:18:21 -07007499 }
7500
Robert Carr6a160312021-05-17 12:08:20 -07007501 Rect parentSourceBounds = parent->getCroppedBufferSize(parent->getDrawingState());
chaviw3efadb12020-07-27 10:07:15 -07007502 if (args.sourceCrop.width() <= 0) {
Robert Carrc0df3122019-04-11 13:18:21 -07007503 crop.left = 0;
Vishnu Nairefc42e22019-12-03 17:36:12 -08007504 crop.right = parentSourceBounds.getWidth();
Robert Carrc0df3122019-04-11 13:18:21 -07007505 }
7506
chaviw3efadb12020-07-27 10:07:15 -07007507 if (args.sourceCrop.height() <= 0) {
Robert Carrc0df3122019-04-11 13:18:21 -07007508 crop.top = 0;
Vishnu Nairefc42e22019-12-03 17:36:12 -08007509 crop.bottom = parentSourceBounds.getHeight();
7510 }
7511
chaviw17ac24b2021-01-28 18:50:05 -08007512 if (crop.isEmpty() || args.frameScaleX <= 0.0f || args.frameScaleY <= 0.0f) {
Vishnu Nairefc42e22019-12-03 17:36:12 -08007513 // Error out if the layer has no source bounds (i.e. they are boundless) and a source
7514 // crop was not specified, or an invalid frame scale was provided.
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007515 invokeScreenCaptureError(BAD_VALUE, captureListener);
7516 return;
Robert Carrc0df3122019-04-11 13:18:21 -07007517 }
chaviw17ac24b2021-01-28 18:50:05 -08007518 reqSize = ui::Size(crop.width() * args.frameScaleX, crop.height() * args.frameScaleY);
Robert Carrc0df3122019-04-11 13:18:21 -07007519
chaviw3efadb12020-07-27 10:07:15 -07007520 for (const auto& handle : args.excludeHandles) {
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00007521 uint32_t excludeLayer = LayerHandle::getLayerId(handle);
7522 if (excludeLayer != UNASSIGNED_LAYER_ID) {
7523 excludeLayerIds.emplace(excludeLayer);
Robert Carrc0df3122019-04-11 13:18:21 -07007524 } else {
7525 ALOGW("Invalid layer handle passed as excludeLayer to captureLayers");
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007526 invokeScreenCaptureError(NAME_NOT_FOUND, captureListener);
7527 return;
Robert Carrc0df3122019-04-11 13:18:21 -07007528 }
7529 }
7530 } // mStateLock
chaviw7206d492017-11-10 16:16:12 -08007531
Chia-I Wu20261cb2018-08-23 12:55:44 -07007532 // really small crop or frameScale
chaviw79468ab2021-10-27 11:11:24 -05007533 if (reqSize.width <= 0 || reqSize.height <= 0) {
7534 ALOGW("Failed to captureLayes: crop or scale too small");
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007535 invokeScreenCaptureError(BAD_VALUE, captureListener);
7536 return;
Chia-I Wu20261cb2018-08-23 12:55:44 -07007537 }
7538
chaviw3efadb12020-07-27 10:07:15 -07007539 bool childrenOnly = args.childrenOnly;
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -08007540 RenderAreaFuture renderAreaFuture = ftl::defer([=]() -> std::unique_ptr<RenderArea> {
Vishnu Nair36d5f8e2023-03-19 13:31:35 -07007541 ui::Transform layerTransform;
7542 Rect layerBufferSize;
Lloyd Pique30db6402023-06-26 18:56:51 +00007543 if (mLayerLifecycleManagerEnabled) {
Vishnu Nair36d5f8e2023-03-19 13:31:35 -07007544 frontend::LayerSnapshot* snapshot =
7545 mLayerSnapshotBuilder.getSnapshot(parent->getSequence());
7546 if (!snapshot) {
7547 ALOGW("Couldn't find layer snapshot for %d", parent->getSequence());
7548 } else {
7549 layerTransform = snapshot->localTransform;
7550 layerBufferSize = snapshot->bufferSize;
7551 }
7552 } else {
7553 layerTransform = parent->getTransform();
7554 layerBufferSize = parent->getBufferSize(parent->getDrawingState());
7555 }
7556
chaviw3efadb12020-07-27 10:07:15 -07007557 return std::make_unique<LayerRenderArea>(*this, parent, crop, reqSize, dataspace,
Vishnu Nair36d5f8e2023-03-19 13:31:35 -07007558 childrenOnly, args.captureSecureLayers,
Alec Mouri3e5965f2023-04-07 18:00:58 +00007559 layerTransform, layerBufferSize,
7560 args.hintForSeamlessTransition);
Marin Shalamanov1c434292020-06-12 01:47:29 +02007561 });
Vishnu Nair3af0ec02023-02-10 04:13:48 +00007562 GetLayerSnapshotsFunction getLayerSnapshots;
Lloyd Pique30db6402023-06-26 18:56:51 +00007563 if (mLayerLifecycleManagerEnabled) {
Vishnu Nair36d5f8e2023-03-19 13:31:35 -07007564 std::optional<FloatRect> parentCrop = std::nullopt;
7565 if (args.childrenOnly) {
7566 parentCrop = crop.isEmpty() ? FloatRect(0, 0, reqSize.width, reqSize.height)
7567 : crop.toFloatRect();
7568 }
7569
Vishnu Nair3af0ec02023-02-10 04:13:48 +00007570 getLayerSnapshots = getLayerSnapshotsForScreenshots(parent->sequence, args.uid,
7571 std::move(excludeLayerIds),
7572 args.childrenOnly, parentCrop);
7573 } else {
7574 auto traverseLayers = [parent, args, excludeLayerIds](const LayerVector::Visitor& visitor) {
7575 parent->traverseChildrenInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
7576 if (!layer->isVisible()) {
7577 return;
7578 } else if (args.childrenOnly && layer == parent.get()) {
7579 return;
7580 } else if (args.uid != CaptureArgs::UNSET_UID && args.uid != layer->getOwnerUid()) {
Robert Carr866455f2019-04-02 16:28:26 -07007581 return;
7582 }
Robert Carr866455f2019-04-02 16:28:26 -07007583
Vishnu Nair3af0ec02023-02-10 04:13:48 +00007584 auto p = sp<Layer>::fromExisting(layer);
7585 while (p != nullptr) {
7586 if (excludeLayerIds.count(p->sequence) != 0) {
7587 return;
7588 }
7589 p = p->getParent();
7590 }
7591
7592 visitor(layer);
7593 });
7594 };
7595 getLayerSnapshots = RenderArea::fromTraverseLayersLambda(traverseLayers);
7596 }
Robert Carr108b2c72019-04-02 16:32:58 -07007597
Sally Qi59a9f502021-10-12 18:53:23 +00007598 if (captureListener == nullptr) {
7599 ALOGE("capture screen must provide a capture listener callback");
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007600 invokeScreenCaptureError(BAD_VALUE, captureListener);
7601 return;
Sally Qi59a9f502021-10-12 18:53:23 +00007602 }
7603
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007604 captureScreenCommon(std::move(renderAreaFuture), getLayerSnapshots, reqSize, args.pixelFormat,
7605 args.allowProtected, args.grayscale, captureListener);
chaviwa76b2712017-09-20 12:02:26 -07007606}
7607
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007608void SurfaceFlinger::captureScreenCommon(RenderAreaFuture renderAreaFuture,
7609 GetLayerSnapshotsFunction getLayerSnapshots,
7610 ui::Size bufferSize, ui::PixelFormat reqPixelFormat,
7611 bool allowProtected, bool grayscale,
7612 const sp<IScreenCaptureListener>& captureListener) {
chaviwa76b2712017-09-20 12:02:26 -07007613 ATRACE_CALL();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08007614
Garfield Tan9c9c1912021-07-19 12:02:16 -07007615 if (exceedsMaxRenderTargetSize(bufferSize.getWidth(), bufferSize.getHeight())) {
7616 ALOGE("Attempted to capture screen with size (%" PRId32 ", %" PRId32
7617 ") that exceeds render target size limit.",
7618 bufferSize.getWidth(), bufferSize.getHeight());
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007619 invokeScreenCaptureError(BAD_VALUE, captureListener);
7620 return;
Garfield Tan9c9c1912021-07-19 12:02:16 -07007621 }
7622
Peiyong Lin05cc0112020-10-14 16:16:37 -07007623 // Loop over all visible layers to see whether there's any protected layer. A protected layer is
7624 // typically a layer with DRM contents, or have the GRALLOC_USAGE_PROTECTED set on the buffer.
7625 // A protected layer has no implication on whether it's secure, which is explicitly set by
7626 // application to avoid being screenshot or drawn via unsecure display.
7627 const bool supportsProtected = getRenderEngine().supportsProtectedContent();
7628 bool hasProtectedLayer = false;
7629 if (allowProtected && supportsProtected) {
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00007630 hasProtectedLayer = mScheduler
7631 ->schedule([=]() {
7632 bool protectedLayerFound = false;
7633 auto layers = getLayerSnapshots();
Vishnu Naird47bcee2023-02-24 18:08:51 +00007634 for (auto& [_, layerFe] : layers) {
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00007635 protectedLayerFound |=
7636 (layerFe->mSnapshot->isVisible &&
7637 layerFe->mSnapshot->hasProtectedContent);
7638 }
7639 return protectedLayerFound;
7640 })
7641 .get();
Peiyong Lin05cc0112020-10-14 16:16:37 -07007642 }
7643
Richard Liucbcb8952020-04-08 10:51:55 +00007644 const uint32_t usage = GRALLOC_USAGE_HW_COMPOSER | GRALLOC_USAGE_HW_RENDER |
7645 GRALLOC_USAGE_HW_TEXTURE |
Peiyong Lin05cc0112020-10-14 16:16:37 -07007646 (hasProtectedLayer && allowProtected && supportsProtected
7647 ? GRALLOC_USAGE_PROTECTED
7648 : GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);
chaviw426b5c02020-07-27 11:20:15 -07007649 sp<GraphicBuffer> buffer =
7650 getFactory().createGraphicBuffer(bufferSize.getWidth(), bufferSize.getHeight(),
7651 static_cast<android_pixel_format>(reqPixelFormat),
7652 1 /* layerCount */, usage, "screenshot");
Alec Mouri7013b6f2021-02-12 11:16:54 -08007653
7654 const status_t bufferStatus = buffer->initCheck();
Alec Mourid8f17c52022-07-21 18:43:10 +00007655 if (bufferStatus != OK) {
7656 // Animations may end up being really janky, but don't crash here.
7657 // Otherwise an irreponsible process may cause an SF crash by allocating
7658 // too much.
7659 ALOGE("%s: Buffer failed to allocate: %d", __func__, bufferStatus);
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007660 invokeScreenCaptureError(bufferStatus, captureListener);
7661 return;
Alec Mourid8f17c52022-07-21 18:43:10 +00007662 }
Vishnu Nairdbbe3852022-01-12 20:22:11 -08007663 const std::shared_ptr<renderengine::ExternalTexture> texture = std::make_shared<
7664 renderengine::impl::ExternalTexture>(buffer, getRenderEngine(),
7665 renderengine::impl::ExternalTexture::Usage::
7666 WRITEABLE);
jeimysantiago9be7d0c2023-07-12 18:37:06 +00007667 auto fence = captureScreenCommon(std::move(renderAreaFuture), getLayerSnapshots, texture,
7668 false /* regionSampling */, grayscale, captureListener);
7669 fence.get();
Dan Stozaec460082018-12-17 15:35:09 -08007670}
7671
Dominik Laskowskib17c6212022-05-09 09:36:19 -07007672ftl::SharedFuture<FenceResult> SurfaceFlinger::captureScreenCommon(
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00007673 RenderAreaFuture renderAreaFuture, GetLayerSnapshotsFunction getLayerSnapshots,
Alec Mouria90a5702021-04-16 16:36:21 +00007674 const std::shared_ptr<renderengine::ExternalTexture>& buffer, bool regionSampling,
7675 bool grayscale, const sp<IScreenCaptureListener>& captureListener) {
chaviw03900772020-08-18 12:34:51 -07007676 ATRACE_CALL();
7677
chaviwf5bb97b2021-04-28 15:35:37 -05007678 bool canCaptureBlackoutContent = hasCaptureBlackoutContentPermission();
Robert Carr03480e22018-01-04 16:02:06 -08007679
Patrick Williams377c0142022-10-13 17:33:38 +00007680 auto future = mScheduler->schedule(
7681 [=, renderAreaFuture = std::move(renderAreaFuture)]() FTL_FAKE_GUARD(
7682 kMainThreadContext) mutable -> ftl::SharedFuture<FenceResult> {
7683 ScreenCaptureResults captureResults;
Patrick Williams31908132023-01-09 13:38:48 -06007684 std::shared_ptr<RenderArea> renderArea = renderAreaFuture.get();
Patrick Williams377c0142022-10-13 17:33:38 +00007685 if (!renderArea) {
7686 ALOGW("Skipping screen capture because of invalid render area.");
Nolan Scobie1d2deb22022-11-18 12:57:47 -05007687 if (captureListener) {
7688 captureResults.fenceResult = base::unexpected(NO_MEMORY);
7689 captureListener->onScreenCaptureCompleted(captureResults);
7690 }
Patrick Williams377c0142022-10-13 17:33:38 +00007691 return ftl::yield<FenceResult>(base::unexpected(NO_ERROR)).share();
7692 }
Dan Stoza2b6d38e2017-06-01 16:40:30 -07007693
Patrick Williams377c0142022-10-13 17:33:38 +00007694 ftl::SharedFuture<FenceResult> renderFuture;
7695 renderArea->render([&]() FTL_FAKE_GUARD(kMainThreadContext) {
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00007696 renderFuture = renderScreenImpl(renderArea, getLayerSnapshots, buffer,
Patrick Williams377c0142022-10-13 17:33:38 +00007697 canCaptureBlackoutContent, regionSampling,
7698 grayscale, captureResults);
7699 });
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07007700
Patrick Williams377c0142022-10-13 17:33:38 +00007701 if (captureListener) {
7702 // Defer blocking on renderFuture back to the Binder thread.
7703 return ftl::Future(std::move(renderFuture))
7704 .then([captureListener, captureResults = std::move(captureResults)](
7705 FenceResult fenceResult) mutable -> FenceResult {
7706 captureResults.fenceResult = std::move(fenceResult);
7707 captureListener->onScreenCaptureCompleted(captureResults);
7708 return base::unexpected(NO_ERROR);
7709 })
7710 .share();
7711 }
7712 return renderFuture;
7713 });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07007714
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07007715 // Flatten nested futures.
Dominik Laskowskib17c6212022-05-09 09:36:19 -07007716 auto chain = ftl::Future(std::move(future)).then([](ftl::SharedFuture<FenceResult> future) {
7717 return future;
7718 });
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07007719
7720 return chain.share();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08007721}
7722
Dominik Laskowskib17c6212022-05-09 09:36:19 -07007723ftl::SharedFuture<FenceResult> SurfaceFlinger::renderScreenImpl(
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00007724 std::shared_ptr<const RenderArea> renderArea, GetLayerSnapshotsFunction getLayerSnapshots,
chaviwf5bb97b2021-04-28 15:35:37 -05007725 const std::shared_ptr<renderengine::ExternalTexture>& buffer,
7726 bool canCaptureBlackoutContent, bool regionSampling, bool grayscale,
7727 ScreenCaptureResults& captureResults) {
Mathias Agopian180f10d2013-04-10 22:55:41 -07007728 ATRACE_CALL();
chaviwa76b2712017-09-20 12:02:26 -07007729
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00007730 auto layers = getLayerSnapshots();
Vishnu Naird47bcee2023-02-24 18:08:51 +00007731 for (auto& [_, layerFE] : layers) {
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00007732 frontend::LayerSnapshot* snapshot = layerFE->mSnapshot.get();
7733 captureResults.capturedSecureLayers |= (snapshot->isVisible && snapshot->isSecure);
7734 captureResults.capturedHdrLayers |= isHdrLayer(*snapshot);
7735 layerFE->mSnapshot->geomLayerTransform =
7736 renderArea->getTransform() * layerFE->mSnapshot->geomLayerTransform;
Patrick Williamsc6e0cce2023-02-28 23:04:45 -06007737 layerFE->mSnapshot->geomInverseLayerTransform =
7738 layerFE->mSnapshot->geomLayerTransform.inverse();
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00007739 }
chaviw426b5c02020-07-27 11:20:15 -07007740
7741 // We allow the system server to take screenshots of secure layers for
7742 // use in situations like the Screen-rotation animation and place
7743 // the impetus on WindowManager to not persist them.
chaviwf5bb97b2021-04-28 15:35:37 -05007744 if (captureResults.capturedSecureLayers && !canCaptureBlackoutContent) {
chaviw426b5c02020-07-27 11:20:15 -07007745 ALOGW("FB is protected: PERMISSION_DENIED");
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07007746 return ftl::yield<FenceResult>(base::unexpected(PERMISSION_DENIED)).share();
chaviw426b5c02020-07-27 11:20:15 -07007747 }
7748
Alec Mouri3e5965f2023-04-07 18:00:58 +00007749 auto capturedBuffer = buffer;
7750
7751 auto requestedDataspace = renderArea->getReqDataSpace();
Patrick Williams7584c6a2022-10-29 02:10:58 +00007752 auto parent = renderArea->getParentLayer();
Alec Mourifcedb9c2022-04-11 20:02:17 +00007753 auto renderIntent = RenderIntent::TONE_MAP_COLORIMETRIC;
Sally Qi6c903ca2022-04-25 11:24:20 -07007754 auto sdrWhitePointNits = DisplayDevice::sDefaultMaxLumiance;
7755 auto displayBrightnessNits = DisplayDevice::sDefaultMaxLumiance;
7756
Alec Mouri3e5965f2023-04-07 18:00:58 +00007757 captureResults.capturedDataspace = requestedDataspace;
7758
7759 {
Robert Carr12a3b9b2022-03-10 09:55:29 -08007760 Mutex::Autolock lock(mStateLock);
Alec Mouri3e5965f2023-04-07 18:00:58 +00007761 const DisplayDevice* display = nullptr;
7762 if (parent) {
7763 display = findDisplay([layerStack = parent->getLayerStack()](const auto& display) {
7764 return display.getLayerStack() == layerStack;
7765 }).get();
Robert Carr12a3b9b2022-03-10 09:55:29 -08007766 }
7767
Alec Mouri3e5965f2023-04-07 18:00:58 +00007768 if (display == nullptr) {
7769 display = renderArea->getDisplayDevice().get();
7770 }
7771
7772 if (display == nullptr) {
7773 display = getDefaultDisplayDeviceLocked().get();
7774 }
7775
7776 if (display != nullptr) {
7777 const auto& state = display->getCompositionDisplay()->getState();
7778 captureResults.capturedDataspace =
7779 pickBestDataspace(requestedDataspace, display, captureResults.capturedHdrLayers,
7780 renderArea->getHintForSeamlessTransition());
7781 sdrWhitePointNits = state.sdrWhitePointNits;
7782 displayBrightnessNits = state.displayBrightnessNits;
John Reck1dadaa62023-07-11 14:07:00 -04007783 // Only clamp the display brightness if this is not a seamless transition. Otherwise
7784 // for seamless transitions it's important to match the current display state as the
7785 // buffer will be shown under these same conditions, and we want to avoid any flickers
7786 if (sdrWhitePointNits > 1.0f && !renderArea->getHintForSeamlessTransition()) {
John Reck5b02fc42023-06-14 14:41:10 -04007787 // Restrict the amount of HDR "headroom" in the screenshot to avoid over-dimming
7788 // the SDR portion. 2.0 chosen by experimentation
7789 constexpr float kMaxScreenshotHeadroom = 2.0f;
7790 displayBrightnessNits =
7791 std::min(sdrWhitePointNits * kMaxScreenshotHeadroom, displayBrightnessNits);
7792 }
Alec Mouri3e5965f2023-04-07 18:00:58 +00007793
7794 if (requestedDataspace == ui::Dataspace::UNKNOWN) {
7795 renderIntent = state.renderIntent;
7796 }
7797 }
Robert Carr12a3b9b2022-03-10 09:55:29 -08007798 }
Alec Mouri3e5965f2023-04-07 18:00:58 +00007799
7800 captureResults.buffer = capturedBuffer->getBuffer();
chaviw426b5c02020-07-27 11:20:15 -07007801
Patrick Williams7584c6a2022-10-29 02:10:58 +00007802 ui::LayerStack layerStack{ui::DEFAULT_LAYER_STACK};
7803 if (!layers.empty()) {
7804 const sp<LayerFE>& layerFE = layers.back().second;
7805 layerStack = layerFE->getCompositionState()->outputFilter.layerStack;
Yichi Chen40773d92020-04-01 10:10:18 +08007806 }
Ady Abraham99599942021-01-27 20:27:23 -08007807
Patrick Williams7584c6a2022-10-29 02:10:58 +00007808 auto copyLayerFEs = [&layers]() {
7809 std::vector<sp<compositionengine::LayerFE>> layerFEs;
7810 layerFEs.reserve(layers.size());
7811 for (const auto& [_, layerFE] : layers) {
7812 layerFEs.push_back(layerFE);
7813 }
7814 return layerFEs;
7815 };
7816
Alec Mouri3e5965f2023-04-07 18:00:58 +00007817 auto present = [this, buffer = capturedBuffer, dataspace = captureResults.capturedDataspace,
7818 sdrWhitePointNits, displayBrightnessNits, grayscale, layerFEs = copyLayerFEs(),
7819 layerStack, regionSampling, renderArea = std::move(renderArea),
Patrick Williams278a88f2023-01-27 16:52:40 -06007820 renderIntent]() -> FenceResult {
Patrick Williams7584c6a2022-10-29 02:10:58 +00007821 std::unique_ptr<compositionengine::CompositionEngine> compositionEngine =
Lloyd Pique30db6402023-06-26 18:56:51 +00007822 mFactory.createCompositionEngine();
Patrick Williams7584c6a2022-10-29 02:10:58 +00007823 compositionEngine->setRenderEngine(mRenderEngine.get());
7824
7825 compositionengine::Output::ColorProfile colorProfile{.dataspace = dataspace,
7826 .renderIntent = renderIntent};
7827
Alec Mouri3e5965f2023-04-07 18:00:58 +00007828 float targetBrightness = 1.0f;
7829 if (dataspace == ui::Dataspace::BT2020_HLG) {
7830 const float maxBrightnessNits = displayBrightnessNits / sdrWhitePointNits * 203;
7831 // With a low dimming ratio, don't fit the entire curve. Otherwise mixed content
7832 // will appear way too bright.
7833 if (maxBrightnessNits < 1000.f) {
7834 targetBrightness = 1000.f / maxBrightnessNits;
7835 }
7836 }
7837
Patrick Williams7584c6a2022-10-29 02:10:58 +00007838 std::shared_ptr<ScreenCaptureOutput> output = createScreenCaptureOutput(
7839 ScreenCaptureOutputArgs{.compositionEngine = *compositionEngine,
7840 .colorProfile = colorProfile,
7841 .renderArea = *renderArea,
7842 .layerStack = layerStack,
7843 .buffer = std::move(buffer),
7844 .sdrWhitePointNits = sdrWhitePointNits,
7845 .displayBrightnessNits = displayBrightnessNits,
Alec Mouri3e5965f2023-04-07 18:00:58 +00007846 .targetBrightness = targetBrightness,
Alec Mouri7dae9c12023-07-13 19:40:53 +00007847 .regionSampling = regionSampling,
7848 .treat170mAsSrgb = mTreat170mAsSrgb});
Patrick Williams7584c6a2022-10-29 02:10:58 +00007849
7850 const float colorSaturation = grayscale ? 0 : 1;
7851 compositionengine::CompositionRefreshArgs refreshArgs{
7852 .outputs = {output},
7853 .layers = std::move(layerFEs),
7854 .updatingOutputGeometryThisFrame = true,
7855 .updatingGeometryThisFrame = true,
7856 .colorTransformMatrix = calculateColorMatrix(colorSaturation),
7857 };
7858 compositionEngine->present(refreshArgs);
7859
7860 return output->getRenderSurface()->getClientTargetAcquireFence();
7861 };
7862
7863 // If RenderEngine is threaded, we can safely call CompositionEngine::present off the main
7864 // thread as the RenderEngine::drawLayers call will run on RenderEngine's thread. Otherwise,
7865 // we need RenderEngine to run on the main thread so we call CompositionEngine::present
7866 // immediately.
7867 //
7868 // TODO(b/196334700) Once we use RenderEngineThreaded everywhere we can always defer the call
7869 // to CompositionEngine::present.
7870 const bool renderEngineIsThreaded = [&]() {
7871 using Type = renderengine::RenderEngine::RenderEngineType;
7872 const auto type = mRenderEngine->getRenderEngineType();
7873 return type == Type::THREADED || type == Type::SKIA_GL_THREADED;
7874 }();
7875 auto presentFuture = renderEngineIsThreaded ? ftl::defer(std::move(present)).share()
7876 : ftl::yield(present()).share();
7877
7878 for (auto& [layer, layerFE] : layers) {
Vishnu Nair7ee4f462023-04-19 09:54:09 -07007879 layer->onLayerDisplayed(ftl::Future(presentFuture)
7880 .then([layerFE = std::move(layerFE)](FenceResult) {
7881 return layerFE->stealCompositionResult()
7882 .releaseFences.back()
7883 .first.get();
7884 })
7885 .share(),
7886 ui::INVALID_LAYER_STACK);
Patrick Williams7584c6a2022-10-29 02:10:58 +00007887 }
7888
7889 return presentFuture;
Mathias Agopian74c40c02010-09-29 13:02:36 -07007890}
7891
Vishnu Naird47bcee2023-02-24 18:08:51 +00007892void SurfaceFlinger::traverseLegacyLayers(const LayerVector::Visitor& visitor) const {
Lloyd Pique30db6402023-06-26 18:56:51 +00007893 if (mLayerLifecycleManagerEnabled) {
Vishnu Naird47bcee2023-02-24 18:08:51 +00007894 for (auto& layer : mLegacyLayers) {
7895 visitor(layer.second.get());
7896 }
7897 } else {
7898 mDrawingState.traverse(visitor);
7899 }
7900}
7901
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07007902// ---------------------------------------------------------------------------
7903
Edgar Arriaga844fa672020-01-16 14:21:42 -08007904void SurfaceFlinger::State::traverse(const LayerVector::Visitor& visitor) const {
7905 layersSortedByZ.traverse(visitor);
7906}
7907
Dan Stoza412903f2017-04-27 13:42:17 -07007908void SurfaceFlinger::State::traverseInZOrder(const LayerVector::Visitor& visitor) const {
7909 layersSortedByZ.traverseInZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07007910}
7911
Dan Stoza412903f2017-04-27 13:42:17 -07007912void SurfaceFlinger::State::traverseInReverseZOrder(const LayerVector::Visitor& visitor) const {
7913 layersSortedByZ.traverseInReverseZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07007914}
7915
chaviw4b9d5e12020-08-04 18:30:35 -07007916void SurfaceFlinger::traverseLayersInLayerStack(ui::LayerStack layerStack, const int32_t uid,
Ajinkya Chalke02844632023-03-01 12:10:14 +00007917 std::unordered_set<uint32_t> excludeLayerIds,
Marin Shalamanov1c434292020-06-12 01:47:29 +02007918 const LayerVector::Visitor& visitor) {
chaviwa76b2712017-09-20 12:02:26 -07007919 // We loop through the first level of layers without traversing,
chaviw0e3479f2018-09-10 16:49:30 -07007920 // as we need to determine which layers belong to the requested display.
chaviwa76b2712017-09-20 12:02:26 -07007921 for (const auto& layer : mDrawingState.layersSortedByZ) {
Dominik Laskowski29fa1462021-04-27 15:51:50 -07007922 if (layer->getLayerStack() != layerStack) {
chaviwa76b2712017-09-20 12:02:26 -07007923 continue;
7924 }
Chia-I Wuec2d9852017-11-21 09:21:01 -08007925 // relative layers are traversed in Layer::traverseInZOrder
chaviwa76b2712017-09-20 12:02:26 -07007926 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
Dominik Laskowski29fa1462021-04-27 15:51:50 -07007927 if (layer->isInternalDisplayOverlay()) {
Adrian Roos8acf5a02018-01-17 21:28:19 +01007928 return;
7929 }
chaviwa76b2712017-09-20 12:02:26 -07007930 if (!layer->isVisible()) {
7931 return;
7932 }
chaviw4b9d5e12020-08-04 18:30:35 -07007933 if (uid != CaptureArgs::UNSET_UID && layer->getOwnerUid() != uid) {
7934 return;
7935 }
Ajinkya Chalke02844632023-03-01 12:10:14 +00007936
7937 if (!excludeLayerIds.empty()) {
7938 auto p = sp<Layer>::fromExisting(layer);
7939 while (p != nullptr) {
7940 if (excludeLayerIds.count(p->sequence) != 0) {
7941 return;
7942 }
7943 p = p->getParent();
7944 }
7945 }
7946
chaviwa76b2712017-09-20 12:02:26 -07007947 visitor(layer);
7948 });
7949 }
7950}
7951
Ady Abrahamace3d052022-11-17 16:25:05 -08007952ftl::Optional<scheduler::FrameRateMode> SurfaceFlinger::getPreferredDisplayMode(
Dominik Laskowskif2595442022-08-29 13:51:57 -07007953 PhysicalDisplayId displayId, DisplayModeId defaultModeId) const {
7954 if (const auto schedulerMode = mScheduler->getPreferredDisplayMode();
Dominik Laskowskifc378b02022-12-02 14:56:05 -05007955 schedulerMode.modePtr->getPhysicalDisplayId() == displayId) {
Ady Abrahamace3d052022-11-17 16:25:05 -08007956 return schedulerMode;
Dominik Laskowskif2595442022-08-29 13:51:57 -07007957 }
7958
7959 return mPhysicalDisplays.get(displayId)
7960 .transform(&PhysicalDisplay::snapshotRef)
7961 .and_then([&](const display::DisplaySnapshot& snapshot) {
7962 return snapshot.displayModes().get(defaultModeId);
Dominik Laskowski530d6bd2022-10-10 16:55:54 -04007963 })
Ady Abrahamace3d052022-11-17 16:25:05 -08007964 .transform([](const DisplayModePtr& modePtr) {
7965 return scheduler::FrameRateMode{modePtr->getFps(), ftl::as_non_null(modePtr)};
7966 });
Dominik Laskowskif2595442022-08-29 13:51:57 -07007967}
7968
Marin Shalamanova7fe3042021-01-29 21:02:08 +01007969status_t SurfaceFlinger::setDesiredDisplayModeSpecsInternal(
Steven Thomasd4071902020-03-24 16:02:53 -07007970 const sp<DisplayDevice>& display,
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04007971 const scheduler::RefreshRateSelector::PolicyVariant& policy) {
Dominik Laskowskie591b552022-09-09 10:44:56 -07007972 const auto displayId = display->getPhysicalId();
Dominik Laskowskifdac5652023-06-29 12:01:13 -04007973 ATRACE_NAME(ftl::Concat(__func__, ' ', displayId.value).c_str());
Dominik Laskowskie591b552022-09-09 10:44:56 -07007974
Ana Kruleced3a8cc2019-11-14 00:55:07 +01007975 Mutex::Autolock lock(mStateLock);
7976
Ady Abrahamfb853662021-04-09 11:46:40 -07007977 if (mDebugDisplayModeSetByBackdoor) {
7978 // ignore this request as mode is overridden by backdoor
7979 return NO_ERROR;
7980 }
7981
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04007982 auto& selector = display->refreshRateSelector();
7983 using SetPolicyResult = scheduler::RefreshRateSelector::SetPolicyResult;
Dominik Laskowski36dced82022-09-02 09:24:00 -07007984
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04007985 switch (selector.setPolicy(policy)) {
Dominik Laskowski36dced82022-09-02 09:24:00 -07007986 case SetPolicyResult::Invalid:
7987 return BAD_VALUE;
7988 case SetPolicyResult::Unchanged:
7989 return NO_ERROR;
7990 case SetPolicyResult::Changed:
Dominik Laskowskifc378b02022-12-02 14:56:05 -05007991 break;
Ady Abraham3efa3942021-06-24 19:01:25 -07007992 }
Dominik Laskowskifc378b02022-12-02 14:56:05 -05007993
Dominik Laskowskifdac5652023-06-29 12:01:13 -04007994 // TODO(b/255635711): Apply the policy once the display is powered on, which is currently only
7995 // done for the internal display that becomes active on fold/unfold. For now, assume that DM
7996 // always powers on the secondary (internal or external) display before setting its policy.
7997 if (!display->isPoweredOn()) {
7998 ALOGV("%s(%s): Display is powered off", __func__, to_string(displayId).c_str());
Dominik Laskowskifc378b02022-12-02 14:56:05 -05007999 return NO_ERROR;
8000 }
8001
8002 return applyRefreshRateSelectorPolicy(displayId, selector);
Dominik Laskowski3f726402022-11-21 17:21:22 -05008003}
Ady Abraham3efa3942021-06-24 19:01:25 -07008004
Dominik Laskowski3f726402022-11-21 17:21:22 -05008005status_t SurfaceFlinger::applyRefreshRateSelectorPolicy(
Dominik Laskowskifc378b02022-12-02 14:56:05 -05008006 PhysicalDisplayId displayId, const scheduler::RefreshRateSelector& selector, bool force) {
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04008007 const scheduler::RefreshRateSelector::Policy currentPolicy = selector.getCurrentPolicy();
Marin Shalamanova7fe3042021-01-29 21:02:08 +01008008 ALOGV("Setting desired display mode specs: %s", currentPolicy.toString().c_str());
Adrian Salidoab6ef6c2019-08-28 10:02:49 -07008009
Ana Krulecb9afd792020-06-11 13:16:15 -07008010 // TODO(b/140204874): Leave the event in until we do proper testing with all apps that might
8011 // be depending in this callback.
Ady Abrahamace3d052022-11-17 16:25:05 -08008012 if (const auto activeMode = selector.getActiveMode(); displayId == mActiveDisplayId) {
8013 mScheduler->onPrimaryDisplayModeChanged(mAppConnectionHandle, activeMode);
Ady Abraham690f4612021-07-01 23:24:03 -07008014 toggleKernelIdleTimer();
8015 } else {
Ady Abrahamace3d052022-11-17 16:25:05 -08008016 mScheduler->onNonPrimaryDisplayModeChanged(mAppConnectionHandle, activeMode);
Ady Abraham690f4612021-07-01 23:24:03 -07008017 }
Ady Abraham838de062019-02-04 10:24:03 -08008018
Dominik Laskowskie591b552022-09-09 10:44:56 -07008019 auto preferredModeOpt = getPreferredDisplayMode(displayId, currentPolicy.defaultMode);
Dominik Laskowskif2595442022-08-29 13:51:57 -07008020 if (!preferredModeOpt) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07008021 ALOGE("%s: Preferred mode is unknown", __func__);
8022 return NAME_NOT_FOUND;
8023 }
8024
Dominik Laskowskif2595442022-08-29 13:51:57 -07008025 auto preferredMode = std::move(*preferredModeOpt);
Ady Abrahamace3d052022-11-17 16:25:05 -08008026 const auto preferredModeId = preferredMode.modePtr->getId();
Ana Krulec3f6a2062020-01-23 15:48:01 -08008027
Dominik Laskowskif2595442022-08-29 13:51:57 -07008028 ALOGV("Switching to Scheduler preferred mode %d (%s)", preferredModeId.value(),
Ady Abrahamace3d052022-11-17 16:25:05 -08008029 to_string(preferredMode.fps).c_str());
Dominik Laskowskif2595442022-08-29 13:51:57 -07008030
Ady Abrahamace3d052022-11-17 16:25:05 -08008031 if (!selector.isModeAllowed(preferredMode)) {
Dominik Laskowskif2595442022-08-29 13:51:57 -07008032 ALOGE("%s: Preferred mode %d is disallowed", __func__, preferredModeId.value());
8033 return INVALID_OPERATION;
Dominik Laskowski4f1dd8c2019-04-17 15:54:30 -07008034 }
8035
Ady Abraham33a386b2023-07-18 15:37:11 -07008036 setDesiredActiveMode({preferredMode, .emitEvent = true}, force);
8037
8038 // Update the frameRateOverride list as the display render rate might have changed
8039 if (mScheduler->updateFrameRateOverrides(/*consideredSignals*/ {}, preferredMode.fps)) {
8040 triggerOnFrameRateOverridesChanged();
8041 }
8042
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08008043 return NO_ERROR;
8044}
8045
Ady Abraham285f8c12022-10-11 17:12:14 -07008046namespace {
8047FpsRange translate(const gui::DisplayModeSpecs::RefreshRateRanges::RefreshRateRange& aidlRange) {
8048 return FpsRange{Fps::fromValue(aidlRange.min), Fps::fromValue(aidlRange.max)};
8049}
8050
8051FpsRanges translate(const gui::DisplayModeSpecs::RefreshRateRanges& aidlRanges) {
8052 return FpsRanges{translate(aidlRanges.physical), translate(aidlRanges.render)};
8053}
8054
8055gui::DisplayModeSpecs::RefreshRateRanges::RefreshRateRange translate(const FpsRange& range) {
8056 gui::DisplayModeSpecs::RefreshRateRanges::RefreshRateRange aidlRange;
8057 aidlRange.min = range.min.getValue();
8058 aidlRange.max = range.max.getValue();
8059 return aidlRange;
8060}
8061
8062gui::DisplayModeSpecs::RefreshRateRanges translate(const FpsRanges& ranges) {
8063 gui::DisplayModeSpecs::RefreshRateRanges aidlRanges;
8064 aidlRanges.physical = translate(ranges.physical);
8065 aidlRanges.render = translate(ranges.render);
8066 return aidlRanges;
8067}
8068
8069} // namespace
8070
8071status_t SurfaceFlinger::setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
8072 const gui::DisplayModeSpecs& specs) {
Ana Krulec0782b882019-10-15 17:34:54 -07008073 ATRACE_CALL();
8074
8075 if (!displayToken) {
8076 return BAD_VALUE;
8077 }
8078
Dominik Laskowski36dced82022-09-02 09:24:00 -07008079 auto future = mScheduler->schedule([=]() FTL_FAKE_GUARD(kMainThreadContext) -> status_t {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08008080 const auto display = FTL_FAKE_GUARD(mStateLock, getDisplayDeviceLocked(displayToken));
Ana Krulec234bb162019-11-10 22:55:55 +01008081 if (!display) {
Marin Shalamanova7fe3042021-01-29 21:02:08 +01008082 ALOGE("Attempt to set desired display modes for invalid display token %p",
Ana Krulec234bb162019-11-10 22:55:55 +01008083 displayToken.get());
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07008084 return NAME_NOT_FOUND;
Ana Krulec234bb162019-11-10 22:55:55 +01008085 } else if (display->isVirtual()) {
Marin Shalamanova7fe3042021-01-29 21:02:08 +01008086 ALOGW("Attempt to set desired display modes for virtual display");
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07008087 return INVALID_OPERATION;
Ana Krulec234bb162019-11-10 22:55:55 +01008088 } else {
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04008089 using Policy = scheduler::RefreshRateSelector::DisplayManagerPolicy;
Ady Abraham285f8c12022-10-11 17:12:14 -07008090 const Policy policy{DisplayModeId(specs.defaultMode), translate(specs.primaryRanges),
8091 translate(specs.appRequestRanges), specs.allowGroupSwitching};
Ana Kruleced3a8cc2019-11-14 00:55:07 +01008092
Dominik Laskowski36dced82022-09-02 09:24:00 -07008093 return setDesiredDisplayModeSpecsInternal(display, policy);
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07008094 }
8095 });
8096
8097 return future.get();
Ana Krulec234bb162019-11-10 22:55:55 +01008098}
8099
Marin Shalamanov228f46b2021-01-28 21:11:45 +01008100status_t SurfaceFlinger::getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
Ady Abraham285f8c12022-10-11 17:12:14 -07008101 gui::DisplayModeSpecs* outSpecs) {
Ana Krulec234bb162019-11-10 22:55:55 +01008102 ATRACE_CALL();
8103
Ady Abraham285f8c12022-10-11 17:12:14 -07008104 if (!displayToken || !outSpecs) {
Ana Krulec234bb162019-11-10 22:55:55 +01008105 return BAD_VALUE;
8106 }
8107
8108 Mutex::Autolock lock(mStateLock);
8109 const auto display = getDisplayDeviceLocked(displayToken);
8110 if (!display) {
8111 return NAME_NOT_FOUND;
8112 }
8113
Ady Abraham3efa3942021-06-24 19:01:25 -07008114 if (display->isVirtual()) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07008115 return INVALID_OPERATION;
Ana Krulec234bb162019-11-10 22:55:55 +01008116 }
Ady Abraham3efa3942021-06-24 19:01:25 -07008117
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04008118 scheduler::RefreshRateSelector::Policy policy =
8119 display->refreshRateSelector().getDisplayManagerPolicy();
Ady Abraham285f8c12022-10-11 17:12:14 -07008120 outSpecs->defaultMode = policy.defaultMode.value();
8121 outSpecs->allowGroupSwitching = policy.allowGroupSwitching;
8122 outSpecs->primaryRanges = translate(policy.primaryRanges);
8123 outSpecs->appRequestRanges = translate(policy.appRequestRanges);
Ady Abraham3efa3942021-06-24 19:01:25 -07008124 return NO_ERROR;
Ana Krulec0782b882019-10-15 17:34:54 -07008125}
8126
Dominik Laskowski75848362019-11-11 17:57:20 -08008127void SurfaceFlinger::onLayerFirstRef(Layer* layer) {
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -07008128 mNumLayers++;
Ady Abrahambe09aad2021-05-03 18:59:38 -07008129 if (!layer->isRemovedFromCurrentState()) {
8130 mScheduler->registerLayer(layer);
8131 }
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -07008132}
8133
8134void SurfaceFlinger::onLayerDestroyed(Layer* layer) {
8135 mNumLayers--;
Robert Carr867be372021-06-29 17:36:02 -07008136 removeHierarchyFromOffscreenLayers(layer);
Ady Abrahambe09aad2021-05-03 18:59:38 -07008137 if (!layer->isRemovedFromCurrentState()) {
8138 mScheduler->deregisterLayer(layer);
8139 }
Dominik Laskowski46471e62022-01-14 15:34:03 -08008140 if (mTransactionTracing) {
8141 mTransactionTracing->onLayerRemoved(layer->getSequence());
Vishnu Nair84125ac2021-12-02 08:47:48 -08008142 }
Ady Abraham822ecbd2023-07-07 16:16:09 -07008143 mScheduler->onLayerDestroyed(layer);
Valerie Hauc5686802019-11-22 14:18:09 -08008144}
8145
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07008146void SurfaceFlinger::onLayerUpdate() {
8147 scheduleCommit(FrameHint::kActive);
8148}
8149
Valerie Hauc5686802019-11-22 14:18:09 -08008150// WARNING: ONLY CALL THIS FROM LAYER DTOR
8151// Here we add children in the current state to offscreen layers and remove the
8152// layer itself from the offscreen layer list. Since
8153// this is the dtor, it is safe to access the current state. This keeps us
8154// from dangling children layers such that they are not reachable from the
8155// Drawing state nor the offscreen layer list
8156// See b/141111965
Robert Carr867be372021-06-29 17:36:02 -07008157void SurfaceFlinger::removeHierarchyFromOffscreenLayers(Layer* layer) {
Valerie Hauc5686802019-11-22 14:18:09 -08008158 for (auto& child : layer->getCurrentChildren()) {
8159 mOffscreenLayers.emplace(child.get());
8160 }
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -07008161 mOffscreenLayers.erase(layer);
8162}
8163
Robert Carr867be372021-06-29 17:36:02 -07008164void SurfaceFlinger::removeFromOffscreenLayers(Layer* layer) {
8165 mOffscreenLayers.erase(layer);
8166}
8167
Vishnu Nair08f6eae2019-11-26 14:01:39 -08008168status_t SurfaceFlinger::setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
8169 float lightPosY, float lightPosZ,
8170 float lightRadius) {
8171 Mutex::Autolock _l(mStateLock);
8172 mCurrentState.globalShadowSettings.ambientColor = vec4(ambientColor);
8173 mCurrentState.globalShadowSettings.spotColor = vec4(spotColor);
8174 mCurrentState.globalShadowSettings.lightPos.y = lightPosY;
8175 mCurrentState.globalShadowSettings.lightPos.z = lightPosZ;
8176 mCurrentState.globalShadowSettings.lightRadius = lightRadius;
8177
8178 // these values are overridden when calculating the shadow settings for a layer.
8179 mCurrentState.globalShadowSettings.lightPos.x = 0.f;
8180 mCurrentState.globalShadowSettings.length = 0.f;
Vishnu Nairb13bb952019-11-15 10:24:08 -08008181 return NO_ERROR;
8182}
8183
Lloyd Pique8d9f8362020-02-11 19:13:09 -08008184const std::unordered_map<std::string, uint32_t>& SurfaceFlinger::getGenericLayerMetadataKeyMap()
8185 const {
8186 // TODO(b/149500060): Remove this fixed/static mapping. Please prefer taking
8187 // on the work to remove the table in that bug rather than adding more to
8188 // it.
8189 static const std::unordered_map<std::string, uint32_t> genericLayerMetadataKeyMap{
Huihong Luod3d8f8e2022-03-08 14:48:46 -08008190 {"org.chromium.arc.V1_0.TaskId", gui::METADATA_TASK_ID},
8191 {"org.chromium.arc.V1_0.CursorInfo", gui::METADATA_MOUSE_CURSOR},
Lloyd Pique8d9f8362020-02-11 19:13:09 -08008192 };
8193 return genericLayerMetadataKeyMap;
8194}
8195
Andy Yu2ae6b6b2021-11-18 14:51:06 -08008196status_t SurfaceFlinger::setOverrideFrameRate(uid_t uid, float frameRate) {
8197 PhysicalDisplayId displayId = [&]() {
8198 Mutex::Autolock lock(mStateLock);
8199 return getDefaultDisplayDeviceLocked()->getPhysicalId();
8200 }();
8201
8202 mScheduler->setGameModeRefreshRateForUid(FrameRateOverride{static_cast<uid_t>(uid), frameRate});
8203 mScheduler->onFrameRateOverridesChanged(mAppConnectionHandle, displayId);
8204 return NO_ERROR;
8205}
8206
Dominik Laskowski20134642020-04-20 22:36:44 -07008207void SurfaceFlinger::enableRefreshRateOverlay(bool enable) {
ramindanib2158ee2023-02-13 20:29:59 -08008208 bool setByHwc = getHwComposer().hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG);
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07008209 for (const auto& [id, display] : mPhysicalDisplays) {
8210 if (display.snapshot().connectionType() == ui::DisplayConnectionType::Internal) {
8211 if (const auto device = getDisplayDeviceLocked(id)) {
ramindani3c722da2023-07-12 20:37:59 -07008212 const auto enableOverlay = [&](const bool setByHwc) FTL_FAKE_GUARD(
8213 kMainThreadContext) {
8214 device->enableRefreshRateOverlay(enable, setByHwc, mRefreshRateOverlaySpinner,
8215 mRefreshRateOverlayRenderRate,
8216 mRefreshRateOverlayShowInMiddle);
8217 };
8218 enableOverlay(setByHwc);
8219 if (setByHwc) {
8220 const auto status =
8221 getHwComposer().setRefreshRateChangedCallbackDebugEnabled(id, enable);
8222 if (status != NO_ERROR) {
8223 ALOGE("Error updating the refresh rate changed callback debug enabled");
8224 enableOverlay(/*setByHwc*/ false);
8225 }
8226 }
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07008227 }
Dominik Laskowski20134642020-04-20 22:36:44 -07008228 }
Ady Abraham1b11bc62021-06-03 19:51:19 -07008229 }
Dominik Laskowski20134642020-04-20 22:36:44 -07008230}
8231
Sally Qi147581b2023-06-27 11:55:34 -07008232void SurfaceFlinger::enableHdrSdrRatioOverlay(bool enable) {
8233 for (const auto& [id, display] : mPhysicalDisplays) {
8234 if (display.snapshot().connectionType() == ui::DisplayConnectionType::Internal) {
8235 if (const auto device = getDisplayDeviceLocked(id)) {
8236 device->enableHdrSdrRatioOverlay(enable);
8237 }
8238 }
8239 }
8240}
8241
Huihong Luo02186fb2022-02-23 14:21:54 -08008242int SurfaceFlinger::getGpuContextPriority() {
Alec Mourid6f09462020-12-07 11:18:17 -08008243 return getRenderEngine().getContextPriority();
Ana Krulec31f2b3c2020-12-14 14:30:09 -08008244}
8245
Ady Abraham899dcdb2021-06-15 16:56:21 -07008246int SurfaceFlinger::calculateMaxAcquiredBufferCount(Fps refreshRate,
Lloyd Pique30db6402023-06-26 18:56:51 +00008247 std::chrono::nanoseconds presentLatency) {
Ady Abraham899dcdb2021-06-15 16:56:21 -07008248 auto pipelineDepth = presentLatency.count() / refreshRate.getPeriodNsecs();
8249 if (presentLatency.count() % refreshRate.getPeriodNsecs()) {
Ady Abraham564f9de2021-02-03 18:34:33 -08008250 pipelineDepth++;
8251 }
Lloyd Pique30db6402023-06-26 18:56:51 +00008252 return std::max(minAcquiredBuffers, static_cast<int64_t>(pipelineDepth - 1));
Ady Abraham564f9de2021-02-03 18:34:33 -08008253}
8254
Ady Abraham899dcdb2021-06-15 16:56:21 -07008255status_t SurfaceFlinger::getMaxAcquiredBufferCount(int* buffers) const {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07008256 Fps maxRefreshRate = 60_Hz;
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07008257
8258 if (!getHwComposer().isHeadless()) {
8259 if (const auto display = getDefaultDisplayDevice()) {
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04008260 maxRefreshRate = display->refreshRateSelector().getSupportedRefreshRateRange().max;
Ady Abraham3efa3942021-06-24 19:01:25 -07008261 }
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07008262 }
8263
8264 *buffers = getMaxAcquiredBufferCountForRefreshRate(maxRefreshRate);
Ady Abraham564f9de2021-02-03 18:34:33 -08008265 return NO_ERROR;
8266}
8267
rnleeed20fa42021-08-10 18:00:03 -07008268uint32_t SurfaceFlinger::getMaxAcquiredBufferCountForCurrentRefreshRate(uid_t uid) const {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07008269 Fps refreshRate = 60_Hz;
Ady Abraham3efa3942021-06-24 19:01:25 -07008270
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07008271 if (const auto frameRateOverride = mScheduler->getFrameRateOverride(uid)) {
8272 refreshRate = *frameRateOverride;
8273 } else if (!getHwComposer().isHeadless()) {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08008274 if (const auto display = FTL_FAKE_GUARD(mStateLock, getDefaultDisplayDeviceLocked())) {
Ady Abrahamace3d052022-11-17 16:25:05 -08008275 refreshRate = display->refreshRateSelector().getActiveMode().fps;
Ady Abraham3efa3942021-06-24 19:01:25 -07008276 }
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07008277 }
Ady Abraham3efa3942021-06-24 19:01:25 -07008278
Ady Abraham899dcdb2021-06-15 16:56:21 -07008279 return getMaxAcquiredBufferCountForRefreshRate(refreshRate);
8280}
8281
8282int SurfaceFlinger::getMaxAcquiredBufferCountForRefreshRate(Fps refreshRate) const {
8283 const auto vsyncConfig = mVsyncConfiguration->getConfigsForRefreshRate(refreshRate).late;
8284 const auto presentLatency = vsyncConfig.appWorkDuration + vsyncConfig.sfWorkDuration;
8285 return calculateMaxAcquiredBufferCount(refreshRate, presentLatency);
8286}
8287
Dominik Laskowski08fbd852022-07-14 08:53:42 -07008288void SurfaceFlinger::handleLayerCreatedLocked(const LayerCreatedState& state, VsyncId vsyncId) {
Vishnu Nair0fc7af52022-01-13 08:11:34 -08008289 sp<Layer> layer = state.layer.promote();
arthurhungdba591c2021-02-08 17:28:49 +08008290 if (!layer) {
Vishnu Nair0fc7af52022-01-13 08:11:34 -08008291 ALOGD("Layer was destroyed soon after creation %p", state.layer.unsafe_get());
8292 return;
arthurhungdba591c2021-02-08 17:28:49 +08008293 }
Josh Gao194ff392022-09-08 16:19:29 -07008294 MUTEX_ALIAS(mStateLock, layer->mFlinger->mStateLock);
arthurhungdba591c2021-02-08 17:28:49 +08008295
8296 sp<Layer> parent;
Vishnu Nair0fc7af52022-01-13 08:11:34 -08008297 bool addToRoot = state.addToRoot;
8298 if (state.initialParent != nullptr) {
8299 parent = state.initialParent.promote();
arthurhungdba591c2021-02-08 17:28:49 +08008300 if (parent == nullptr) {
Vishnu Nair0fc7af52022-01-13 08:11:34 -08008301 ALOGD("Parent was destroyed soon after creation %p", state.initialParent.unsafe_get());
Garfield Tand712ad32021-10-27 13:44:22 -07008302 addToRoot = false;
arthurhungdba591c2021-02-08 17:28:49 +08008303 }
arthurhungdba591c2021-02-08 17:28:49 +08008304 }
8305
Garfield Tand712ad32021-10-27 13:44:22 -07008306 if (parent == nullptr && addToRoot) {
Vishnu Nair14d218b2021-07-13 13:57:39 -07008307 layer->setIsAtRoot(true);
arthurhungdba591c2021-02-08 17:28:49 +08008308 mCurrentState.layersSortedByZ.add(layer);
8309 } else if (parent == nullptr) {
8310 layer->onRemovedFromCurrentState();
8311 } else if (parent->isRemovedFromCurrentState()) {
8312 parent->addChild(layer);
8313 layer->onRemovedFromCurrentState();
8314 } else {
8315 parent->addChild(layer);
8316 }
8317
Vishnu Nair73908d12022-10-24 21:46:42 -07008318 ui::LayerStack layerStack = layer->getLayerStack(LayerVector::StateSet::Current);
Vishnu Nairafd527a2022-10-18 08:56:10 -07008319 sp<const DisplayDevice> hintDisplay;
8320 // Find the display that includes the layer.
8321 for (const auto& [token, display] : mDisplays) {
8322 if (display->getLayerStack() == layerStack) {
8323 hintDisplay = display;
8324 break;
8325 }
8326 }
8327
8328 if (hintDisplay) {
8329 layer->updateTransformHint(hintDisplay->getTransformHint());
8330 }
arthurhungdba591c2021-02-08 17:28:49 +08008331}
Ady Abraham562c2712021-05-07 15:10:42 -07008332
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07008333void SurfaceFlinger::sample() {
Lloyd Pique30db6402023-06-26 18:56:51 +00008334 if (!mLumaSampling || !mRegionSamplingThread) {
Ady Abraham562c2712021-05-07 15:10:42 -07008335 return;
8336 }
8337
Dominik Laskowski756b7892021-08-04 12:53:59 -07008338 mRegionSamplingThread->onCompositionComplete(mScheduler->getScheduledFrameTime());
Ady Abraham562c2712021-05-07 15:10:42 -07008339}
8340
Dominik Laskowski39dfc942023-02-08 16:27:05 -05008341void SurfaceFlinger::onActiveDisplaySizeChanged(const DisplayDevice& activeDisplay) {
8342 mScheduler->onActiveDisplayAreaChanged(activeDisplay.getWidth() * activeDisplay.getHeight());
8343 getRenderEngine().onActiveDisplaySizeChanged(activeDisplay.getSize());
Ady Abrahamed3290f2021-05-17 15:12:14 -07008344}
8345
Dominik Laskowski39dfc942023-02-08 16:27:05 -05008346void SurfaceFlinger::onActiveDisplayChangedLocked(const DisplayDevice* inactiveDisplayPtr,
8347 const DisplayDevice& activeDisplay) {
Ady Abrahamed3290f2021-05-17 15:12:14 -07008348 ATRACE_CALL();
8349
Dominik Laskowski360ae782023-02-22 13:30:37 -05008350 // For the first display activated during boot, there is no need to force setDesiredActiveMode,
8351 // because DM is about to send its policy via setDesiredDisplayModeSpecs.
8352 bool forceApplyPolicy = false;
8353
Dominik Laskowski39dfc942023-02-08 16:27:05 -05008354 if (inactiveDisplayPtr) {
8355 inactiveDisplayPtr->getCompositionDisplay()->setLayerCachingTexturePoolEnabled(false);
Dominik Laskowski360ae782023-02-22 13:30:37 -05008356 forceApplyPolicy = true;
Ady Abrahamdb036a82021-07-16 14:18:34 -07008357 }
8358
Dominik Laskowski39dfc942023-02-08 16:27:05 -05008359 mActiveDisplayId = activeDisplay.getPhysicalId();
8360 activeDisplay.getCompositionDisplay()->setLayerCachingTexturePoolEnabled(true);
Dominik Laskowski596a2562022-10-28 11:26:12 -04008361
Dominik Laskowski14956dc2023-02-22 13:43:57 -05008362 resetPhaseConfiguration(activeDisplay.getActiveMode().fps);
8363
Dominik Laskowskifdac5652023-06-29 12:01:13 -04008364 // TODO(b/255635711): Check for pending mode changes on other displays.
Ady Abraham690f4612021-07-01 23:24:03 -07008365 mScheduler->setModeChangePending(false);
Dominik Laskowskifdac5652023-06-29 12:01:13 -04008366
Leon Scroggins III1af0fb62023-03-02 14:21:44 -05008367 mScheduler->setPacesetterDisplay(mActiveDisplayId);
Dominik Laskowski596a2562022-10-28 11:26:12 -04008368
Ady Abrahamed3290f2021-05-17 15:12:14 -07008369 onActiveDisplaySizeChanged(activeDisplay);
Dominik Laskowski39dfc942023-02-08 16:27:05 -05008370 mActiveDisplayTransformHint = activeDisplay.getTransformHint();
Leon Scroggins III85d4b222023-05-09 13:58:18 -04008371 sActiveDisplayRotationFlags = ui::Transform::toRotationFlags(activeDisplay.getOrientation());
Ady Abraham85d692d2021-09-28 14:08:54 -07008372
Leon Scroggins III1af0fb62023-03-02 14:21:44 -05008373 // The policy of the new active/pacesetter display may have changed while it was inactive. In
8374 // that case, its preferred mode has not been propagated to HWC (via setDesiredActiveMode). In
8375 // either case, the Scheduler's cachedModeChangedParams must be initialized to the newly active
8376 // mode, and the kernel idle timer of the newly active display must be toggled.
Dominik Laskowski360ae782023-02-22 13:30:37 -05008377 applyRefreshRateSelectorPolicy(mActiveDisplayId, activeDisplay.refreshRateSelector(),
8378 forceApplyPolicy);
Ady Abrahamed3290f2021-05-17 15:12:14 -07008379}
8380
Patrick Williamsacd22582023-07-12 13:47:28 -05008381status_t SurfaceFlinger::addWindowInfosListener(const sp<IWindowInfosListener>& windowInfosListener,
8382 gui::WindowInfosListenerInfo* outInfo) {
8383 mWindowInfosListenerInvoker->addWindowInfosListener(windowInfosListener, outInfo);
Patrick Williamsaf06b792023-02-16 17:46:22 -06008384 setTransactionFlags(eInputInfoUpdateNeeded);
chaviw60c9d3e2021-06-04 12:52:17 -05008385 return NO_ERROR;
8386}
8387
8388status_t SurfaceFlinger::removeWindowInfosListener(
8389 const sp<IWindowInfosListener>& windowInfosListener) const {
8390 mWindowInfosListenerInvoker->removeWindowInfosListener(windowInfosListener);
8391 return NO_ERROR;
8392}
8393
Vishnu Nairdbbe3852022-01-12 20:22:11 -08008394std::shared_ptr<renderengine::ExternalTexture> SurfaceFlinger::getExternalTextureFromBufferData(
Patrick Williamsf1e5df12022-10-17 21:37:42 +00008395 BufferData& bufferData, const char* layerName, uint64_t transactionId) {
8396 if (bufferData.buffer &&
8397 exceedsMaxRenderTargetSize(bufferData.buffer->getWidth(), bufferData.buffer->getHeight())) {
Patrick Williamsae9ab532022-11-14 18:41:38 +00008398 std::string errorMessage =
8399 base::StringPrintf("Attempted to create an ExternalTexture with size (%u, %u) for "
8400 "layer %s that exceeds render target size limit of %u.",
8401 bufferData.buffer->getWidth(), bufferData.buffer->getHeight(),
8402 layerName, static_cast<uint32_t>(mMaxRenderTargetSize));
8403 ALOGD("%s", errorMessage.c_str());
8404 if (bufferData.releaseBufferListener) {
Huihong Luoffee3bc2023-01-17 16:14:35 +00008405 bufferData.releaseBufferListener->onTransactionQueueStalled(
8406 String8(errorMessage.c_str()));
Patrick Williamsae9ab532022-11-14 18:41:38 +00008407 }
Patrick Williamsf1e5df12022-10-17 21:37:42 +00008408 return nullptr;
Vishnu Nairdbbe3852022-01-12 20:22:11 -08008409 }
Patrick Williamsf1e5df12022-10-17 21:37:42 +00008410
8411 bool cachedBufferChanged =
8412 bufferData.flags.test(BufferData::BufferDataChange::cachedBufferChanged);
8413 if (cachedBufferChanged && bufferData.buffer) {
8414 auto result = ClientCache::getInstance().add(bufferData.cachedBuffer, bufferData.buffer);
8415 if (result.ok()) {
8416 return result.value();
8417 }
8418
8419 if (result.error() == ClientCache::AddError::CacheFull) {
Vishnu Nair40fff5c2022-11-04 02:46:28 +00008420 ALOGE("Attempted to create an ExternalTexture for layer %s but CacheFull", layerName);
8421
8422 if (bufferData.releaseBufferListener) {
8423 bufferData.releaseBufferListener->onTransactionQueueStalled(
Huihong Luoffee3bc2023-01-17 16:14:35 +00008424 String8("Buffer processing hung due to full buffer cache"));
Vishnu Nair40fff5c2022-11-04 02:46:28 +00008425 }
Patrick Williamsf1e5df12022-10-17 21:37:42 +00008426 }
8427
8428 return nullptr;
8429 }
8430
8431 if (cachedBufferChanged) {
8432 return ClientCache::getInstance().get(bufferData.cachedBuffer);
8433 }
8434
8435 if (bufferData.buffer) {
8436 return std::make_shared<
8437 renderengine::impl::ExternalTexture>(bufferData.buffer, getRenderEngine(),
8438 renderengine::impl::ExternalTexture::Usage::
8439 READABLE);
8440 }
8441
8442 return nullptr;
Vishnu Nairdbbe3852022-01-12 20:22:11 -08008443}
Vishnu Nair0fc7af52022-01-13 08:11:34 -08008444
Dominik Laskowski08fbd852022-07-14 08:53:42 -07008445bool SurfaceFlinger::commitMirrorDisplays(VsyncId vsyncId) {
Chavi Weingarten7043a7d2022-07-19 23:40:35 +00008446 std::vector<MirrorDisplayState> mirrorDisplays;
8447 {
8448 std::scoped_lock<std::mutex> lock(mMirrorDisplayLock);
8449 mirrorDisplays = std::move(mMirrorDisplays);
8450 mMirrorDisplays.clear();
8451 if (mirrorDisplays.size() == 0) {
8452 return false;
8453 }
8454 }
8455
8456 sp<IBinder> unused;
8457 for (const auto& mirrorDisplay : mirrorDisplays) {
8458 // Set mirror layer's default layer stack to -1 so it doesn't end up rendered on a display
8459 // accidentally.
Vishnu Nair07e2a482022-10-18 19:18:16 +00008460 sp<Layer> rootMirrorLayer = LayerHandle::getLayer(mirrorDisplay.rootHandle);
Chavi Weingarten7043a7d2022-07-19 23:40:35 +00008461 rootMirrorLayer->setLayerStack(ui::LayerStack::fromValue(-1));
8462 for (const auto& layer : mDrawingState.layersSortedByZ) {
8463 if (layer->getLayerStack() != mirrorDisplay.layerStack ||
8464 layer->isInternalDisplayOverlay()) {
8465 continue;
8466 }
8467
8468 LayerCreationArgs mirrorArgs(this, mirrorDisplay.client, "MirrorLayerParent",
8469 ISurfaceComposerClient::eNoColorFill,
8470 gui::LayerMetadata());
8471 sp<Layer> childMirror;
Ying Wei2cf827f2023-03-22 22:25:28 +00008472 {
8473 Mutex::Autolock lock(mStateLock);
8474 createEffectLayer(mirrorArgs, &unused, &childMirror);
Josh Gao194ff392022-09-08 16:19:29 -07008475 MUTEX_ALIAS(mStateLock, childMirror->mFlinger->mStateLock);
Vishnu Nairde177252023-04-21 12:44:10 -07008476 childMirror->setClonedChild(layer->createClone(childMirror->getSequence()));
Ying Wei2cf827f2023-03-22 22:25:28 +00008477 childMirror->reparent(mirrorDisplay.rootHandle);
8478 }
8479 // lock on mStateLock needs to be released before binder handle gets destroyed
8480 unused.clear();
Chavi Weingarten7043a7d2022-07-19 23:40:35 +00008481 }
8482 }
8483 return true;
8484}
8485
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008486bool SurfaceFlinger::commitCreatedLayers(VsyncId vsyncId,
8487 std::vector<LayerCreatedState>& createdLayers) {
8488 if (createdLayers.size() == 0) {
8489 return false;
Vishnu Nair0fc7af52022-01-13 08:11:34 -08008490 }
8491
8492 Mutex::Autolock _l(mStateLock);
8493 for (const auto& createdLayer : createdLayers) {
Vishnu Nair286f4f92022-06-08 16:37:39 -07008494 handleLayerCreatedLocked(createdLayer, vsyncId);
Vishnu Nair0fc7af52022-01-13 08:11:34 -08008495 }
Vishnu Nair0fc7af52022-01-13 08:11:34 -08008496 mLayersAdded = true;
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008497 return mLayersAdded;
Vishnu Nair0fc7af52022-01-13 08:11:34 -08008498}
Huihong Luof5029222021-12-16 14:33:46 -08008499
Vishnu Nair0a4fb002022-08-08 02:40:42 +00008500void SurfaceFlinger::updateLayerMetadataSnapshot() {
8501 LayerMetadata parentMetadata;
8502 for (const auto& layer : mDrawingState.layersSortedByZ) {
8503 layer->updateMetadataSnapshot(parentMetadata);
8504 }
8505
8506 std::unordered_set<Layer*> visited;
8507 mDrawingState.traverse([&visited](Layer* layer) {
8508 if (visited.find(layer) != visited.end()) {
8509 return;
8510 }
8511
8512 // If the layer isRelativeOf, then either it's relative metadata will be set
8513 // recursively when updateRelativeMetadataSnapshot is called on its relative parent or
8514 // it's relative parent has been deleted. Clear the layer's relativeLayerMetadata to ensure
8515 // that layers with deleted relative parents don't hold stale relativeLayerMetadata.
8516 if (layer->getDrawingState().isRelativeOf) {
8517 layer->editLayerSnapshot()->relativeLayerMetadata = {};
8518 return;
8519 }
8520
8521 layer->updateRelativeMetadataSnapshot({}, visited);
8522 });
8523}
8524
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008525void SurfaceFlinger::moveSnapshotsFromCompositionArgs(
8526 compositionengine::CompositionRefreshArgs& refreshArgs,
Dominik Laskowski16a345b2023-04-27 17:07:33 -04008527 const std::vector<std::pair<Layer*, LayerFE*>>& layers) {
Lloyd Pique30db6402023-06-26 18:56:51 +00008528 if (mLayerLifecycleManagerEnabled) {
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008529 std::vector<std::unique_ptr<frontend::LayerSnapshot>>& snapshots =
8530 mLayerSnapshotBuilder.getSnapshots();
8531 for (auto [_, layerFE] : layers) {
8532 auto i = layerFE->mSnapshot->globalZ;
8533 snapshots[i] = std::move(layerFE->mSnapshot);
8534 }
8535 }
Lloyd Pique30db6402023-06-26 18:56:51 +00008536 if (mLegacyFrontEndEnabled && !mLayerLifecycleManagerEnabled) {
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008537 for (auto [layer, layerFE] : layers) {
8538 layer->updateLayerSnapshot(std::move(layerFE->mSnapshot));
8539 }
8540 }
8541}
8542
8543std::vector<std::pair<Layer*, LayerFE*>> SurfaceFlinger::moveSnapshotsToCompositionArgs(
Dominik Laskowski16a345b2023-04-27 17:07:33 -04008544 compositionengine::CompositionRefreshArgs& refreshArgs, bool cursorOnly) {
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008545 std::vector<std::pair<Layer*, LayerFE*>> layers;
Lloyd Pique30db6402023-06-26 18:56:51 +00008546 if (mLayerLifecycleManagerEnabled) {
Vishnu Nairc765c6c2023-02-23 00:08:01 +00008547 nsecs_t currentTime = systemTime();
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008548 mLayerSnapshotBuilder.forEachVisibleSnapshot(
8549 [&](std::unique_ptr<frontend::LayerSnapshot>& snapshot) {
8550 if (cursorOnly &&
8551 snapshot->compositionType !=
8552 aidl::android::hardware::graphics::composer3::Composition::CURSOR) {
8553 return;
8554 }
8555
8556 if (!snapshot->hasSomethingToDraw()) {
8557 return;
8558 }
8559
8560 auto it = mLegacyLayers.find(snapshot->sequence);
8561 LOG_ALWAYS_FATAL_IF(it == mLegacyLayers.end(),
8562 "Couldnt find layer object for %s",
8563 snapshot->getDebugString().c_str());
8564 auto& legacyLayer = it->second;
8565 sp<LayerFE> layerFE = legacyLayer->getCompositionEngineLayerFE(snapshot->path);
Vishnu Nairc765c6c2023-02-23 00:08:01 +00008566 snapshot->fps = getLayerFramerate(currentTime, snapshot->sequence);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008567 layerFE->mSnapshot = std::move(snapshot);
8568 refreshArgs.layers.push_back(layerFE);
8569 layers.emplace_back(legacyLayer.get(), layerFE.get());
8570 });
8571 }
Lloyd Pique30db6402023-06-26 18:56:51 +00008572 if (mLegacyFrontEndEnabled && !mLayerLifecycleManagerEnabled) {
Vishnu Nair802ac4f2023-05-10 13:55:22 -07008573 auto moveSnapshots = [&layers, &refreshArgs, cursorOnly](Layer* layer) {
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008574 if (const auto& layerFE = layer->getCompositionEngineLayerFE()) {
8575 if (cursorOnly &&
8576 layer->getLayerSnapshot()->compositionType !=
8577 aidl::android::hardware::graphics::composer3::Composition::CURSOR)
8578 return;
8579 layer->updateSnapshot(refreshArgs.updatingGeometryThisFrame);
8580 layerFE->mSnapshot = layer->stealLayerSnapshot();
8581 refreshArgs.layers.push_back(layerFE);
8582 layers.emplace_back(layer, layerFE.get());
8583 }
Vishnu Nair802ac4f2023-05-10 13:55:22 -07008584 };
8585
8586 if (cursorOnly || !mVisibleRegionsDirty) {
8587 // for hot path avoid traversals by walking though the previous composition list
8588 for (sp<Layer> layer : mPreviouslyComposedLayers) {
8589 moveSnapshots(layer.get());
8590 }
8591 } else {
8592 mPreviouslyComposedLayers.clear();
8593 mDrawingState.traverseInZOrder(
8594 [&moveSnapshots](Layer* layer) { moveSnapshots(layer); });
8595 mPreviouslyComposedLayers.reserve(layers.size());
8596 for (auto [layer, _] : layers) {
8597 mPreviouslyComposedLayers.push_back(sp<Layer>::fromExisting(layer));
8598 }
8599 }
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008600 }
8601
8602 return layers;
8603}
8604
8605std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()>
Vishnu Nairc5a5b6e2023-02-28 00:19:07 +00008606SurfaceFlinger::getLayerSnapshotsForScreenshots(
8607 std::optional<ui::LayerStack> layerStack, uint32_t uid,
8608 std::function<bool(const frontend::LayerSnapshot&, bool& outStopTraversal)>
8609 snapshotFilterFn) {
Vishnu Naird47bcee2023-02-24 18:08:51 +00008610 return [&, layerStack, uid]() {
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008611 std::vector<std::pair<Layer*, sp<LayerFE>>> layers;
Vishnu Nairc5a5b6e2023-02-28 00:19:07 +00008612 bool stopTraversal = false;
Vishnu Naird47bcee2023-02-24 18:08:51 +00008613 mLayerSnapshotBuilder.forEachVisibleSnapshot(
8614 [&](std::unique_ptr<frontend::LayerSnapshot>& snapshot) {
Vishnu Nairc5a5b6e2023-02-28 00:19:07 +00008615 if (stopTraversal) {
8616 return;
8617 }
Vishnu Naird47bcee2023-02-24 18:08:51 +00008618 if (layerStack && snapshot->outputFilter.layerStack != *layerStack) {
8619 return;
8620 }
Vishnu Naira02943f2023-06-03 13:44:46 -07008621 if (uid != CaptureArgs::UNSET_UID && snapshot->uid != gui::Uid(uid)) {
Vishnu Naird47bcee2023-02-24 18:08:51 +00008622 return;
8623 }
8624 if (!snapshot->hasSomethingToDraw()) {
8625 return;
8626 }
Vishnu Nairc5a5b6e2023-02-28 00:19:07 +00008627 if (snapshotFilterFn && !snapshotFilterFn(*snapshot, stopTraversal)) {
8628 return;
8629 }
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008630
Vishnu Naird47bcee2023-02-24 18:08:51 +00008631 auto it = mLegacyLayers.find(snapshot->sequence);
8632 LOG_ALWAYS_FATAL_IF(it == mLegacyLayers.end(),
8633 "Couldnt find layer object for %s",
8634 snapshot->getDebugString().c_str());
8635 Layer* legacyLayer = (it == mLegacyLayers.end()) ? nullptr : it->second.get();
8636 sp<LayerFE> layerFE = getFactory().createLayerFE(snapshot->name);
8637 layerFE->mSnapshot = std::make_unique<frontend::LayerSnapshot>(*snapshot);
8638 layers.emplace_back(legacyLayer, std::move(layerFE));
8639 });
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008640
8641 return layers;
8642 };
8643}
8644
8645std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()>
Ajinkya Chalke02844632023-03-01 12:10:14 +00008646SurfaceFlinger::getLayerSnapshotsForScreenshots(std::optional<ui::LayerStack> layerStack,
8647 uint32_t uid,
8648 std::unordered_set<uint32_t> excludeLayerIds) {
8649 return [&, layerStack, uid, excludeLayerIds = std::move(excludeLayerIds)]() {
8650 if (excludeLayerIds.empty()) {
8651 auto getLayerSnapshotsFn =
8652 getLayerSnapshotsForScreenshots(layerStack, uid, /*snapshotFilterFn=*/nullptr);
8653 std::vector<std::pair<Layer*, sp<LayerFE>>> layers = getLayerSnapshotsFn();
8654 return layers;
8655 }
8656
8657 frontend::LayerSnapshotBuilder::Args
8658 args{.root = mLayerHierarchyBuilder.getHierarchy(),
8659 .layerLifecycleManager = mLayerLifecycleManager,
8660 .forceUpdate = frontend::LayerSnapshotBuilder::ForceUpdateFlags::HIERARCHY,
8661 .displays = mFrontEndDisplayInfos,
8662 .displayChanges = true,
8663 .globalShadowSettings = mDrawingState.globalShadowSettings,
Lloyd Pique30db6402023-06-26 18:56:51 +00008664 .supportsBlur = mSupportsBlur,
Ajinkya Chalke02844632023-03-01 12:10:14 +00008665 .forceFullDamage = mForceFullDamage,
8666 .excludeLayerIds = std::move(excludeLayerIds),
8667 .supportedLayerGenericMetadata =
8668 getHwComposer().getSupportedLayerGenericMetadata(),
Vishnu Nair0808ae62023-08-07 21:42:42 -07008669 .genericLayerMetadataKeyMap = getGenericLayerMetadataKeyMap(),
8670 .skipRoundCornersWhenProtected =
8671 !getRenderEngine().supportsProtectedContent()};
Ajinkya Chalke02844632023-03-01 12:10:14 +00008672 mLayerSnapshotBuilder.update(args);
8673
8674 auto getLayerSnapshotsFn =
8675 getLayerSnapshotsForScreenshots(layerStack, uid, /*snapshotFilterFn=*/nullptr);
8676 std::vector<std::pair<Layer*, sp<LayerFE>>> layers = getLayerSnapshotsFn();
8677
8678 args.excludeLayerIds.clear();
8679 mLayerSnapshotBuilder.update(args);
8680
8681 return layers;
8682 };
8683}
8684
8685std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()>
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008686SurfaceFlinger::getLayerSnapshotsForScreenshots(uint32_t rootLayerId, uint32_t uid,
8687 std::unordered_set<uint32_t> excludeLayerIds,
Vishnu Nair36d5f8e2023-03-19 13:31:35 -07008688 bool childrenOnly,
8689 const std::optional<FloatRect>& parentCrop) {
Vishnu Naird47bcee2023-02-24 18:08:51 +00008690 return [&, rootLayerId, uid, excludeLayerIds = std::move(excludeLayerIds), childrenOnly,
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008691 parentCrop]() {
Vishnu Naird47bcee2023-02-24 18:08:51 +00008692 auto root = mLayerHierarchyBuilder.getPartialHierarchy(rootLayerId, childrenOnly);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008693 frontend::LayerSnapshotBuilder::Args
Vishnu Naird47bcee2023-02-24 18:08:51 +00008694 args{.root = root,
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008695 .layerLifecycleManager = mLayerLifecycleManager,
Vishnu Naird47bcee2023-02-24 18:08:51 +00008696 .forceUpdate = frontend::LayerSnapshotBuilder::ForceUpdateFlags::HIERARCHY,
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008697 .displays = mFrontEndDisplayInfos,
8698 .displayChanges = true,
8699 .globalShadowSettings = mDrawingState.globalShadowSettings,
Lloyd Pique30db6402023-06-26 18:56:51 +00008700 .supportsBlur = mSupportsBlur,
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008701 .forceFullDamage = mForceFullDamage,
Vishnu Nair36d5f8e2023-03-19 13:31:35 -07008702 .parentCrop = parentCrop,
Vishnu Nairc765c6c2023-02-23 00:08:01 +00008703 .excludeLayerIds = std::move(excludeLayerIds),
8704 .supportedLayerGenericMetadata =
8705 getHwComposer().getSupportedLayerGenericMetadata(),
Vishnu Nair0808ae62023-08-07 21:42:42 -07008706 .genericLayerMetadataKeyMap = getGenericLayerMetadataKeyMap(),
8707 .skipRoundCornersWhenProtected =
8708 !getRenderEngine().supportsProtectedContent()};
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008709 mLayerSnapshotBuilder.update(args);
8710
Vishnu Nairc5a5b6e2023-02-28 00:19:07 +00008711 auto getLayerSnapshotsFn =
8712 getLayerSnapshotsForScreenshots({}, uid, /*snapshotFilterFn=*/nullptr);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008713 std::vector<std::pair<Layer*, sp<LayerFE>>> layers = getLayerSnapshotsFn();
8714 args.root = mLayerHierarchyBuilder.getHierarchy();
8715 args.parentCrop.reset();
8716 args.excludeLayerIds.clear();
8717 mLayerSnapshotBuilder.update(args);
8718 return layers;
8719 };
8720}
8721
Vishnu Nair81750622023-03-08 15:02:06 -08008722frontend::Update SurfaceFlinger::flushLifecycleUpdates() {
8723 frontend::Update update;
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008724 ATRACE_NAME("TransactionHandler:flushTransactions");
8725 // Locking:
8726 // 1. to prevent onHandleDestroyed from being called while the state lock is held,
8727 // we must keep a copy of the transactions (specifically the composer
8728 // states) around outside the scope of the lock.
8729 // 2. Transactions and created layers do not share a lock. To prevent applying
8730 // transactions with layers still in the createdLayer queue, flush the transactions
8731 // before committing the created layers.
Vishnu Nair4d9cef92023-06-24 22:34:41 +00008732 mTransactionHandler.collectTransactions();
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008733 update.transactions = mTransactionHandler.flushTransactions();
8734 {
8735 // TODO(b/238781169) lockless queue this and keep order.
8736 std::scoped_lock<std::mutex> lock(mCreatedLayersLock);
8737 update.layerCreatedStates = std::move(mCreatedLayers);
8738 mCreatedLayers.clear();
8739 update.newLayers = std::move(mNewLayers);
8740 mNewLayers.clear();
Vishnu Nair81750622023-03-08 15:02:06 -08008741 update.layerCreationArgs = std::move(mNewLayerArgs);
8742 mNewLayerArgs.clear();
Vishnu Nair3af0ec02023-02-10 04:13:48 +00008743 update.destroyedHandles = std::move(mDestroyedHandles);
8744 mDestroyedHandles.clear();
8745 }
8746 return update;
8747}
8748
Dominik Laskowski16a345b2023-04-27 17:07:33 -04008749void SurfaceFlinger::addToLayerTracing(bool visibleRegionDirty, TimePoint time, VsyncId vsyncId) {
Vishnu Nair81750622023-03-08 15:02:06 -08008750 const uint32_t tracingFlags = mLayerTracing.getFlags();
8751 LayersProto layers(dumpDrawingStateProto(tracingFlags));
8752 if (tracingFlags & LayerTracing::TRACE_EXTRA) {
8753 dumpOffscreenLayersProto(layers);
8754 }
8755 std::string hwcDump;
8756 if (tracingFlags & LayerTracing::TRACE_HWC) {
8757 dumpHwc(hwcDump);
8758 }
8759 auto displays = dumpDisplayProto();
Dominik Laskowski16a345b2023-04-27 17:07:33 -04008760 mLayerTracing.notify(visibleRegionDirty, time.ns(), ftl::to_underlying(vsyncId), &layers,
8761 std::move(hwcDump), &displays);
Vishnu Nair81750622023-03-08 15:02:06 -08008762}
8763
Huihong Luof5029222021-12-16 14:33:46 -08008764// gui::ISurfaceComposer
Huihong Luo07e72362022-02-14 14:26:04 -08008765
Huihong Luo1b0c49f2022-03-15 19:18:21 -07008766binder::Status SurfaceComposerAIDL::bootFinished() {
8767 status_t status = checkAccessPermission();
8768 if (status != OK) {
8769 return binderStatusFromStatusT(status);
8770 }
8771 mFlinger->bootFinished();
8772 return binder::Status::ok();
8773}
8774
8775binder::Status SurfaceComposerAIDL::createDisplayEventConnection(
8776 VsyncSource vsyncSource, EventRegistration eventRegistration,
Rachel Lee2248f522023-01-27 16:45:23 -08008777 const sp<IBinder>& layerHandle, sp<IDisplayEventConnection>* outConnection) {
Huihong Luo1b0c49f2022-03-15 19:18:21 -07008778 sp<IDisplayEventConnection> conn =
Rachel Lee2248f522023-01-27 16:45:23 -08008779 mFlinger->createDisplayEventConnection(vsyncSource, eventRegistration, layerHandle);
Huihong Luo1b0c49f2022-03-15 19:18:21 -07008780 if (conn == nullptr) {
8781 *outConnection = nullptr;
8782 return binderStatusFromStatusT(BAD_VALUE);
8783 } else {
8784 *outConnection = conn;
8785 return binder::Status::ok();
8786 }
8787}
8788
Huihong Luod3d8f8e2022-03-08 14:48:46 -08008789binder::Status SurfaceComposerAIDL::createConnection(sp<gui::ISurfaceComposerClient>* outClient) {
Ady Abrahamd11bade2022-08-01 16:18:03 -07008790 const sp<Client> client = sp<Client>::make(mFlinger);
Huihong Luod3d8f8e2022-03-08 14:48:46 -08008791 if (client->initCheck() == NO_ERROR) {
8792 *outClient = client;
8793 return binder::Status::ok();
8794 } else {
8795 *outClient = nullptr;
8796 return binderStatusFromStatusT(BAD_VALUE);
8797 }
8798}
8799
Huihong Luo07e72362022-02-14 14:26:04 -08008800binder::Status SurfaceComposerAIDL::createDisplay(const std::string& displayName, bool secure,
Huihong Luo1768cb02022-10-11 11:10:34 -07008801 float requestedRefreshRate,
Huihong Luo07e72362022-02-14 14:26:04 -08008802 sp<IBinder>* outDisplay) {
8803 status_t status = checkAccessPermission();
Huihong Luo37396db2022-02-15 10:43:00 -08008804 if (status != OK) {
Huihong Luo3bdef862022-03-03 11:57:19 -08008805 return binderStatusFromStatusT(status);
Huihong Luo07e72362022-02-14 14:26:04 -08008806 }
Huihong Luo37396db2022-02-15 10:43:00 -08008807 String8 displayName8 = String8::format("%s", displayName.c_str());
Huihong Luo1768cb02022-10-11 11:10:34 -07008808 *outDisplay = mFlinger->createDisplay(displayName8, secure, requestedRefreshRate);
Huihong Luo37396db2022-02-15 10:43:00 -08008809 return binder::Status::ok();
Huihong Luo07e72362022-02-14 14:26:04 -08008810}
8811
8812binder::Status SurfaceComposerAIDL::destroyDisplay(const sp<IBinder>& display) {
8813 status_t status = checkAccessPermission();
Huihong Luo37396db2022-02-15 10:43:00 -08008814 if (status != OK) {
Huihong Luo3bdef862022-03-03 11:57:19 -08008815 return binderStatusFromStatusT(status);
Huihong Luo07e72362022-02-14 14:26:04 -08008816 }
Huihong Luo37396db2022-02-15 10:43:00 -08008817 mFlinger->destroyDisplay(display);
8818 return binder::Status::ok();
Huihong Luo07e72362022-02-14 14:26:04 -08008819}
8820
8821binder::Status SurfaceComposerAIDL::getPhysicalDisplayIds(std::vector<int64_t>* outDisplayIds) {
8822 std::vector<PhysicalDisplayId> physicalDisplayIds = mFlinger->getPhysicalDisplayIds();
8823 std::vector<int64_t> displayIds;
8824 displayIds.reserve(physicalDisplayIds.size());
8825 for (auto item : physicalDisplayIds) {
8826 displayIds.push_back(static_cast<int64_t>(item.value));
8827 }
8828 *outDisplayIds = displayIds;
8829 return binder::Status::ok();
8830}
8831
Huihong Luo07e72362022-02-14 14:26:04 -08008832binder::Status SurfaceComposerAIDL::getPhysicalDisplayToken(int64_t displayId,
8833 sp<IBinder>* outDisplay) {
Sally Qi6bb12822022-10-05 11:42:30 -07008834 status_t status = checkAccessPermission();
8835 if (status != OK) {
8836 return binderStatusFromStatusT(status);
8837 }
Huihong Luo07e72362022-02-14 14:26:04 -08008838 const auto id = DisplayId::fromValue<PhysicalDisplayId>(static_cast<uint64_t>(displayId));
8839 *outDisplay = mFlinger->getPhysicalDisplayToken(*id);
8840 return binder::Status::ok();
8841}
8842
Huihong Luo37396db2022-02-15 10:43:00 -08008843binder::Status SurfaceComposerAIDL::setPowerMode(const sp<IBinder>& display, int mode) {
8844 status_t status = checkAccessPermission();
8845 if (status != OK) {
Huihong Luo3bdef862022-03-03 11:57:19 -08008846 return binderStatusFromStatusT(status);
Huihong Luo37396db2022-02-15 10:43:00 -08008847 }
8848 mFlinger->setPowerMode(display, mode);
8849 return binder::Status::ok();
8850}
8851
Huihong Luo0a81aa32022-02-22 16:02:36 -08008852binder::Status SurfaceComposerAIDL::getSupportedFrameTimestamps(
8853 std::vector<FrameEvent>* outSupported) {
8854 status_t status;
8855 if (!outSupported) {
8856 status = UNEXPECTED_NULL;
8857 } else {
8858 outSupported->clear();
8859 status = mFlinger->getSupportedFrameTimestamps(outSupported);
8860 }
Huihong Luo3bdef862022-03-03 11:57:19 -08008861 return binderStatusFromStatusT(status);
Huihong Luo0a81aa32022-02-22 16:02:36 -08008862}
8863
Huihong Luoaa7fc2e2022-02-15 10:43:00 -08008864binder::Status SurfaceComposerAIDL::getDisplayStats(const sp<IBinder>& display,
8865 gui::DisplayStatInfo* outStatInfo) {
8866 DisplayStatInfo statInfo;
8867 status_t status = mFlinger->getDisplayStats(display, &statInfo);
8868 if (status == NO_ERROR) {
8869 outStatInfo->vsyncTime = static_cast<long>(statInfo.vsyncTime);
8870 outStatInfo->vsyncPeriod = static_cast<long>(statInfo.vsyncPeriod);
8871 }
Huihong Luo3bdef862022-03-03 11:57:19 -08008872 return binderStatusFromStatusT(status);
Huihong Luoaa7fc2e2022-02-15 10:43:00 -08008873}
8874
8875binder::Status SurfaceComposerAIDL::getDisplayState(const sp<IBinder>& display,
8876 gui::DisplayState* outState) {
8877 ui::DisplayState state;
8878 status_t status = mFlinger->getDisplayState(display, &state);
8879 if (status == NO_ERROR) {
8880 outState->layerStack = state.layerStack.id;
8881 outState->orientation = static_cast<gui::Rotation>(state.orientation);
8882 outState->layerStackSpaceRect.width = state.layerStackSpaceRect.width;
8883 outState->layerStackSpaceRect.height = state.layerStackSpaceRect.height;
8884 }
Huihong Luo3bdef862022-03-03 11:57:19 -08008885 return binderStatusFromStatusT(status);
Huihong Luoaa7fc2e2022-02-15 10:43:00 -08008886}
8887
Sally Qi6bb12822022-10-05 11:42:30 -07008888binder::Status SurfaceComposerAIDL::getStaticDisplayInfo(int64_t displayId,
Huihong Luoa79ddf42022-02-17 00:01:38 -08008889 gui::StaticDisplayInfo* outInfo) {
8890 using Tag = gui::DeviceProductInfo::ManufactureOrModelDate::Tag;
8891 ui::StaticDisplayInfo info;
Sally Qi6bb12822022-10-05 11:42:30 -07008892
8893 status_t status = mFlinger->getStaticDisplayInfo(displayId, &info);
Huihong Luoa79ddf42022-02-17 00:01:38 -08008894 if (status == NO_ERROR) {
8895 // convert ui::StaticDisplayInfo to gui::StaticDisplayInfo
8896 outInfo->connectionType = static_cast<gui::DisplayConnectionType>(info.connectionType);
8897 outInfo->density = info.density;
8898 outInfo->secure = info.secure;
8899 outInfo->installOrientation = static_cast<gui::Rotation>(info.installOrientation);
8900
Snild Dolkow8d675642023-07-14 12:43:35 +02008901 if (const std::optional<DeviceProductInfo> dpi = info.deviceProductInfo) {
8902 gui::DeviceProductInfo dinfo;
8903 dinfo.name = std::move(dpi->name);
8904 dinfo.manufacturerPnpId = std::vector<uint8_t>(dpi->manufacturerPnpId.begin(),
8905 dpi->manufacturerPnpId.end());
8906 dinfo.productId = dpi->productId;
8907 dinfo.relativeAddress =
8908 std::vector<uint8_t>(dpi->relativeAddress.begin(), dpi->relativeAddress.end());
8909 if (const auto* model =
8910 std::get_if<DeviceProductInfo::ModelYear>(&dpi->manufactureOrModelDate)) {
8911 gui::DeviceProductInfo::ModelYear modelYear;
8912 modelYear.year = model->year;
8913 dinfo.manufactureOrModelDate.set<Tag::modelYear>(modelYear);
8914 } else if (const auto* manufacture = std::get_if<DeviceProductInfo::ManufactureYear>(
8915 &dpi->manufactureOrModelDate)) {
8916 gui::DeviceProductInfo::ManufactureYear date;
8917 date.modelYear.year = manufacture->year;
8918 dinfo.manufactureOrModelDate.set<Tag::manufactureYear>(date);
8919 } else if (const auto* manufacture =
8920 std::get_if<DeviceProductInfo::ManufactureWeekAndYear>(
8921 &dpi->manufactureOrModelDate)) {
8922 gui::DeviceProductInfo::ManufactureWeekAndYear date;
8923 date.manufactureYear.modelYear.year = manufacture->year;
8924 date.week = manufacture->week;
8925 dinfo.manufactureOrModelDate.set<Tag::manufactureWeekAndYear>(date);
8926 }
Huihong Luoa79ddf42022-02-17 00:01:38 -08008927
Snild Dolkow8d675642023-07-14 12:43:35 +02008928 outInfo->deviceProductInfo = dinfo;
8929 }
Huihong Luoa79ddf42022-02-17 00:01:38 -08008930 }
Huihong Luo3bdef862022-03-03 11:57:19 -08008931 return binderStatusFromStatusT(status);
Huihong Luoa79ddf42022-02-17 00:01:38 -08008932}
8933
Sally Qi6bb12822022-10-05 11:42:30 -07008934void SurfaceComposerAIDL::getDynamicDisplayInfoInternal(ui::DynamicDisplayInfo& info,
8935 gui::DynamicDisplayInfo*& outInfo) {
8936 // convert ui::DynamicDisplayInfo to gui::DynamicDisplayInfo
8937 outInfo->supportedDisplayModes.clear();
8938 outInfo->supportedDisplayModes.reserve(info.supportedDisplayModes.size());
8939 for (const auto& mode : info.supportedDisplayModes) {
8940 gui::DisplayMode outMode;
8941 outMode.id = mode.id;
8942 outMode.resolution.width = mode.resolution.width;
8943 outMode.resolution.height = mode.resolution.height;
8944 outMode.xDpi = mode.xDpi;
8945 outMode.yDpi = mode.yDpi;
8946 outMode.refreshRate = mode.refreshRate;
8947 outMode.appVsyncOffset = mode.appVsyncOffset;
8948 outMode.sfVsyncOffset = mode.sfVsyncOffset;
8949 outMode.presentationDeadline = mode.presentationDeadline;
8950 outMode.group = mode.group;
8951 std::transform(mode.supportedHdrTypes.begin(), mode.supportedHdrTypes.end(),
8952 std::back_inserter(outMode.supportedHdrTypes),
8953 [](const ui::Hdr& value) { return static_cast<int32_t>(value); });
8954 outInfo->supportedDisplayModes.push_back(outMode);
8955 }
8956
8957 outInfo->activeDisplayModeId = info.activeDisplayModeId;
8958 outInfo->renderFrameRate = info.renderFrameRate;
8959
8960 outInfo->supportedColorModes.clear();
8961 outInfo->supportedColorModes.reserve(info.supportedColorModes.size());
8962 for (const auto& cmode : info.supportedColorModes) {
8963 outInfo->supportedColorModes.push_back(static_cast<int32_t>(cmode));
8964 }
8965
8966 outInfo->activeColorMode = static_cast<int32_t>(info.activeColorMode);
8967
8968 gui::HdrCapabilities& hdrCapabilities = outInfo->hdrCapabilities;
8969 hdrCapabilities.supportedHdrTypes.clear();
8970 hdrCapabilities.supportedHdrTypes.reserve(info.hdrCapabilities.getSupportedHdrTypes().size());
8971 for (const auto& hdr : info.hdrCapabilities.getSupportedHdrTypes()) {
8972 hdrCapabilities.supportedHdrTypes.push_back(static_cast<int32_t>(hdr));
8973 }
8974 hdrCapabilities.maxLuminance = info.hdrCapabilities.getDesiredMaxLuminance();
8975 hdrCapabilities.maxAverageLuminance = info.hdrCapabilities.getDesiredMaxAverageLuminance();
8976 hdrCapabilities.minLuminance = info.hdrCapabilities.getDesiredMinLuminance();
8977
8978 outInfo->autoLowLatencyModeSupported = info.autoLowLatencyModeSupported;
8979 outInfo->gameContentTypeSupported = info.gameContentTypeSupported;
8980 outInfo->preferredBootDisplayMode = info.preferredBootDisplayMode;
8981}
8982
8983binder::Status SurfaceComposerAIDL::getDynamicDisplayInfoFromToken(
8984 const sp<IBinder>& display, gui::DynamicDisplayInfo* outInfo) {
Huihong Luo38603fd2022-02-21 14:32:54 -08008985 ui::DynamicDisplayInfo info;
Sally Qi6bb12822022-10-05 11:42:30 -07008986 status_t status = mFlinger->getDynamicDisplayInfoFromToken(display, &info);
Huihong Luo38603fd2022-02-21 14:32:54 -08008987 if (status == NO_ERROR) {
Sally Qi6bb12822022-10-05 11:42:30 -07008988 getDynamicDisplayInfoInternal(info, outInfo);
8989 }
8990 return binderStatusFromStatusT(status);
8991}
Marc Kassisbdf7e4b2022-11-04 17:26:48 +01008992
Sally Qi6bb12822022-10-05 11:42:30 -07008993binder::Status SurfaceComposerAIDL::getDynamicDisplayInfoFromId(int64_t displayId,
8994 gui::DynamicDisplayInfo* outInfo) {
8995 ui::DynamicDisplayInfo info;
8996 status_t status = mFlinger->getDynamicDisplayInfoFromId(displayId, &info);
8997 if (status == NO_ERROR) {
8998 getDynamicDisplayInfoInternal(info, outInfo);
Huihong Luo38603fd2022-02-21 14:32:54 -08008999 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009000 return binderStatusFromStatusT(status);
Huihong Luo38603fd2022-02-21 14:32:54 -08009001}
9002
Huihong Luoca3d9a42022-02-22 11:07:34 -08009003binder::Status SurfaceComposerAIDL::getDisplayNativePrimaries(const sp<IBinder>& display,
9004 gui::DisplayPrimaries* outPrimaries) {
9005 ui::DisplayPrimaries primaries;
9006 status_t status = mFlinger->getDisplayNativePrimaries(display, primaries);
9007 if (status == NO_ERROR) {
9008 outPrimaries->red.X = primaries.red.X;
9009 outPrimaries->red.Y = primaries.red.Y;
9010 outPrimaries->red.Z = primaries.red.Z;
9011
9012 outPrimaries->green.X = primaries.green.X;
9013 outPrimaries->green.Y = primaries.green.Y;
9014 outPrimaries->green.Z = primaries.green.Z;
9015
9016 outPrimaries->blue.X = primaries.blue.X;
9017 outPrimaries->blue.Y = primaries.blue.Y;
9018 outPrimaries->blue.Z = primaries.blue.Z;
9019
9020 outPrimaries->white.X = primaries.white.X;
9021 outPrimaries->white.Y = primaries.white.Y;
9022 outPrimaries->white.Z = primaries.white.Z;
9023 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009024 return binderStatusFromStatusT(status);
Huihong Luoca3d9a42022-02-22 11:07:34 -08009025}
9026
9027binder::Status SurfaceComposerAIDL::setActiveColorMode(const sp<IBinder>& display, int colorMode) {
9028 status_t status = checkAccessPermission();
9029 if (status == OK) {
9030 status = mFlinger->setActiveColorMode(display, static_cast<ui::ColorMode>(colorMode));
9031 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009032 return binderStatusFromStatusT(status);
Huihong Luoca3d9a42022-02-22 11:07:34 -08009033}
9034
9035binder::Status SurfaceComposerAIDL::setBootDisplayMode(const sp<IBinder>& display,
9036 int displayModeId) {
9037 status_t status = checkAccessPermission();
9038 if (status == OK) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07009039 status = mFlinger->setBootDisplayMode(display, DisplayModeId{displayModeId});
Huihong Luoca3d9a42022-02-22 11:07:34 -08009040 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009041 return binderStatusFromStatusT(status);
Huihong Luoca3d9a42022-02-22 11:07:34 -08009042}
9043
Huihong Luo37396db2022-02-15 10:43:00 -08009044binder::Status SurfaceComposerAIDL::clearBootDisplayMode(const sp<IBinder>& display) {
9045 status_t status = checkAccessPermission();
9046 if (status == OK) {
9047 status = mFlinger->clearBootDisplayMode(display);
9048 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009049 return binderStatusFromStatusT(status);
Huihong Luo37396db2022-02-15 10:43:00 -08009050}
9051
Sally Qi0cbd08b2022-08-17 12:12:28 -07009052binder::Status SurfaceComposerAIDL::getOverlaySupport(gui::OverlayProperties* outProperties) {
9053 status_t status = checkAccessPermission();
9054 if (status == OK) {
9055 status = mFlinger->getOverlaySupport(outProperties);
9056 }
9057 return binderStatusFromStatusT(status);
9058}
9059
Huihong Luo37396db2022-02-15 10:43:00 -08009060binder::Status SurfaceComposerAIDL::getBootDisplayModeSupport(bool* outMode) {
9061 status_t status = checkAccessPermission();
9062 if (status == OK) {
9063 status = mFlinger->getBootDisplayModeSupport(outMode);
9064 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009065 return binderStatusFromStatusT(status);
Huihong Luo37396db2022-02-15 10:43:00 -08009066}
9067
Kriti Dang674b9372022-11-18 10:58:44 +01009068binder::Status SurfaceComposerAIDL::getHdrConversionCapabilities(
9069 std::vector<gui::HdrConversionCapability>* hdrConversionCapabilities) {
9070 status_t status = checkAccessPermission();
9071 if (status == OK) {
9072 status = mFlinger->getHdrConversionCapabilities(hdrConversionCapabilities);
9073 }
9074 return binderStatusFromStatusT(status);
9075}
9076
9077binder::Status SurfaceComposerAIDL::setHdrConversionStrategy(
Kriti Dangd432bb52023-02-09 18:21:04 +01009078 const gui::HdrConversionStrategy& hdrConversionStrategy,
9079 int32_t* outPreferredHdrOutputType) {
Kriti Dang674b9372022-11-18 10:58:44 +01009080 status_t status = checkAccessPermission();
9081 if (status == OK) {
Kriti Dangd432bb52023-02-09 18:21:04 +01009082 status = mFlinger->setHdrConversionStrategy(hdrConversionStrategy,
9083 outPreferredHdrOutputType);
Kriti Dang674b9372022-11-18 10:58:44 +01009084 }
9085 return binderStatusFromStatusT(status);
9086}
9087
9088binder::Status SurfaceComposerAIDL::getHdrOutputConversionSupport(bool* outMode) {
9089 status_t status = checkAccessPermission();
9090 if (status == OK) {
9091 status = mFlinger->getHdrOutputConversionSupport(outMode);
9092 }
9093 return binderStatusFromStatusT(status);
9094}
9095
Huihong Luo37396db2022-02-15 10:43:00 -08009096binder::Status SurfaceComposerAIDL::setAutoLowLatencyMode(const sp<IBinder>& display, bool on) {
9097 status_t status = checkAccessPermission();
9098 if (status != OK) {
Huihong Luo3bdef862022-03-03 11:57:19 -08009099 return binderStatusFromStatusT(status);
Huihong Luo37396db2022-02-15 10:43:00 -08009100 }
9101 mFlinger->setAutoLowLatencyMode(display, on);
9102 return binder::Status::ok();
9103}
9104
9105binder::Status SurfaceComposerAIDL::setGameContentType(const sp<IBinder>& display, bool on) {
9106 status_t status = checkAccessPermission();
9107 if (status != OK) {
Huihong Luo3bdef862022-03-03 11:57:19 -08009108 return binderStatusFromStatusT(status);
Huihong Luo37396db2022-02-15 10:43:00 -08009109 }
9110 mFlinger->setGameContentType(display, on);
9111 return binder::Status::ok();
9112}
9113
Huihong Luof5029222021-12-16 14:33:46 -08009114binder::Status SurfaceComposerAIDL::captureDisplay(
9115 const DisplayCaptureArgs& args, const sp<IScreenCaptureListener>& captureListener) {
jeimysantiago9be7d0c2023-07-12 18:37:06 +00009116 mFlinger->captureDisplay(args, captureListener);
9117 return binderStatusFromStatusT(NO_ERROR);
Huihong Luof5029222021-12-16 14:33:46 -08009118}
9119
9120binder::Status SurfaceComposerAIDL::captureDisplayById(
9121 int64_t displayId, const sp<IScreenCaptureListener>& captureListener) {
jeimysantiago9be7d0c2023-07-12 18:37:06 +00009122 // status_t status;
Huihong Luof5029222021-12-16 14:33:46 -08009123 IPCThreadState* ipc = IPCThreadState::self();
9124 const int uid = ipc->getCallingUid();
9125 if (uid == AID_ROOT || uid == AID_GRAPHICS || uid == AID_SYSTEM || uid == AID_SHELL) {
9126 std::optional<DisplayId> id = DisplayId::fromValue(static_cast<uint64_t>(displayId));
jeimysantiago9be7d0c2023-07-12 18:37:06 +00009127 mFlinger->captureDisplay(*id, captureListener);
Huihong Luof5029222021-12-16 14:33:46 -08009128 } else {
jeimysantiago9be7d0c2023-07-12 18:37:06 +00009129 invokeScreenCaptureError(PERMISSION_DENIED, captureListener);
Huihong Luof5029222021-12-16 14:33:46 -08009130 }
jeimysantiago9be7d0c2023-07-12 18:37:06 +00009131 return binderStatusFromStatusT(NO_ERROR);
Huihong Luof5029222021-12-16 14:33:46 -08009132}
9133
9134binder::Status SurfaceComposerAIDL::captureLayers(
9135 const LayerCaptureArgs& args, const sp<IScreenCaptureListener>& captureListener) {
jeimysantiago9be7d0c2023-07-12 18:37:06 +00009136 mFlinger->captureLayers(args, captureListener);
9137 return binderStatusFromStatusT(NO_ERROR);
Huihong Luof5029222021-12-16 14:33:46 -08009138}
9139
Huihong Luo05539a12022-02-23 10:29:40 -08009140binder::Status SurfaceComposerAIDL::overrideHdrTypes(const sp<IBinder>& display,
9141 const std::vector<int32_t>& hdrTypes) {
9142 // overrideHdrTypes is used by CTS tests, which acquire the necessary
9143 // permission dynamically. Don't use the permission cache for this check.
9144 status_t status = checkAccessPermission(false);
9145 if (status != OK) {
Huihong Luo3bdef862022-03-03 11:57:19 -08009146 return binderStatusFromStatusT(status);
Huihong Luo05539a12022-02-23 10:29:40 -08009147 }
9148
9149 std::vector<ui::Hdr> hdrTypesVector;
9150 for (int32_t i : hdrTypes) {
9151 hdrTypesVector.push_back(static_cast<ui::Hdr>(i));
9152 }
9153 status = mFlinger->overrideHdrTypes(display, hdrTypesVector);
Huihong Luo3bdef862022-03-03 11:57:19 -08009154 return binderStatusFromStatusT(status);
Huihong Luo05539a12022-02-23 10:29:40 -08009155}
9156
9157binder::Status SurfaceComposerAIDL::onPullAtom(int32_t atomId, gui::PullAtomData* outPullData) {
9158 status_t status;
9159 const int uid = IPCThreadState::self()->getCallingUid();
9160 if (uid != AID_SYSTEM) {
9161 status = PERMISSION_DENIED;
9162 } else {
9163 status = mFlinger->onPullAtom(atomId, &outPullData->data, &outPullData->success);
9164 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009165 return binderStatusFromStatusT(status);
Huihong Luo05539a12022-02-23 10:29:40 -08009166}
9167
Huihong Luo05539a12022-02-23 10:29:40 -08009168binder::Status SurfaceComposerAIDL::getLayerDebugInfo(std::vector<gui::LayerDebugInfo>* outLayers) {
9169 if (!outLayers) {
Huihong Luo3bdef862022-03-03 11:57:19 -08009170 return binderStatusFromStatusT(UNEXPECTED_NULL);
Huihong Luo05539a12022-02-23 10:29:40 -08009171 }
9172
9173 IPCThreadState* ipc = IPCThreadState::self();
9174 const int pid = ipc->getCallingPid();
9175 const int uid = ipc->getCallingUid();
9176 if ((uid != AID_SHELL) && !PermissionCache::checkPermission(sDump, pid, uid)) {
9177 ALOGE("Layer debug info permission denied for pid=%d, uid=%d", pid, uid);
Huihong Luo3bdef862022-03-03 11:57:19 -08009178 return binderStatusFromStatusT(PERMISSION_DENIED);
Huihong Luo05539a12022-02-23 10:29:40 -08009179 }
9180 status_t status = mFlinger->getLayerDebugInfo(outLayers);
Huihong Luo3bdef862022-03-03 11:57:19 -08009181 return binderStatusFromStatusT(status);
Huihong Luo05539a12022-02-23 10:29:40 -08009182}
9183
9184binder::Status SurfaceComposerAIDL::getColorManagement(bool* outGetColorManagement) {
9185 status_t status = mFlinger->getColorManagement(outGetColorManagement);
Huihong Luo3bdef862022-03-03 11:57:19 -08009186 return binderStatusFromStatusT(status);
Huihong Luo05539a12022-02-23 10:29:40 -08009187}
9188
9189binder::Status SurfaceComposerAIDL::getCompositionPreference(gui::CompositionPreference* outPref) {
9190 ui::Dataspace dataspace;
9191 ui::PixelFormat pixelFormat;
9192 ui::Dataspace wideColorGamutDataspace;
9193 ui::PixelFormat wideColorGamutPixelFormat;
9194 status_t status =
9195 mFlinger->getCompositionPreference(&dataspace, &pixelFormat, &wideColorGamutDataspace,
9196 &wideColorGamutPixelFormat);
9197 if (status == NO_ERROR) {
9198 outPref->defaultDataspace = static_cast<int32_t>(dataspace);
9199 outPref->defaultPixelFormat = static_cast<int32_t>(pixelFormat);
9200 outPref->wideColorGamutDataspace = static_cast<int32_t>(wideColorGamutDataspace);
9201 outPref->wideColorGamutPixelFormat = static_cast<int32_t>(wideColorGamutPixelFormat);
9202 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009203 return binderStatusFromStatusT(status);
Huihong Luo05539a12022-02-23 10:29:40 -08009204}
9205
9206binder::Status SurfaceComposerAIDL::getDisplayedContentSamplingAttributes(
9207 const sp<IBinder>& display, gui::ContentSamplingAttributes* outAttrs) {
9208 status_t status = checkAccessPermission();
9209 if (status != OK) {
Huihong Luo3bdef862022-03-03 11:57:19 -08009210 return binderStatusFromStatusT(status);
Huihong Luo05539a12022-02-23 10:29:40 -08009211 }
9212
9213 ui::PixelFormat format;
9214 ui::Dataspace dataspace;
9215 uint8_t componentMask;
9216 status = mFlinger->getDisplayedContentSamplingAttributes(display, &format, &dataspace,
9217 &componentMask);
9218 if (status == NO_ERROR) {
9219 outAttrs->format = static_cast<int32_t>(format);
9220 outAttrs->dataspace = static_cast<int32_t>(dataspace);
9221 outAttrs->componentMask = static_cast<int8_t>(componentMask);
9222 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009223 return binderStatusFromStatusT(status);
Huihong Luo05539a12022-02-23 10:29:40 -08009224}
9225
9226binder::Status SurfaceComposerAIDL::setDisplayContentSamplingEnabled(const sp<IBinder>& display,
9227 bool enable,
9228 int8_t componentMask,
9229 int64_t maxFrames) {
9230 status_t status = checkAccessPermission();
9231 if (status == OK) {
9232 status = mFlinger->setDisplayContentSamplingEnabled(display, enable,
9233 static_cast<uint8_t>(componentMask),
9234 static_cast<uint64_t>(maxFrames));
9235 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009236 return binderStatusFromStatusT(status);
9237}
9238
9239binder::Status SurfaceComposerAIDL::getDisplayedContentSample(const sp<IBinder>& display,
9240 int64_t maxFrames, int64_t timestamp,
9241 gui::DisplayedFrameStats* outStats) {
9242 if (!outStats) {
9243 return binderStatusFromStatusT(BAD_VALUE);
9244 }
9245
9246 status_t status = checkAccessPermission();
9247 if (status != OK) {
9248 return binderStatusFromStatusT(status);
9249 }
9250
9251 DisplayedFrameStats stats;
9252 status = mFlinger->getDisplayedContentSample(display, static_cast<uint64_t>(maxFrames),
9253 static_cast<uint64_t>(timestamp), &stats);
9254 if (status == NO_ERROR) {
9255 // convert from ui::DisplayedFrameStats to gui::DisplayedFrameStats
9256 outStats->numFrames = static_cast<int64_t>(stats.numFrames);
9257 outStats->component_0_sample.reserve(stats.component_0_sample.size());
9258 for (const auto& s : stats.component_0_sample) {
9259 outStats->component_0_sample.push_back(static_cast<int64_t>(s));
9260 }
9261 outStats->component_1_sample.reserve(stats.component_1_sample.size());
9262 for (const auto& s : stats.component_1_sample) {
9263 outStats->component_1_sample.push_back(static_cast<int64_t>(s));
9264 }
9265 outStats->component_2_sample.reserve(stats.component_2_sample.size());
9266 for (const auto& s : stats.component_2_sample) {
9267 outStats->component_2_sample.push_back(static_cast<int64_t>(s));
9268 }
9269 outStats->component_3_sample.reserve(stats.component_3_sample.size());
9270 for (const auto& s : stats.component_3_sample) {
9271 outStats->component_3_sample.push_back(static_cast<int64_t>(s));
9272 }
9273 }
9274 return binderStatusFromStatusT(status);
Huihong Luo05539a12022-02-23 10:29:40 -08009275}
9276
9277binder::Status SurfaceComposerAIDL::getProtectedContentSupport(bool* outSupported) {
9278 status_t status = mFlinger->getProtectedContentSupport(outSupported);
Huihong Luo3bdef862022-03-03 11:57:19 -08009279 return binderStatusFromStatusT(status);
Huihong Luo05539a12022-02-23 10:29:40 -08009280}
9281
Huihong Luo37396db2022-02-15 10:43:00 -08009282binder::Status SurfaceComposerAIDL::isWideColorDisplay(const sp<IBinder>& token,
9283 bool* outIsWideColorDisplay) {
9284 status_t status = mFlinger->isWideColorDisplay(token, outIsWideColorDisplay);
Huihong Luo3bdef862022-03-03 11:57:19 -08009285 return binderStatusFromStatusT(status);
Huihong Luo37396db2022-02-15 10:43:00 -08009286}
9287
Huihong Luo02186fb2022-02-23 14:21:54 -08009288binder::Status SurfaceComposerAIDL::addRegionSamplingListener(
9289 const gui::ARect& samplingArea, const sp<IBinder>& stopLayerHandle,
9290 const sp<gui::IRegionSamplingListener>& listener) {
9291 status_t status = checkReadFrameBufferPermission();
9292 if (status != OK) {
Huihong Luo3bdef862022-03-03 11:57:19 -08009293 return binderStatusFromStatusT(status);
Huihong Luo02186fb2022-02-23 14:21:54 -08009294 }
9295 android::Rect rect;
9296 rect.left = samplingArea.left;
9297 rect.top = samplingArea.top;
9298 rect.right = samplingArea.right;
9299 rect.bottom = samplingArea.bottom;
9300 status = mFlinger->addRegionSamplingListener(rect, stopLayerHandle, listener);
Huihong Luo3bdef862022-03-03 11:57:19 -08009301 return binderStatusFromStatusT(status);
Huihong Luo02186fb2022-02-23 14:21:54 -08009302}
9303
9304binder::Status SurfaceComposerAIDL::removeRegionSamplingListener(
9305 const sp<gui::IRegionSamplingListener>& listener) {
9306 status_t status = checkReadFrameBufferPermission();
9307 if (status == OK) {
9308 status = mFlinger->removeRegionSamplingListener(listener);
9309 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009310 return binderStatusFromStatusT(status);
Huihong Luo02186fb2022-02-23 14:21:54 -08009311}
9312
9313binder::Status SurfaceComposerAIDL::addFpsListener(int32_t taskId,
9314 const sp<gui::IFpsListener>& listener) {
9315 status_t status = checkReadFrameBufferPermission();
9316 if (status == OK) {
9317 status = mFlinger->addFpsListener(taskId, listener);
9318 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009319 return binderStatusFromStatusT(status);
Huihong Luo02186fb2022-02-23 14:21:54 -08009320}
9321
9322binder::Status SurfaceComposerAIDL::removeFpsListener(const sp<gui::IFpsListener>& listener) {
9323 status_t status = checkReadFrameBufferPermission();
9324 if (status == OK) {
9325 status = mFlinger->removeFpsListener(listener);
9326 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009327 return binderStatusFromStatusT(status);
Huihong Luo02186fb2022-02-23 14:21:54 -08009328}
9329
9330binder::Status SurfaceComposerAIDL::addTunnelModeEnabledListener(
9331 const sp<gui::ITunnelModeEnabledListener>& listener) {
9332 status_t status = checkAccessPermission();
9333 if (status == OK) {
9334 status = mFlinger->addTunnelModeEnabledListener(listener);
9335 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009336 return binderStatusFromStatusT(status);
Huihong Luo02186fb2022-02-23 14:21:54 -08009337}
9338
9339binder::Status SurfaceComposerAIDL::removeTunnelModeEnabledListener(
9340 const sp<gui::ITunnelModeEnabledListener>& listener) {
9341 status_t status = checkAccessPermission();
9342 if (status == OK) {
9343 status = mFlinger->removeTunnelModeEnabledListener(listener);
9344 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009345 return binderStatusFromStatusT(status);
Huihong Luo02186fb2022-02-23 14:21:54 -08009346}
9347
Ady Abraham285f8c12022-10-11 17:12:14 -07009348binder::Status SurfaceComposerAIDL::setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
9349 const gui::DisplayModeSpecs& specs) {
Huihong Luo02186fb2022-02-23 14:21:54 -08009350 status_t status = checkAccessPermission();
9351 if (status == OK) {
Ady Abraham285f8c12022-10-11 17:12:14 -07009352 status = mFlinger->setDesiredDisplayModeSpecs(displayToken, specs);
Huihong Luo02186fb2022-02-23 14:21:54 -08009353 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009354 return binderStatusFromStatusT(status);
Huihong Luo02186fb2022-02-23 14:21:54 -08009355}
9356
9357binder::Status SurfaceComposerAIDL::getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
9358 gui::DisplayModeSpecs* outSpecs) {
9359 if (!outSpecs) {
Huihong Luo3bdef862022-03-03 11:57:19 -08009360 return binderStatusFromStatusT(BAD_VALUE);
Huihong Luo02186fb2022-02-23 14:21:54 -08009361 }
9362
9363 status_t status = checkAccessPermission();
9364 if (status != OK) {
Huihong Luo3bdef862022-03-03 11:57:19 -08009365 return binderStatusFromStatusT(status);
Huihong Luo02186fb2022-02-23 14:21:54 -08009366 }
9367
Ady Abraham285f8c12022-10-11 17:12:14 -07009368 status = mFlinger->getDesiredDisplayModeSpecs(displayToken, outSpecs);
Huihong Luo3bdef862022-03-03 11:57:19 -08009369 return binderStatusFromStatusT(status);
Huihong Luo02186fb2022-02-23 14:21:54 -08009370}
9371
Huihong Luo37396db2022-02-15 10:43:00 -08009372binder::Status SurfaceComposerAIDL::getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
9373 bool* outSupport) {
9374 status_t status = mFlinger->getDisplayBrightnessSupport(displayToken, outSupport);
Huihong Luo3bdef862022-03-03 11:57:19 -08009375 return binderStatusFromStatusT(status);
Huihong Luo37396db2022-02-15 10:43:00 -08009376}
9377
9378binder::Status SurfaceComposerAIDL::setDisplayBrightness(const sp<IBinder>& displayToken,
9379 const gui::DisplayBrightness& brightness) {
9380 status_t status = checkControlDisplayBrightnessPermission();
9381 if (status == OK) {
9382 status = mFlinger->setDisplayBrightness(displayToken, brightness);
9383 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009384 return binderStatusFromStatusT(status);
Huihong Luo37396db2022-02-15 10:43:00 -08009385}
9386
9387binder::Status SurfaceComposerAIDL::addHdrLayerInfoListener(
9388 const sp<IBinder>& displayToken, const sp<gui::IHdrLayerInfoListener>& listener) {
9389 status_t status = checkControlDisplayBrightnessPermission();
9390 if (status == OK) {
9391 status = mFlinger->addHdrLayerInfoListener(displayToken, listener);
9392 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009393 return binderStatusFromStatusT(status);
Huihong Luo37396db2022-02-15 10:43:00 -08009394}
9395
9396binder::Status SurfaceComposerAIDL::removeHdrLayerInfoListener(
9397 const sp<IBinder>& displayToken, const sp<gui::IHdrLayerInfoListener>& listener) {
9398 status_t status = checkControlDisplayBrightnessPermission();
9399 if (status == OK) {
9400 status = mFlinger->removeHdrLayerInfoListener(displayToken, listener);
9401 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009402 return binderStatusFromStatusT(status);
Huihong Luo37396db2022-02-15 10:43:00 -08009403}
9404
9405binder::Status SurfaceComposerAIDL::notifyPowerBoost(int boostId) {
9406 status_t status = checkAccessPermission();
9407 if (status == OK) {
9408 status = mFlinger->notifyPowerBoost(boostId);
9409 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009410 return binderStatusFromStatusT(status);
9411}
9412
9413binder::Status SurfaceComposerAIDL::setGlobalShadowSettings(const gui::Color& ambientColor,
9414 const gui::Color& spotColor,
9415 float lightPosY, float lightPosZ,
9416 float lightRadius) {
9417 status_t status = checkAccessPermission();
9418 if (status != OK) {
9419 return binderStatusFromStatusT(status);
9420 }
9421
9422 half4 ambientColorHalf = {ambientColor.r, ambientColor.g, ambientColor.b, ambientColor.a};
9423 half4 spotColorHalf = {spotColor.r, spotColor.g, spotColor.b, spotColor.a};
9424 status = mFlinger->setGlobalShadowSettings(ambientColorHalf, spotColorHalf, lightPosY,
9425 lightPosZ, lightRadius);
9426 return binderStatusFromStatusT(status);
9427}
9428
9429binder::Status SurfaceComposerAIDL::getDisplayDecorationSupport(
9430 const sp<IBinder>& displayToken, std::optional<gui::DisplayDecorationSupport>* outSupport) {
9431 std::optional<aidl::android::hardware::graphics::common::DisplayDecorationSupport> support;
9432 status_t status = mFlinger->getDisplayDecorationSupport(displayToken, &support);
9433 if (status != NO_ERROR) {
9434 ALOGE("getDisplayDecorationSupport failed with error %d", status);
9435 return binderStatusFromStatusT(status);
9436 }
9437
9438 if (!support || !support.has_value()) {
9439 outSupport->reset();
9440 } else {
9441 outSupport->emplace();
9442 outSupport->value().format = static_cast<int32_t>(support->format);
9443 outSupport->value().alphaInterpretation =
9444 static_cast<int32_t>(support->alphaInterpretation);
9445 }
9446
9447 return binder::Status::ok();
9448}
9449
9450binder::Status SurfaceComposerAIDL::setOverrideFrameRate(int32_t uid, float frameRate) {
9451 status_t status;
9452 const int c_uid = IPCThreadState::self()->getCallingUid();
9453 if (c_uid == AID_ROOT || c_uid == AID_SYSTEM) {
9454 status = mFlinger->setOverrideFrameRate(uid, frameRate);
9455 } else {
9456 ALOGE("setOverrideFrameRate() permission denied for uid: %d", c_uid);
9457 status = PERMISSION_DENIED;
9458 }
9459 return binderStatusFromStatusT(status);
Huihong Luo37396db2022-02-15 10:43:00 -08009460}
9461
Huihong Luo02186fb2022-02-23 14:21:54 -08009462binder::Status SurfaceComposerAIDL::getGpuContextPriority(int32_t* outPriority) {
9463 *outPriority = mFlinger->getGpuContextPriority();
9464 return binder::Status::ok();
9465}
9466
9467binder::Status SurfaceComposerAIDL::getMaxAcquiredBufferCount(int32_t* buffers) {
9468 status_t status = mFlinger->getMaxAcquiredBufferCount(buffers);
Huihong Luo3bdef862022-03-03 11:57:19 -08009469 return binderStatusFromStatusT(status);
Huihong Luo02186fb2022-02-23 14:21:54 -08009470}
9471
9472binder::Status SurfaceComposerAIDL::addWindowInfosListener(
Patrick Williamsacd22582023-07-12 13:47:28 -05009473 const sp<gui::IWindowInfosListener>& windowInfosListener,
9474 gui::WindowInfosListenerInfo* outInfo) {
Huihong Luo02186fb2022-02-23 14:21:54 -08009475 status_t status;
Patrick Williams0525e9b2023-02-13 17:24:18 -06009476 const int pid = IPCThreadState::self()->getCallingPid();
Huihong Luo02186fb2022-02-23 14:21:54 -08009477 const int uid = IPCThreadState::self()->getCallingUid();
Patrick Williams0525e9b2023-02-13 17:24:18 -06009478 // TODO(b/270566761) update permissions check so that only system_server and shell can add
9479 // WindowInfosListeners
9480 if (uid == AID_SYSTEM || uid == AID_GRAPHICS ||
9481 checkPermission(sAccessSurfaceFlinger, pid, uid)) {
Patrick Williamsacd22582023-07-12 13:47:28 -05009482 status = mFlinger->addWindowInfosListener(windowInfosListener, outInfo);
Huihong Luo02186fb2022-02-23 14:21:54 -08009483 } else {
9484 status = PERMISSION_DENIED;
9485 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009486 return binderStatusFromStatusT(status);
Huihong Luo02186fb2022-02-23 14:21:54 -08009487}
9488
9489binder::Status SurfaceComposerAIDL::removeWindowInfosListener(
9490 const sp<gui::IWindowInfosListener>& windowInfosListener) {
9491 status_t status;
Patrick Williams0525e9b2023-02-13 17:24:18 -06009492 const int pid = IPCThreadState::self()->getCallingPid();
Huihong Luo02186fb2022-02-23 14:21:54 -08009493 const int uid = IPCThreadState::self()->getCallingUid();
Patrick Williams0525e9b2023-02-13 17:24:18 -06009494 if (uid == AID_SYSTEM || uid == AID_GRAPHICS ||
9495 checkPermission(sAccessSurfaceFlinger, pid, uid)) {
Huihong Luo02186fb2022-02-23 14:21:54 -08009496 status = mFlinger->removeWindowInfosListener(windowInfosListener);
9497 } else {
9498 status = PERMISSION_DENIED;
9499 }
Huihong Luo3bdef862022-03-03 11:57:19 -08009500 return binderStatusFromStatusT(status);
Huihong Luo02186fb2022-02-23 14:21:54 -08009501}
9502
Huihong Luo07e72362022-02-14 14:26:04 -08009503status_t SurfaceComposerAIDL::checkAccessPermission(bool usePermissionCache) {
9504 if (!mFlinger->callingThreadHasUnscopedSurfaceFlingerAccess(usePermissionCache)) {
9505 IPCThreadState* ipc = IPCThreadState::self();
9506 ALOGE("Permission Denial: can't access SurfaceFlinger pid=%d, uid=%d", ipc->getCallingPid(),
9507 ipc->getCallingUid());
9508 return PERMISSION_DENIED;
9509 }
9510 return OK;
9511}
9512
Huihong Luo37396db2022-02-15 10:43:00 -08009513status_t SurfaceComposerAIDL::checkControlDisplayBrightnessPermission() {
9514 IPCThreadState* ipc = IPCThreadState::self();
9515 const int pid = ipc->getCallingPid();
9516 const int uid = ipc->getCallingUid();
Rheygine Medel9e9281e2022-09-22 10:13:56 -07009517 if ((uid != AID_GRAPHICS) && (uid != AID_SYSTEM) &&
Huihong Luo37396db2022-02-15 10:43:00 -08009518 !PermissionCache::checkPermission(sControlDisplayBrightness, pid, uid)) {
9519 ALOGE("Permission Denial: can't control brightness pid=%d, uid=%d", pid, uid);
9520 return PERMISSION_DENIED;
9521 }
9522 return OK;
9523}
9524
Huihong Luo02186fb2022-02-23 14:21:54 -08009525status_t SurfaceComposerAIDL::checkReadFrameBufferPermission() {
9526 IPCThreadState* ipc = IPCThreadState::self();
9527 const int pid = ipc->getCallingPid();
9528 const int uid = ipc->getCallingUid();
9529 if ((uid != AID_GRAPHICS) && !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
9530 ALOGE("Permission Denial: can't read framebuffer pid=%d, uid=%d", pid, uid);
9531 return PERMISSION_DENIED;
9532 }
9533 return OK;
9534}
9535
Chavi Weingarten076acac2023-01-19 17:20:43 +00009536void SurfaceFlinger::forceFutureUpdate(int delayInMs) {
9537 static_cast<void>(mScheduler->scheduleDelayed([&]() { scheduleRepaint(); }, ms2ns(delayInMs)));
9538}
9539
Vishnu Nair2f65e972023-04-04 16:36:28 +00009540const DisplayDevice* SurfaceFlinger::getDisplayFromLayerStack(ui::LayerStack layerStack) {
9541 for (const auto& [_, display] : mDisplays) {
9542 if (display->getLayerStack() == layerStack) {
9543 return display.get();
9544 }
9545 }
9546 return nullptr;
9547}
9548
Dominik Laskowski9dab3432019-03-27 13:21:10 -07009549} // namespace android
Lloyd Pique074e8122018-07-26 12:57:23 -07009550
Mathias Agopian3f844832013-08-07 21:24:32 -07009551#if defined(__gl_h_)
9552#error "don't include gl/gl.h in this file"
9553#endif
9554
9555#if defined(__gl2_h_)
9556#error "don't include gl2/gl2.h in this file"
Chia-I Wu767fcf72017-11-30 22:07:38 -08009557#endif
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08009558
9559// TODO(b/129481165): remove the #pragma below and fix conversion issues
Marin Shalamanovbed7fd32020-12-21 20:02:20 +01009560#pragma clang diagnostic pop // ignored "-Wconversion -Wextra"