blob: c2f3bddffc9cb7b2460404d49bff73b3e1a89f37 [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
Dominik Laskowski298b08e2022-02-15 13:45:02 -080027#include <android-base/parseint.h>
Ana Krulecb9afd792020-06-11 13:16:15 -070028#include <android-base/properties.h>
Dominik Laskowski298b08e2022-02-15 13:45:02 -080029#include <android-base/stringprintf.h>
30#include <android-base/strings.h>
Alec Mouri5f487d42020-02-06 09:26:19 -080031#include <android/configuration.h>
Huihong Luo6fac5232021-11-22 16:05:23 -080032#include <android/gui/IDisplayEventConnection.h>
Alec Mouri5f487d42020-02-06 09:26:19 -080033#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
34#include <android/hardware/configstore/1.1/ISurfaceFlingerConfigs.h>
35#include <android/hardware/configstore/1.1/types.h>
Lais Andrade3a6e47d2020-04-02 11:20:16 +010036#include <android/hardware/power/Boost.h>
Steven Thomas62a4cf82020-01-31 12:04:03 -080037#include <android/native_window.h>
Chris Ye0783e992020-06-02 21:34:49 -070038#include <android/os/IInputFlinger.h>
Mathias Agopianc5b2c0b2009-05-19 19:08:10 -070039#include <binder/IPCThreadState.h>
40#include <binder/IServiceManager.h>
Mathias Agopian99b49842011-06-27 16:05:52 -070041#include <binder/PermissionCache.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070042#include <compositionengine/CompositionEngine.h>
Lloyd Piqueab039b52019-02-13 14:22:42 -080043#include <compositionengine/CompositionRefreshArgs.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070044#include <compositionengine/Display.h>
Lloyd Pique3d0c02e2018-10-19 18:38:12 -070045#include <compositionengine/DisplayColorProfile.h>
Lloyd Pique9370a482019-10-03 17:58:30 -070046#include <compositionengine/DisplayCreationArgs.h>
Lloyd Piquede196652020-01-22 17:29:58 -080047#include <compositionengine/LayerFECompositionState.h>
Lloyd Piquecc01a452018-12-04 17:24:00 -080048#include <compositionengine/OutputLayer.h>
Lloyd Pique31cb2942018-10-19 17:23:03 -070049#include <compositionengine/RenderSurface.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070050#include <compositionengine/impl/OutputCompositionState.h>
John Reckdb1a16b2021-07-09 13:05:52 -040051#include <compositionengine/impl/OutputLayerCompositionState.h>
Alec Mouri5f487d42020-02-06 09:26:19 -080052#include <configstore/Utils.h>
53#include <cutils/compiler.h>
54#include <cutils/properties.h>
Dominik Laskowski298b08e2022-02-15 13:45:02 -080055#include <ftl/fake_guard.h>
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -080056#include <ftl/future.h>
Dominik Laskowski9f410f02022-01-08 16:22:46 -080057#include <ftl/small_map.h>
Jamie Gennis1a4d8832012-08-02 20:11:05 -070058#include <gui/BufferQueue.h>
Ady Abrahama3b08ef2019-07-15 18:43:10 -070059#include <gui/DebugEGLImageTracker.h>
Alec Mouri0a9c7b82018-11-16 13:05:25 -080060#include <gui/IProducerListener.h>
Kalle Raitaa099a242017-01-11 11:17:29 -080061#include <gui/LayerDebugInfo.h>
Lloyd Pique4603f3c2020-02-11 12:06:56 -080062#include <gui/LayerMetadata.h>
Steven Thomas62a4cf82020-01-31 12:04:03 -080063#include <gui/LayerState.h>
Mathias Agopiane3c697f2013-02-14 17:11:02 -080064#include <gui/Surface.h>
rnlee60f46b52021-05-21 15:14:07 -070065#include <gui/TraceUtils.h>
Steven Moreland7c8af942020-07-08 18:35:51 +000066#include <hidl/ServiceManagement.h>
Alec Mouri5f487d42020-02-06 09:26:19 -080067#include <layerproto/LayerProtoParser.h>
68#include <log/log.h>
69#include <private/android_filesystem_config.h>
70#include <private/gui/SyncFeatures.h>
Wei Wang976a6452021-06-11 15:26:00 -070071#include <processgroup/processgroup.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070072#include <renderengine/RenderEngine.h>
Vishnu Nairdbbe3852022-01-12 20:22:11 -080073#include <renderengine/impl/ExternalTexture.h>
Alec Mouri5f487d42020-02-06 09:26:19 -080074#include <sys/types.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070075#include <ui/ColorSpace.h>
Alec Mouricdf6cbc2021-11-01 17:21:15 -070076#include <ui/DataspaceUtils.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070077#include <ui/DebugUtils.h>
Marin Shalamanov045b7002021-01-07 16:56:24 +010078#include <ui/DisplayId.h>
Marin Shalamanova7fe3042021-01-29 21:02:08 +010079#include <ui/DisplayMode.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070080#include <ui/DisplayStatInfo.h>
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -080081#include <ui/DisplayState.h>
Marin Shalamanov228f46b2021-01-28 21:11:45 +010082#include <ui/DynamicDisplayInfo.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070083#include <ui/GraphicBufferAllocator.h>
84#include <ui/PixelFormat.h>
Marin Shalamanov228f46b2021-01-28 21:11:45 +010085#include <ui/StaticDisplayInfo.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080086#include <utils/StopWatch.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070087#include <utils/String16.h>
88#include <utils/String8.h>
Yusuke Sato0a688f52015-07-30 23:05:39 -070089#include <utils/Timers.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070090#include <utils/misc.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080091
Alec Mouri5f487d42020-02-06 09:26:19 -080092#include <algorithm>
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -080093#include <cerrno>
Alec Mouri5f487d42020-02-06 09:26:19 -080094#include <cinttypes>
95#include <cmath>
96#include <cstdint>
97#include <functional>
Xiang Wang839fe5b2022-04-04 17:39:38 +000098#include <memory>
Alec Mouri5f487d42020-02-06 09:26:19 -080099#include <mutex>
100#include <optional>
Michael Wright44753b12020-07-08 13:48:11 +0100101#include <type_traits>
Alec Mouri5f487d42020-02-06 09:26:19 -0800102#include <unordered_map>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800103
Alec Mouriff793872022-01-13 17:45:06 -0800104#include <ui/DisplayIdentification.h>
Vishnu Nair03ccbd62021-12-01 17:21:16 -0800105#include "BackgroundExecutor.h"
Robert Carr578038f2018-03-09 12:25:24 -0800106#include "BufferLayer.h"
Marissa Wallfd668622018-05-10 10:21:13 -0700107#include "BufferQueueLayer.h"
Marissa Wall61c58622018-07-18 10:12:20 -0700108#include "BufferStateLayer.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +0200109#include "Client.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +0200110#include "Colorizer.h"
Robert Carr578038f2018-03-09 12:25:24 -0800111#include "ContainerLayer.h"
Robert Carr578038f2018-03-09 12:25:24 -0800112#include "DisplayDevice.h"
Steven Thomasb02664d2017-07-26 18:48:28 -0700113#include "DisplayHardware/ComposerHal.h"
Mathias Agopiana4912602012-07-12 14:25:33 -0700114#include "DisplayHardware/FramebufferSurface.h"
Mathias Agopiana350ff92010-08-10 17:14:02 -0700115#include "DisplayHardware/HWComposer.h"
Marin Shalamanovd3b5c5d2021-02-11 18:26:14 +0100116#include "DisplayHardware/Hal.h"
Xiang Wang839fe5b2022-04-04 17:39:38 +0000117#include "DisplayHardware/PowerAdvisor.h"
Jesse Hall99c7dbb2013-03-14 14:29:29 -0700118#include "DisplayHardware/VirtualDisplaySurface.h"
Marin Shalamanovf6b5d182020-06-12 02:08:51 +0200119#include "DisplayRenderArea.h"
Alec Mouri5f487d42020-02-06 09:26:19 -0800120#include "EffectLayer.h"
Mathias Agopianff2ed702013-09-01 21:36:12 -0700121#include "Effects/Daltonizer.h"
rnleea2ecd832021-07-29 13:58:30 -0700122#include "FlagManager.h"
Alec Mouriadebf5c2021-01-05 12:57:36 -0800123#include "FpsReporter.h"
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700124#include "FrameTimeline/FrameTimeline.h"
Mikael Pessa90092f42019-08-26 17:22:04 -0700125#include "FrameTracer/FrameTracer.h"
John Reck88270902021-03-18 11:27:35 -0400126#include "HdrLayerInfoReporter.h"
Alec Mouri5f487d42020-02-06 09:26:19 -0800127#include "Layer.h"
chaviw0a398992021-08-13 10:13:01 -0500128#include "LayerProtoHelper.h"
Marin Shalamanovf6b5d182020-06-12 02:08:51 +0200129#include "LayerRenderArea.h"
Alec Mouri5f487d42020-02-06 09:26:19 -0800130#include "LayerVector.h"
131#include "MonitoredProducer.h"
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800132#include "MutexUtils.h"
Alec Mouri5f487d42020-02-06 09:26:19 -0800133#include "NativeWindowSurface.h"
134#include "RefreshRateOverlay.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700135#include "RegionSamplingThread.h"
Ana Krulec241cf832018-08-10 15:03:23 -0700136#include "Scheduler/DispSyncSource.h"
Ana Krulecfefcb582018-08-07 14:22:37 -0700137#include "Scheduler/EventThread.h"
Ady Abraham5def7332020-05-29 16:13:47 -0700138#include "Scheduler/LayerHistory.h"
Ana Krulec98b5b242018-08-10 15:03:23 -0700139#include "Scheduler/Scheduler.h"
Ady Abrahamc581d3c2020-08-06 17:34:27 -0700140#include "Scheduler/VsyncConfiguration.h"
Ady Abraham8cb21882020-08-26 18:22:05 -0700141#include "Scheduler/VsyncController.h"
Alec Mouri5f487d42020-02-06 09:26:19 -0800142#include "StartPropertySetThread.h"
143#include "SurfaceFlingerProperties.h"
144#include "SurfaceInterceptor.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800145#include "TimeStats/TimeStats.h"
Galia Peycheva8f04b302021-04-27 13:25:38 +0200146#include "TunnelModeEnabledReporter.h"
chaviw60c9d3e2021-06-04 12:52:17 -0500147#include "WindowInfosListenerInvoker.h"
David Sodman7e4ae112018-02-09 15:02:28 -0800148
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500149#include <aidl/android/hardware/graphics/common/DisplayDecorationSupport.h>
Leon Scroggins III5967aec2021-12-29 11:14:22 -0500150#include <aidl/android/hardware/graphics/composer3/DisplayCapability.h>
Alec Mourifcedb9c2022-04-11 20:02:17 +0000151#include <aidl/android/hardware/graphics/composer3/RenderIntent.h>
Leon Scroggins III5967aec2021-12-29 11:14:22 -0500152
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700153#undef NO_THREAD_SAFETY_ANALYSIS
154#define NO_THREAD_SAFETY_ANALYSIS \
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800155 _Pragma("GCC error \"Prefer <ftl/fake_guard.h> or MutexUtils.h helpers.\"")
Leon Scroggins III5967aec2021-12-29 11:14:22 -0500156
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800157namespace android {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700158
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700159using namespace std::string_literals;
160
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800161using namespace hardware::configstore;
162using namespace hardware::configstore::V1_0;
163using namespace sysprop;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -0800164
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800165using aidl::android::hardware::graphics::common::DisplayDecorationSupport;
166using aidl::android::hardware::graphics::composer3::Capability;
167using aidl::android::hardware::graphics::composer3::DisplayCapability;
Vishnu Nair9cf89262022-02-26 09:17:49 -0800168using CompositionStrategyPredictionState = android::compositionengine::impl::
169 OutputCompositionState::CompositionStrategyPredictionState;
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800170
Yiwei Zhang5434a782018-12-05 18:06:32 -0800171using base::StringAppendF;
Prabir Pradhan48f8cb92021-08-26 14:05:36 -0700172using gui::DisplayInfo;
Huihong Luo6fac5232021-11-22 16:05:23 -0800173using gui::IDisplayEventConnection;
chaviw60c9d3e2021-06-04 12:52:17 -0500174using gui::IWindowInfosListener;
chaviw98318de2021-05-19 16:45:23 -0500175using gui::WindowInfo;
Peiyong Lin9f034472018-03-28 15:29:00 -0700176using ui::ColorMode;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700177using ui::Dataspace;
Daniel Solomon42d04562019-01-20 21:03:19 -0800178using ui::DisplayPrimaries;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700179using ui::RenderIntent;
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900180
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800181using KernelIdleTimerController = scheduler::RefreshRateConfigs::KernelIdleTimerController;
182
Peiyong Line9d809e2020-04-14 13:10:48 -0700183namespace hal = android::hardware::graphics::composer::hal;
184
Steven Thomasb02664d2017-07-26 18:48:28 -0700185namespace {
Peiyong Linfca547f2018-07-09 13:03:33 -0700186
187#pragma clang diagnostic push
188#pragma clang diagnostic error "-Wswitch-enum"
189
190bool isWideColorMode(const ColorMode colorMode) {
191 switch (colorMode) {
192 case ColorMode::DISPLAY_P3:
193 case ColorMode::ADOBE_RGB:
194 case ColorMode::DCI_P3:
195 case ColorMode::BT2020:
Valerie Hau9758ae02018-10-09 16:05:09 -0700196 case ColorMode::DISPLAY_BT2020:
Peiyong Linfca547f2018-07-09 13:03:33 -0700197 case ColorMode::BT2100_PQ:
198 case ColorMode::BT2100_HLG:
199 return true;
200 case ColorMode::NATIVE:
201 case ColorMode::STANDARD_BT601_625:
202 case ColorMode::STANDARD_BT601_625_UNADJUSTED:
203 case ColorMode::STANDARD_BT601_525:
204 case ColorMode::STANDARD_BT601_525_UNADJUSTED:
205 case ColorMode::STANDARD_BT709:
206 case ColorMode::SRGB:
207 return false;
208 }
209 return false;
210}
211
212#pragma clang diagnostic pop
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
217float 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 }
Dominik Laskowskid125d0e2020-05-08 12:36:39 -0700224 return density;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800225}
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
Steven Thomasb02664d2017-07-26 18:48:28 -0700261} // namespace anonymous
262
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800263// ---------------------------------------------------------------------------
264
Mathias Agopian99b49842011-06-27 16:05:52 -0700265const String16 sHardwareTest("android.permission.HARDWARE_TEST");
266const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER");
Hongwei Wang46213ea2020-12-04 17:17:31 -0800267const String16 sRotateSurfaceFlinger("android.permission.ROTATE_SURFACE_FLINGER");
Mathias Agopian99b49842011-06-27 16:05:52 -0700268const String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER");
John Reck88270902021-03-18 11:27:35 -0400269const String16 sControlDisplayBrightness("android.permission.CONTROL_DISPLAY_BRIGHTNESS");
Mathias Agopian99b49842011-06-27 16:05:52 -0700270const String16 sDump("android.permission.DUMP");
chaviwf5bb97b2021-04-28 15:35:37 -0500271const String16 sCaptureBlackoutContent("android.permission.CAPTURE_BLACKOUT_CONTENT");
Leon Scroggins9a20f722021-12-28 14:43:12 +0000272const String16 sInternalSystemWindow("android.permission.INTERNAL_SYSTEM_WINDOW");
chaviwf5bb97b2021-04-28 15:35:37 -0500273
Amy Hsuc8cdfef2020-05-07 13:06:25 +0800274const char* KERNEL_IDLE_TIMER_PROP = "graphics.display.kernel_idle_timer.enabled";
Mathias Agopian99b49842011-06-27 16:05:52 -0700275
276// ---------------------------------------------------------------------------
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700277int64_t SurfaceFlinger::dispSyncPresentTimeOffset;
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700278bool SurfaceFlinger::useHwcForRgbToYuv;
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800279bool SurfaceFlinger::hasSyncFramework;
Fabien Sanglard1971b632017-03-10 14:50:03 -0800280int64_t SurfaceFlinger::maxFrameBufferAcquiredBuffers;
Brian Lindahla13f2d52020-03-05 11:54:17 +0100281uint32_t SurfaceFlinger::maxGraphicsWidth;
282uint32_t SurfaceFlinger::maxGraphicsHeight;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600283bool SurfaceFlinger::hasWideColorDisplay;
Peiyong Linb3839ad2018-09-05 15:37:19 -0700284bool SurfaceFlinger::useContextPriority;
Peiyong Linc6780972018-10-28 15:24:08 -0700285Dataspace SurfaceFlinger::defaultCompositionDataspace = Dataspace::V0_SRGB;
286ui::PixelFormat SurfaceFlinger::defaultCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
287Dataspace SurfaceFlinger::wideColorGamutCompositionDataspace = Dataspace::V0_SRGB;
288ui::PixelFormat SurfaceFlinger::wideColorGamutCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
ramindani4d48f902021-09-20 21:07:45 +0000289LatchUnsignaledConfig SurfaceFlinger::enableLatchUnsignaledConfig;
Mathias Agopian99b49842011-06-27 16:05:52 -0700290
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800291std::string decodeDisplayColorSetting(DisplayColorSetting displayColorSetting) {
292 switch(displayColorSetting) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800293 case DisplayColorSetting::kManaged:
Chia-I Wu0d711262018-05-21 15:19:35 -0700294 return std::string("Managed");
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800295 case DisplayColorSetting::kUnmanaged:
Chia-I Wu0d711262018-05-21 15:19:35 -0700296 return std::string("Unmanaged");
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800297 case DisplayColorSetting::kEnhanced:
Chia-I Wu0d711262018-05-21 15:19:35 -0700298 return std::string("Enhanced");
299 default:
300 return std::string("Unknown ") +
301 std::to_string(static_cast<int>(displayColorSetting));
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800302 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800303}
304
Hongwei Wang46213ea2020-12-04 17:17:31 -0800305bool callingThreadHasRotateSurfaceFlingerAccess() {
306 IPCThreadState* ipc = IPCThreadState::self();
307 const int pid = ipc->getCallingPid();
308 const int uid = ipc->getCallingUid();
309 return uid == AID_GRAPHICS || uid == AID_SYSTEM ||
310 PermissionCache::checkPermission(sRotateSurfaceFlinger, pid, uid);
311}
312
Leon Scroggins9a20f722021-12-28 14:43:12 +0000313bool callingThreadHasInternalSystemWindowAccess() {
314 IPCThreadState* ipc = IPCThreadState::self();
315 const int pid = ipc->getCallingPid();
316 const int uid = ipc->getCallingUid();
Leon Scroggins IIIcf7a7b22021-12-23 20:04:48 -0500317 return uid == AID_GRAPHICS || uid == AID_SYSTEM ||
318 PermissionCache::checkPermission(sInternalSystemWindow, pid, uid);
Leon Scroggins9a20f722021-12-28 14:43:12 +0000319}
320
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700321SurfaceFlinger::SurfaceFlinger(Factory& factory, SkipInitializationTag)
322 : mFactory(factory),
Vishnu Nair7891e962021-11-11 12:07:21 -0800323 mPid(getpid()),
Pablo Gamitoc351d6f2020-09-17 15:34:26 +0000324 mInterceptor(mFactory.createSurfaceInterceptor()),
Yiwei Zhangf0229a72019-09-09 19:28:02 -0700325 mTimeStats(std::make_shared<impl::TimeStats>()),
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -0800326 mFrameTracer(mFactory.createFrameTracer()),
Vishnu Nair7891e962021-11-11 12:07:21 -0800327 mFrameTimeline(mFactory.createFrameTimeline(mTimeStats, mPid)),
Dominik Laskowskieddeda12019-07-19 11:54:13 -0700328 mCompositionEngine(mFactory.createCompositionEngine()),
Dominik Laskowskif06d68e2021-03-24 19:40:03 -0700329 mHwcServiceName(base::GetProperty("debug.sf.hwc_service_name"s, "default"s)),
Robert Carr3e2a2992021-06-11 13:42:55 -0700330 mTunnelModeEnabledReporter(new TunnelModeEnabledReporter()),
Alec Mouridea1ac52021-06-23 18:12:18 -0700331 mEmulatedDisplayDensity(getDensityFromProperty("qemu.sf.lcd_density", false)),
Roman Kiryanovd1e8de92022-11-11 15:35:16 -0800332 mInternalDisplayDensity(
333 getDensityFromProperty("ro.sf.lcd_density", !mEmulatedDisplayDensity)),
Xiang Wang839fe5b2022-04-04 17:39:38 +0000334 mPowerAdvisor(std::make_unique<Hwc2::impl::PowerAdvisor>(*this)),
Dominik Laskowski91f635e2022-01-08 05:46:09 -0800335 mWindowInfosListenerInvoker(sp<WindowInfosListenerInvoker>::make(*this)) {
Dominik Laskowskif06d68e2021-03-24 19:40:03 -0700336 ALOGI("Using HWComposer service: %s", mHwcServiceName.c_str());
Chris Ye0783e992020-06-02 21:34:49 -0700337}
Lloyd Piqueac648ee2018-01-17 13:42:24 -0800338
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700339SurfaceFlinger::SurfaceFlinger(Factory& factory) : SurfaceFlinger(factory, SkipInitialization) {
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800340 ALOGI("SurfaceFlinger is starting");
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800341
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900342 hasSyncFramework = running_without_sync_framework(true);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800343
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900344 dispSyncPresentTimeOffset = present_time_offset_from_vsync_ns(0);
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700345
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900346 useHwcForRgbToYuv = force_hwc_copy_for_virtual_displays(false);
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700347
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900348 maxFrameBufferAcquiredBuffers = max_frame_buffer_acquired_buffers(2);
Fabien Sanglard1971b632017-03-10 14:50:03 -0800349
Brian Lindahla13f2d52020-03-05 11:54:17 +0100350 maxGraphicsWidth = std::max(max_graphics_width(0), 0);
351 maxGraphicsHeight = std::max(max_graphics_height(0), 0);
352
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900353 hasWideColorDisplay = has_wide_color_display(false);
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900354 mDefaultCompositionDataspace =
355 static_cast<ui::Dataspace>(default_composition_dataspace(Dataspace::V0_SRGB));
Peiyong Lin8cabfc32019-06-14 14:25:43 -0700356 mWideColorGamutCompositionDataspace = static_cast<ui::Dataspace>(wcg_composition_dataspace(
357 hasWideColorDisplay ? Dataspace::DISPLAY_P3 : Dataspace::V0_SRGB));
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900358 defaultCompositionDataspace = mDefaultCompositionDataspace;
359 wideColorGamutCompositionDataspace = mWideColorGamutCompositionDataspace;
360 defaultCompositionPixelFormat = static_cast<ui::PixelFormat>(
361 default_composition_pixel_format(ui::PixelFormat::RGBA_8888));
362 wideColorGamutCompositionPixelFormat =
363 static_cast<ui::PixelFormat>(wcg_composition_pixel_format(ui::PixelFormat::RGBA_8888));
Peiyong Linb3839ad2018-09-05 15:37:19 -0700364
Yichi Chenda901bf2019-06-28 14:58:27 +0800365 mColorSpaceAgnosticDataspace =
366 static_cast<ui::Dataspace>(color_space_agnostic_dataspace(Dataspace::UNKNOWN));
367
Alec Mouridd8bf2d2021-05-08 16:36:33 -0700368 mLayerCachingEnabled = [] {
369 const bool enable =
370 android::sysprop::SurfaceFlingerProperties::enable_layer_caching().value_or(false);
371 return base::GetBoolProperty(std::string("debug.sf.enable_layer_caching"), enable);
372 }();
373
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900374 useContextPriority = use_context_priority(true);
Iris Chang7501ed62018-04-30 14:45:42 +0800375
Sundong Ahn85131bd2019-02-18 15:51:53 +0900376 mInternalDisplayPrimaries = sysprop::getDisplayNativePrimaries();
Daniel Solomon42d04562019-01-20 21:03:19 -0800377
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800378 // debugging stuff...
379 char value[PROPERTY_VALUE_MAX];
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700380
Mathias Agopianb4b17302013-03-20 18:36:41 -0700381 property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");
Mathias Agopian50210b92013-03-21 21:13:21 -0700382 mGpuToCpuSupported = !atoi(value);
Mathias Agopianb4b17302013-03-20 18:36:41 -0700383
Alec Mouri5f487d42020-02-06 09:26:19 -0800384 property_get("ro.build.type", value, "user");
385 mIsUserBuild = strcmp(value, "user") == 0;
386
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700387 mDebugFlashDelay = base::GetUintProperty("debug.sf.showupdates"s, 0u);
Orion Hodson34397da2019-02-04 09:36:10 +0000388
389 // DDMS debugging deprecated (b/120782499)
390 property_get("debug.sf.ddms", value, "0");
391 int debugDdms = atoi(value);
392 ALOGI_IF(debugDdms, "DDMS debugging not supported");
Dan Stozac5da2712016-07-20 15:38:12 -0700393
Ady Abrahamadb9a992019-09-19 21:21:55 +0000394 property_get("debug.sf.enable_gl_backpressure", value, "0");
395 mPropagateBackpressureClientComposition = atoi(value);
396 ALOGI_IF(mPropagateBackpressureClientComposition,
397 "Enabling backpressure propagation for Client Composition");
398
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800399 property_get("ro.surface_flinger.supports_background_blur", value, "0");
400 bool supportsBlurs = atoi(value);
Lucas Dupin00f16422020-03-11 11:33:04 -0700401 mSupportsBlur = supportsBlurs;
402 ALOGI_IF(!mSupportsBlur, "Disabling blur effects, they are not supported.");
Lucas Dupin2dd6f392020-02-18 17:43:36 -0800403 property_get("ro.sf.blurs_are_expensive", value, "0");
404 mBlursAreExpensive = atoi(value);
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800405
Ady Abrahamb89ca7d2020-03-04 11:19:37 -0800406 const size_t defaultListSize = ISurfaceComposer::MAX_LAYERS;
Dan Stoza0a0158c2018-03-16 13:38:54 -0700407 auto listSize = property_get_int32("debug.sf.max_igbp_list_size", int32_t(defaultListSize));
408 mMaxGraphicBufferProducerListSize = (listSize > 0) ? size_t(listSize) : defaultListSize;
Alec Mouri601393f2020-02-21 13:26:52 -0800409 mGraphicBufferProducerListSizeLogThreshold =
410 std::max(static_cast<int>(0.95 *
411 static_cast<double>(mMaxGraphicBufferProducerListSize)),
412 1);
Dan Stoza0a0158c2018-03-16 13:38:54 -0700413
Dan Stozaec460082018-12-17 15:35:09 -0800414 property_get("debug.sf.luma_sampling", value, "1");
415 mLumaSampling = atoi(value);
416
Vishnu Nairb2a999b2020-01-23 13:43:02 -0800417 property_get("debug.sf.disable_client_composition_cache", value, "0");
Vishnu Nair9b079a22020-01-21 14:36:08 -0800418 mDisableClientCompositionCache = atoi(value);
419
Vishnu Nair3539d812022-02-26 09:20:17 -0800420 property_get("debug.sf.predict_hwc_composition_strategy", value, "1");
Vishnu Naira3140382022-02-24 14:07:11 -0800421 mPredictCompositionStrategy = atoi(value);
422
Alec Mouridda07d92022-04-25 22:39:25 +0000423 property_get("debug.sf.treat_170m_as_sRGB", value, "0");
424 mTreat170mAsSrgb = atoi(value);
425
Neha Jain7b31cca2023-01-09 23:10:42 +0000426 mIgnoreHwcPhysicalDisplayOrientation =
427 base::GetBoolProperty("debug.sf.ignore_hwc_physical_display_orientation"s, false);
428
Romain Guy11d63f42017-07-20 12:47:14 -0700429 // We should be reading 'persist.sys.sf.color_saturation' here
430 // but since /data may be encrypted, we need to wait until after vold
431 // comes online to attempt to read the property. The property is
432 // instead read after the boot animation
Kalle Raitaa099a242017-01-11 11:17:29 -0800433
Dominik Laskowskif06d68e2021-03-24 19:40:03 -0700434 if (base::GetBoolProperty("debug.sf.treble_testing_override"s, false)) {
Kalle Raitaa099a242017-01-11 11:17:29 -0800435 // Without the override SurfaceFlinger cannot connect to HIDL
436 // services that are not listed in the manifests. Considered
437 // deriving the setting from the set service name, but it
438 // would be brittle if the name that's not 'default' is used
439 // for production purposes later on.
Dominik Laskowskif06d68e2021-03-24 19:40:03 -0700440 ALOGI("Enabling Treble testing override");
Steven Moreland7c8af942020-07-08 18:35:51 +0000441 android::hardware::details::setTrebleTestingOverride(true);
Kalle Raitaa099a242017-01-11 11:17:29 -0800442 }
Ana Krulec3803b8d2020-02-03 16:35:46 -0800443
Ady Abraham29d0da32020-07-16 18:39:33 -0700444 mRefreshRateOverlaySpinner = property_get_bool("sf.debug.show_refresh_rate_overlay_spinner", 0);
John Reckac09e452021-04-07 16:35:37 -0400445
Dominik Laskowski46471e62022-01-14 15:34:03 -0800446 if (!mIsUserBuild && base::GetBoolProperty("debug.sf.enable_transaction_tracing"s, true)) {
447 mTransactionTracing.emplace();
Vishnu Nair7891e962021-11-11 12:07:21 -0800448 }
John Reck49d9ad32022-02-23 19:03:31 -0500449
450 mIgnoreHdrCameraLayers = ignore_hdr_camera_layers(false);
Matt Buckley50c44062022-01-17 20:48:10 +0000451
452 // Power hint session mode, representing which hint(s) to send: early, late, or both)
453 mPowerHintSessionMode =
454 {.late = base::GetBoolProperty("debug.sf.send_late_power_session_hint"s, true),
Matt Buckley00948702022-07-20 20:53:32 +0000455 .early = base::GetBoolProperty("debug.sf.send_early_power_session_hint"s, false)};
ramindani4d48f902021-09-20 21:07:45 +0000456}
457
458LatchUnsignaledConfig SurfaceFlinger::getLatchUnsignaledConfig() {
459 if (base::GetBoolProperty("debug.sf.latch_unsignaled"s, false)) {
460 return LatchUnsignaledConfig::Always;
ramindani4d48f902021-09-20 21:07:45 +0000461 }
Ady Abraham9dada822022-02-03 10:26:59 -0800462
Ady Abrahamd9e8d1b2022-02-25 00:36:10 +0000463 if (base::GetBoolProperty("debug.sf.auto_latch_unsignaled"s, true)) {
Ady Abraham9dada822022-02-03 10:26:59 -0800464 return LatchUnsignaledConfig::AutoSingleLayer;
465 }
466
467 return LatchUnsignaledConfig::Disabled;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800468}
469
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700470SurfaceFlinger::~SurfaceFlinger() = default;
471
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700472void SurfaceFlinger::binderDied(const wp<IBinder>&) {
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800473 // the window manager died on us. prepare its eulogy.
Rob Carr2aa78cb2020-03-10 14:27:49 -0700474 mBootFinished = false;
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800475
Dominik Laskowski756b7892021-08-04 12:53:59 -0700476 // Sever the link to inputflinger since it's gone as well.
Jaineel Mehtaac331c52021-11-29 21:38:10 +0000477 static_cast<void>(mScheduler->schedule([=] { mInputFlinger = nullptr; }));
Vishnu Nairb9df4702021-03-01 11:53:15 -0800478
Andy McFadden13a082e2012-08-24 10:16:42 -0700479 // restore initial conditions (default device unblank, etc)
480 initializeDisplays();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800481
482 // restart the boot-animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700483 startBootAnim();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800484}
485
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700486void SurfaceFlinger::run() {
Dominik Laskowski756b7892021-08-04 12:53:59 -0700487 mScheduler->run();
Robert Carr1db73f62016-12-21 12:58:51 -0800488}
489
490sp<ISurfaceComposerClient> SurfaceFlinger::createConnection() {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700491 const sp<Client> client = new Client(this);
492 return client->initCheck() == NO_ERROR ? client : nullptr;
Robert Carr1db73f62016-12-21 12:58:51 -0800493}
494
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700495sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName, bool secure) {
chaviwd4a61642020-09-01 14:53:46 -0700496 // onTransact already checks for some permissions, but adding an additional check here.
497 // This is to ensure that only system and graphics can request to create a secure
498 // display. Secure displays can show secure content so we add an additional restriction on it.
499 const int uid = IPCThreadState::self()->getCallingUid();
500 if (secure && uid != AID_GRAPHICS && uid != AID_SYSTEM) {
501 ALOGE("Only privileged processes can create a secure display");
502 return nullptr;
503 }
504
Mathias Agopiane57f2922012-08-09 16:29:12 -0700505 class DisplayToken : public BBinder {
506 sp<SurfaceFlinger> flinger;
507 virtual ~DisplayToken() {
508 // no more references, this display must be terminated
509 Mutex::Autolock _l(flinger->mStateLock);
510 flinger->mCurrentState.displays.removeItem(this);
511 flinger->setTransactionFlags(eDisplayTransactionNeeded);
512 }
513 public:
Chih-Hung Hsiehc4067912016-05-03 14:03:27 -0700514 explicit DisplayToken(const sp<SurfaceFlinger>& flinger)
Mathias Agopiane57f2922012-08-09 16:29:12 -0700515 : flinger(flinger) {
516 }
517 };
518
519 sp<BBinder> token = new DisplayToken(this);
520
521 Mutex::Autolock _l(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700522 // Display ID is assigned when virtual display is allocated by HWC.
523 DisplayDeviceState state;
524 state.isSecure = secure;
525 state.displayName = displayName;
526 mCurrentState.displays.add(token, state);
527 mInterceptor->saveDisplayCreation(state);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700528 return token;
529}
530
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700531void SurfaceFlinger::destroyDisplay(const sp<IBinder>& displayToken) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700532 Mutex::Autolock lock(mStateLock);
Jesse Hall6c913be2013-08-08 12:15:49 -0700533
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700534 const ssize_t index = mCurrentState.displays.indexOfKey(displayToken);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700535 if (index < 0) {
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -0800536 ALOGE("%s: Invalid display token %p", __func__, displayToken.get());
Jesse Hall6c913be2013-08-08 12:15:49 -0700537 return;
538 }
539
Dominik Laskowski075d3172018-05-24 15:50:06 -0700540 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700541 if (state.physical) {
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -0800542 ALOGE("%s: Invalid operation on physical display", __func__);
Jesse Hall6c913be2013-08-08 12:15:49 -0700543 return;
544 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700545 mInterceptor->saveDisplayDeletion(state.sequenceId);
546 mCurrentState.displays.removeItemsAt(index);
Jesse Hall6c913be2013-08-08 12:15:49 -0700547 setTransactionFlags(eDisplayTransactionNeeded);
548}
549
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800550void SurfaceFlinger::enableHalVirtualDisplays(bool enable) {
551 auto& generator = mVirtualDisplayIdGenerators.hal;
552 if (!generator && enable) {
553 ALOGI("Enabling HAL virtual displays");
554 generator.emplace(getHwComposer().getMaxVirtualDisplayCount());
555 } else if (generator && !enable) {
556 ALOGW_IF(generator->inUse(), "Disabling HAL virtual displays while in use");
557 generator.reset();
558 }
559}
560
Dominik Laskowski263eec42021-07-21 23:13:24 -0700561VirtualDisplayId SurfaceFlinger::acquireVirtualDisplay(ui::Size resolution,
562 ui::PixelFormat format) {
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800563 if (auto& generator = mVirtualDisplayIdGenerators.hal) {
564 if (const auto id = generator->generateId()) {
Dominik Laskowski263eec42021-07-21 23:13:24 -0700565 if (getHwComposer().allocateVirtualDisplay(*id, resolution, &format)) {
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800566 return *id;
567 }
568
569 generator->releaseId(*id);
570 } else {
571 ALOGW("%s: Exhausted HAL virtual displays", __func__);
572 }
573
574 ALOGW("%s: Falling back to GPU virtual display", __func__);
575 }
576
577 const auto id = mVirtualDisplayIdGenerators.gpu.generateId();
578 LOG_ALWAYS_FATAL_IF(!id, "Failed to generate ID for GPU virtual display");
579 return *id;
580}
581
582void SurfaceFlinger::releaseVirtualDisplay(VirtualDisplayId displayId) {
583 if (const auto id = HalVirtualDisplayId::tryCast(displayId)) {
584 if (auto& generator = mVirtualDisplayIdGenerators.hal) {
585 generator->releaseId(*id);
586 }
587 return;
588 }
589
590 const auto id = GpuVirtualDisplayId::tryCast(displayId);
591 LOG_ALWAYS_FATAL_IF(!id);
592 mVirtualDisplayIdGenerators.gpu.releaseId(*id);
593}
594
Ady Abrahamed3290f2021-05-17 15:12:14 -0700595std::vector<PhysicalDisplayId> SurfaceFlinger::getPhysicalDisplayIdsLocked() const {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800596 std::vector<PhysicalDisplayId> displayIds;
597 displayIds.reserve(mPhysicalDisplayTokens.size());
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700598
Dominik Laskowski3c363242022-04-07 10:44:12 -0700599 const auto defaultDisplayId = getDefaultDisplayDeviceLocked()->getPhysicalId();
Ady Abraham2a0066d2021-07-15 20:16:58 -0700600 displayIds.push_back(defaultDisplayId);
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800601
602 for (const auto& [id, token] : mPhysicalDisplayTokens) {
Ady Abraham2a0066d2021-07-15 20:16:58 -0700603 if (id != defaultDisplayId) {
Marin Shalamanova524a092020-07-27 21:39:55 +0200604 displayIds.push_back(id);
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800605 }
Mathias Agopiane57f2922012-08-09 16:29:12 -0700606 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700607
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800608 return displayIds;
609}
610
Vishnu Nair8c8db542021-09-17 19:51:45 -0700611status_t SurfaceFlinger::getPrimaryPhysicalDisplayId(PhysicalDisplayId* id) const {
612 Mutex::Autolock lock(mStateLock);
Dominik Laskowski3c363242022-04-07 10:44:12 -0700613 *id = getPrimaryDisplayIdLocked();
Vishnu Nair8c8db542021-09-17 19:51:45 -0700614 return NO_ERROR;
615}
616
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800617sp<IBinder> SurfaceFlinger::getPhysicalDisplayToken(PhysicalDisplayId displayId) const {
618 Mutex::Autolock lock(mStateLock);
Marin Shalamanova524a092020-07-27 21:39:55 +0200619 return getPhysicalDisplayTokenLocked(displayId);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700620}
621
Ady Abraham37965d42018-11-01 13:43:32 -0700622status_t SurfaceFlinger::getColorManagement(bool* outGetColorManagement) const {
623 if (!outGetColorManagement) {
624 return BAD_VALUE;
625 }
626 *outGetColorManagement = useColorManagement;
627 return NO_ERROR;
Ady Abraham2a6ab2a2018-10-26 14:25:30 -0700628}
629
Lloyd Pique441d5042018-10-18 16:49:51 -0700630HWComposer& SurfaceFlinger::getHwComposer() const {
631 return mCompositionEngine->getHwComposer();
632}
633
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700634renderengine::RenderEngine& SurfaceFlinger::getRenderEngine() const {
635 return mCompositionEngine->getRenderEngine();
636}
637
Lloyd Pique70d91362018-10-18 16:02:55 -0700638compositionengine::CompositionEngine& SurfaceFlinger::getCompositionEngine() const {
639 return *mCompositionEngine.get();
640}
641
Marin Shalamanov53fc11d2020-11-20 14:00:13 +0100642void SurfaceFlinger::bootFinished() {
Rob Carr2aa78cb2020-03-10 14:27:49 -0700643 if (mBootFinished == true) {
644 ALOGE("Extra call to bootFinished");
645 return;
646 }
647 mBootFinished = true;
Wei Wangf9b05ee2017-07-19 20:59:39 -0700648 if (mStartPropertySetThread->join() != NO_ERROR) {
649 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800650 }
Ady Abrahamfe2a6db2021-06-09 15:41:37 -0700651
652 if (mRenderEnginePrimeCacheFuture.valid()) {
653 mRenderEnginePrimeCacheFuture.get();
654 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800655 const nsecs_t now = systemTime();
656 const nsecs_t duration = now - mBootTime;
Steve Blocka19954a2012-01-04 20:05:49 +0000657 ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700658
Mikael Pessa90092f42019-08-26 17:22:04 -0700659 mFrameTracer->initialize();
Adithya Srinivasan01189672020-10-20 14:23:05 -0700660 mFrameTimeline->onBootFinished();
Robert Carr9b623c32022-03-21 15:55:22 -0700661 getRenderEngine().setEnableTracing(mFlagManager.use_skia_tracing());
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700662
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700663 // wait patiently for the window manager death
664 const String16 name("window");
Steven Morelanda904bb92019-07-02 17:37:23 -0700665 mWindowManager = defaultServiceManager()->getService(name);
666 if (mWindowManager != 0) {
667 mWindowManager->linkToDeath(static_cast<IBinder::DeathRecipient*>(this));
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700668 }
669
670 // stop boot animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700671 // formerly we would just kill the process, but we now ask it to exit so it
672 // can choose where to stop the animation.
673 property_set("service.bootanim.exit", "1");
Yusuke Sato0a688f52015-07-30 23:05:39 -0700674
675 const int LOGTAG_SF_STOP_BOOTANIM = 60110;
676 LOG_EVENT_LONG(LOGTAG_SF_STOP_BOOTANIM,
677 ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
Romain Guy11d63f42017-07-20 12:47:14 -0700678
Denis Hsue70cc6c2020-06-17 10:17:30 +0800679 sp<IBinder> input(defaultServiceManager()->getService(String16("inputflinger")));
680
Jaineel Mehtaac331c52021-11-29 21:38:10 +0000681 static_cast<void>(mScheduler->schedule([=] {
Denis Hsue70cc6c2020-06-17 10:17:30 +0800682 if (input == nullptr) {
683 ALOGE("Failed to link to input service");
684 } else {
Chris Ye0783e992020-06-02 21:34:49 -0700685 mInputFlinger = interface_cast<os::IInputFlinger>(input);
Denis Hsue70cc6c2020-06-17 10:17:30 +0800686 }
687
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800688 readPersistentProperties();
Xiang Wang839fe5b2022-04-04 17:39:38 +0000689 mPowerAdvisor->onBootFinished();
Xiang Wang65a2e6f2022-04-18 21:19:17 +0000690 const bool powerHintEnabled = mFlagManager.use_adpf_cpu_hint();
691 mPowerAdvisor->enablePowerHint(powerHintEnabled);
692 const bool powerHintUsed = mPowerAdvisor->usePowerHintSession();
693 ALOGD("Power hint is %s",
694 powerHintUsed ? "supported" : (powerHintEnabled ? "unsupported" : "disabled"));
695 if (powerHintUsed) {
Xiang Wang76236e12022-03-22 17:25:30 +0000696 std::optional<pid_t> renderEngineTid = getRenderEngine().getRenderEngineTid();
697 std::vector<int32_t> tidList;
698 tidList.emplace_back(gettid());
699 if (renderEngineTid.has_value()) {
700 tidList.emplace_back(*renderEngineTid);
701 }
Xiang Wang839fe5b2022-04-04 17:39:38 +0000702 if (!mPowerAdvisor->startPowerHintSession(tidList)) {
Xiang Wange12b4fa2022-03-25 23:48:40 +0000703 ALOGW("Cannot start power hint session");
704 }
Matt Buckleyef51fba2021-10-12 19:30:12 +0000705 }
706
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800707 mBootStage = BootStage::FINISHED;
Ana Krulecbd6654b2019-02-15 15:18:15 -0800708
Ady Abraham8a82ba62020-01-17 12:43:17 -0800709 if (property_get_bool("sf.debug.show_refresh_rate_overlay", false)) {
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800710 FTL_FAKE_GUARD(mStateLock, enableRefreshRateOverlay(true));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800711 }
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800712 }));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800713}
714
Dan Stoza436ccf32018-06-21 12:10:12 -0700715uint32_t SurfaceFlinger::getNewTexture() {
716 {
717 std::lock_guard lock(mTexturePoolMutex);
718 if (!mTexturePool.empty()) {
719 uint32_t name = mTexturePool.back();
720 mTexturePool.pop_back();
721 ATRACE_INT("TexturePoolSize", mTexturePool.size());
722 return name;
723 }
724
725 // The pool was too small, so increase it for the future
726 ++mTexturePoolSize;
727 }
728
729 // The pool was empty, so we need to get a new texture name directly using a
730 // blocking call to the main thread
Robert Carrcdd7df92021-04-12 15:32:09 -0700731 auto genTextures = [this] {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700732 uint32_t name = 0;
733 getRenderEngine().genTextures(1, &name);
734 return name;
Robert Carrcdd7df92021-04-12 15:32:09 -0700735 };
736 if (std::this_thread::get_id() == mMainThreadId) {
737 return genTextures();
738 } else {
Dominik Laskowski756b7892021-08-04 12:53:59 -0700739 return mScheduler->schedule(genTextures).get();
Robert Carrcdd7df92021-04-12 15:32:09 -0700740 }
Dan Stoza436ccf32018-06-21 12:10:12 -0700741}
742
Mathias Agopian3f844832013-08-07 21:24:32 -0700743void SurfaceFlinger::deleteTextureAsync(uint32_t texture) {
Dan Stoza67765d82019-05-07 14:58:27 -0700744 std::lock_guard lock(mTexturePoolMutex);
745 // We don't change the pool size, so the fix-up logic in postComposition will decide whether
746 // to actually delete this or not based on mTexturePoolSize
747 mTexturePool.push_back(texture);
748 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700749}
750
Leon Scroggins IIIc77162c2021-11-16 17:13:08 -0500751static std::optional<renderengine::RenderEngine::RenderEngineType>
752chooseRenderEngineTypeViaSysProp() {
753 char prop[PROPERTY_VALUE_MAX];
754 property_get(PROPERTY_DEBUG_RENDERENGINE_BACKEND, prop, "");
755
756 if (strcmp(prop, "gles") == 0) {
757 return renderengine::RenderEngine::RenderEngineType::GLES;
758 } else if (strcmp(prop, "threaded") == 0) {
759 return renderengine::RenderEngine::RenderEngineType::THREADED;
760 } else if (strcmp(prop, "skiagl") == 0) {
761 return renderengine::RenderEngine::RenderEngineType::SKIA_GL;
762 } else if (strcmp(prop, "skiaglthreaded") == 0) {
763 return renderengine::RenderEngine::RenderEngineType::SKIA_GL_THREADED;
764 } else {
765 ALOGE("Unrecognized RenderEngineType %s; ignoring!", prop);
766 return {};
767 }
768}
769
Wei Wangf9b05ee2017-07-19 20:59:39 -0700770// Do not call property_set on main thread which will be blocked by init
771// Use StartPropertySetThread instead.
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700772void SurfaceFlinger::init() {
Mathias Agopiana4912602012-07-12 14:25:33 -0700773 ALOGI( "SurfaceFlinger's main thread ready to run. "
774 "Initializing graphics H/W...");
Steven Thomasb02664d2017-07-26 18:48:28 -0700775 Mutex::Autolock _l(mStateLock);
Kevin DuBois413287f2019-02-25 08:46:47 -0800776
Steven Thomasb02664d2017-07-26 18:48:28 -0700777 // Get a RenderEngine for the given display / config (can't fail)
Peiyong Lin0256f722018-08-31 15:45:10 -0700778 // TODO(b/77156734): We need to stop casting and use HAL types when possible.
Alec Mourida4cf3b2019-02-12 15:33:01 -0800779 // Sending maxFrameBufferAcquiredBuffers as the cache size is tightly tuned to single-display.
Leon Scroggins IIIc77162c2021-11-16 17:13:08 -0500780 auto builder = renderengine::RenderEngineCreationArgs::Builder()
781 .setPixelFormat(static_cast<int32_t>(defaultCompositionPixelFormat))
782 .setImageCacheSize(maxFrameBufferAcquiredBuffers)
783 .setUseColorManagerment(useColorManagement)
784 .setEnableProtectedContext(enable_protected_contents(false))
785 .setPrecacheToneMapperShaderOnly(false)
786 .setSupportsBackgroundBlur(mSupportsBlur)
787 .setContextPriority(
788 useContextPriority
789 ? renderengine::RenderEngine::ContextPriority::REALTIME
790 : renderengine::RenderEngine::ContextPriority::MEDIUM);
791 if (auto type = chooseRenderEngineTypeViaSysProp()) {
792 builder.setRenderEngineType(type.value());
793 }
794 mCompositionEngine->setRenderEngine(renderengine::RenderEngine::create(builder.build()));
Garfield Tan9c9c1912021-07-19 12:02:16 -0700795 mMaxRenderTargetSize =
796 std::min(getRenderEngine().getMaxTextureSize(), getRenderEngine().getMaxViewportDims());
Wei Wang976a6452021-06-11 15:26:00 -0700797
798 // Set SF main policy after initializing RenderEngine which has its own policy.
799 if (!SetTaskProfiles(0, {"SFMainPolicy"})) {
800 ALOGW("Failed to set main task profile");
801 }
802
Alec Mourie4034bb2019-11-19 12:45:54 -0800803 mCompositionEngine->setTimeStats(mTimeStats);
Dominik Laskowskif06d68e2021-03-24 19:40:03 -0700804 mCompositionEngine->setHwComposer(getFactory().createHWComposer(mHwcServiceName));
Yichi Chen3401b562022-01-17 15:42:35 +0800805 mCompositionEngine->getHwComposer().setCallback(*this);
Alec Mouria90a5702021-04-16 16:36:21 +0000806 ClientCache::getInstance().setRenderEngine(&getRenderEngine());
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800807
Ady Abraham9dada822022-02-03 10:26:59 -0800808 enableLatchUnsignaledConfig = getLatchUnsignaledConfig();
809
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800810 if (base::GetBoolProperty("debug.sf.enable_hwc_vds"s, false)) {
811 enableHalVirtualDisplays(true);
812 }
813
Lloyd Piqueba04e622017-12-14 17:11:26 -0800814 // Process any initial hotplug and resulting display changes.
815 processDisplayHotplugEventsLocked();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700816 const auto display = getDefaultDisplayDeviceLocked();
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700817 LOG_ALWAYS_FATAL_IF(!display, "Missing primary display after registering composer callback.");
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200818 const auto displayId = display->getPhysicalId();
819 LOG_ALWAYS_FATAL_IF(!getHwComposer().isConnected(displayId),
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700820 "Primary display is disconnected.");
Jesse Hall692c7232012-11-08 15:41:56 -0800821
Mathias Agopian92a979a2012-08-02 18:32:23 -0700822 // initialize our drawing state
823 mDrawingState = mCurrentState;
Mathias Agopian86303202012-07-24 22:46:10 -0700824
Andy McFadden13a082e2012-08-24 10:16:42 -0700825 // set initial conditions (e.g. unblank default device)
826 initializeDisplays();
827
Xiang Wang839fe5b2022-04-04 17:39:38 +0000828 mPowerAdvisor->init();
Alec Mouridea1ac52021-06-23 18:12:18 -0700829
Steven Thomas137d4bc2019-07-25 16:55:14 -0700830 char primeShaderCache[PROPERTY_VALUE_MAX];
831 property_get("service.sf.prime_shader_cache", primeShaderCache, "1");
832 if (atoi(primeShaderCache)) {
Ady Abrahamfe2a6db2021-06-09 15:41:37 -0700833 if (setSchedFifo(false) != NO_ERROR) {
834 ALOGW("Can't set SCHED_OTHER for primeCache");
835 }
836
837 mRenderEnginePrimeCacheFuture = getRenderEngine().primeCache();
838
839 if (setSchedFifo(true) != NO_ERROR) {
840 ALOGW("Can't set SCHED_OTHER for primeCache");
841 }
Steven Thomas137d4bc2019-07-25 16:55:14 -0700842 }
Dan Stoza4e637772016-07-28 13:31:51 -0700843
Ady Abrahamed3290f2021-05-17 15:12:14 -0700844 onActiveDisplaySizeChanged(display);
Derek Sollenbergerc4a05e12021-03-24 16:45:20 -0400845
Wei Wangf9b05ee2017-07-19 20:59:39 -0700846 // Inform native graphics APIs whether the present timestamp is supported:
Lloyd Pique90c115d2018-09-18 21:39:42 -0700847
848 const bool presentFenceReliable =
Ady Abrahamde549d42022-01-26 19:19:17 -0800849 !getHwComposer().hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE);
Lloyd Pique90c115d2018-09-18 21:39:42 -0700850 mStartPropertySetThread = getFactory().createStartPropertySetThread(presentFenceReliable);
Wei Wangf9b05ee2017-07-19 20:59:39 -0700851
852 if (mStartPropertySetThread->Start() != NO_ERROR) {
853 ALOGE("Run StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800854 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800855
Dan Stoza9e56aa02015-11-02 13:00:03 -0800856 ALOGV("Done initializing");
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700857}
858
Romain Guy11d63f42017-07-20 12:47:14 -0700859void SurfaceFlinger::readPersistentProperties() {
Chia-I Wu28f320b2018-05-03 11:02:56 -0700860 Mutex::Autolock _l(mStateLock);
861
Romain Guy11d63f42017-07-20 12:47:14 -0700862 char value[PROPERTY_VALUE_MAX];
863
864 property_get("persist.sys.sf.color_saturation", value, "1.0");
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800865 mGlobalSaturationFactor = atof(value);
Chia-I Wu28f320b2018-05-03 11:02:56 -0700866 updateColorMatrixLocked();
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800867 ALOGV("Saturation is set to %.2f", mGlobalSaturationFactor);
Romain Guy54f154a2017-10-24 21:40:32 +0100868
869 property_get("persist.sys.sf.native_mode", value, "0");
Chia-I Wu0d711262018-05-21 15:19:35 -0700870 mDisplayColorSetting = static_cast<DisplayColorSetting>(atoi(value));
Peiyong Lina3ea5592019-02-10 14:45:00 -0800871
872 property_get("persist.sys.sf.color_mode", value, "0");
873 mForceColorMode = static_cast<ColorMode>(atoi(value));
Romain Guy11d63f42017-07-20 12:47:14 -0700874}
875
Mathias Agopiana67e4182012-06-19 17:26:12 -0700876void SurfaceFlinger::startBootAnim() {
Wei Wangb254fa32017-01-31 17:43:23 -0800877 // Start boot animation service by setting a property mailbox
878 // if property setting thread is already running, Start() will be just a NOP
Wei Wangf9b05ee2017-07-19 20:59:39 -0700879 mStartPropertySetThread->Start();
Wei Wangb254fa32017-01-31 17:43:23 -0800880 // Wait until property was set
Wei Wangf9b05ee2017-07-19 20:59:39 -0700881 if (mStartPropertySetThread->join() != NO_ERROR) {
882 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800883 }
Mathias Agopiana67e4182012-06-19 17:26:12 -0700884}
885
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800886// ----------------------------------------------------------------------------
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800887
Jamie Gennis582270d2011-08-17 18:19:00 -0700888bool SurfaceFlinger::authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800889 const sp<IGraphicBufferProducer>& bufferProducer) const {
Jamie Gennis134f0422011-03-08 12:18:54 -0800890 Mutex::Autolock _l(mStateLock);
Robert Carr0d480722017-01-10 16:42:54 -0800891 return authenticateSurfaceTextureLocked(bufferProducer);
892}
893
894bool SurfaceFlinger::authenticateSurfaceTextureLocked(
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -0800895 const sp<IGraphicBufferProducer>& /* bufferProducer */) const {
896 return false;
Jamie Gennis134f0422011-03-08 12:18:54 -0800897}
898
Brian Anderson6b376712017-04-04 10:51:39 -0700899status_t SurfaceFlinger::getSupportedFrameTimestamps(
900 std::vector<FrameEvent>* outSupported) const {
901 *outSupported = {
902 FrameEvent::REQUESTED_PRESENT,
903 FrameEvent::ACQUIRE,
904 FrameEvent::LATCH,
905 FrameEvent::FIRST_REFRESH_START,
906 FrameEvent::LAST_REFRESH_START,
907 FrameEvent::GPU_COMPOSITION_DONE,
908 FrameEvent::DEQUEUE_READY,
909 FrameEvent::RELEASE,
910 };
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800911
912 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
913
Ady Abrahamde549d42022-01-26 19:19:17 -0800914 if (!getHwComposer().hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
Brian Anderson6b376712017-04-04 10:51:39 -0700915 outSupported->push_back(FrameEvent::DISPLAY_PRESENT);
916 }
917 return NO_ERROR;
918}
919
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800920status_t SurfaceFlinger::getDisplayState(const sp<IBinder>& displayToken, ui::DisplayState* state) {
921 if (!displayToken || !state) {
922 return BAD_VALUE;
923 }
924
925 Mutex::Autolock lock(mStateLock);
926
927 const auto display = getDisplayDeviceLocked(displayToken);
928 if (!display) {
929 return NAME_NOT_FOUND;
930 }
931
932 state->layerStack = display->getLayerStack();
933 state->orientation = display->getOrientation();
934
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200935 const Rect layerStackRect = display->getLayerStackSpaceRect();
936 state->layerStackSpaceRect =
937 layerStackRect.isValid() ? layerStackRect.getSize() : display->getSize();
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800938
939 return NO_ERROR;
940}
941
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100942status_t SurfaceFlinger::getStaticDisplayInfo(const sp<IBinder>& displayToken,
943 ui::StaticDisplayInfo* info) {
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800944 if (!displayToken || !info) {
945 return BAD_VALUE;
946 }
947
948 Mutex::Autolock lock(mStateLock);
949
950 const auto display = getDisplayDeviceLocked(displayToken);
951 if (!display) {
952 return NAME_NOT_FOUND;
953 }
954
Dominik Laskowski55c85402020-01-21 16:25:47 -0800955 if (const auto connectionType = display->getConnectionType())
956 info->connectionType = *connectionType;
957 else {
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800958 return INVALID_OPERATION;
959 }
960
961 if (mEmulatedDisplayDensity) {
962 info->density = mEmulatedDisplayDensity;
963 } else {
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100964 info->density = info->connectionType == ui::DisplayConnectionType::Internal
Dominik Laskowski55c85402020-01-21 16:25:47 -0800965 ? mInternalDisplayDensity
966 : FALLBACK_DENSITY;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800967 }
Dominik Laskowskid125d0e2020-05-08 12:36:39 -0700968 info->density /= ACONFIGURATION_DENSITY_MEDIUM;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800969
970 info->secure = display->isSecure();
Marin Shalamanove5cceea2020-04-30 18:13:10 +0200971 info->deviceProductInfo = display->getDeviceProductInfo();
ramindani06e518e2022-03-14 18:47:53 +0000972 info->installOrientation = display->getPhysicalOrientation();
Vishnu Naird0a89652022-01-13 12:05:54 -0800973
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800974 return NO_ERROR;
975}
976
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100977status_t SurfaceFlinger::getDynamicDisplayInfo(const sp<IBinder>& displayToken,
978 ui::DynamicDisplayInfo* info) {
979 if (!displayToken || !info) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700980 return BAD_VALUE;
981 }
982
Dominik Laskowski22488f62019-03-28 09:53:04 -0700983 Mutex::Autolock lock(mStateLock);
984
Marin Shalamanov5801c942020-12-17 17:00:13 +0100985 const auto display = getDisplayDeviceLocked(displayToken);
986 if (!display) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700987 return NAME_NOT_FOUND;
Mathias Agopianc666cae2012-07-25 18:56:13 -0700988 }
Mathias Agopian8b736f12012-08-13 17:54:26 -0700989
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700990 const auto displayId = PhysicalDisplayId::tryCast(display->getId());
991 if (!displayId) {
992 return INVALID_OPERATION;
993 }
994
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -0800995 info->activeDisplayModeId = display->getActiveMode()->getId().value();
Mathias Agopian1604f772012-09-18 21:54:42 -0700996
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100997 const auto& supportedModes = display->getSupportedModes();
998 info->supportedDisplayModes.clear();
999 info->supportedDisplayModes.reserve(supportedModes.size());
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001000
1001 for (const auto& [id, mode] : supportedModes) {
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001002 ui::DisplayMode outMode;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001003 outMode.id = static_cast<int32_t>(id.value());
Dan Stoza7f7da322014-05-02 15:26:25 -07001004
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001005 auto [width, height] = mode->getResolution();
1006 auto [xDpi, yDpi] = mode->getDpi();
Yiwei Zhang27de5df2018-08-23 17:04:51 -07001007
ramindani06e518e2022-03-14 18:47:53 +00001008 if (const auto physicalOrientation = display->getPhysicalOrientation();
1009 physicalOrientation == ui::ROTATION_90 || physicalOrientation == ui::ROTATION_270) {
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001010 std::swap(width, height);
1011 std::swap(xDpi, yDpi);
Dan Stoza7f7da322014-05-02 15:26:25 -07001012 }
1013
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001014 outMode.resolution = ui::Size(width, height);
Ady Abraham2139f732019-11-13 18:56:40 -08001015
Huan Songf7eeb102022-03-28 11:02:38 -07001016 outMode.xDpi = xDpi;
1017 outMode.yDpi = yDpi;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001018
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001019 const nsecs_t period = mode->getVsyncPeriod();
1020 outMode.refreshRate = Fps::fromPeriodNsecs(period).getValue();
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001021
Ady Abraham8287e852020-08-12 14:44:58 -07001022 const auto vsyncConfigSet =
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001023 mVsyncConfiguration->getConfigsForRefreshRate(Fps::fromValue(outMode.refreshRate));
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001024 outMode.appVsyncOffset = vsyncConfigSet.late.appOffset;
1025 outMode.sfVsyncOffset = vsyncConfigSet.late.sfOffset;
1026 outMode.group = mode->getGroup();
Dan Stoza9e56aa02015-11-02 13:00:03 -08001027
Andy McFadden91b2ca82014-06-13 14:04:23 -07001028 // This is how far in advance a buffer must be queued for
1029 // presentation at a given time. If you want a buffer to appear
1030 // on the screen at time N, you must submit the buffer before
1031 // (N - presentationDeadline).
1032 //
1033 // Normally it's one full refresh period (to give SF a chance to
1034 // latch the buffer), but this can be reduced by configuring a
Ady Abraham8cb21882020-08-26 18:22:05 -07001035 // VsyncController offset. Any additional delays introduced by the hardware
Andy McFadden91b2ca82014-06-13 14:04:23 -07001036 // composer or panel must be accounted for here.
1037 //
1038 // We add an additional 1ms to allow for processing time and
1039 // differences between the ideal and actual refresh rate.
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001040 outMode.presentationDeadline = period - outMode.sfVsyncOffset + 1000000;
Dan Stoza7f7da322014-05-02 15:26:25 -07001041
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001042 info->supportedDisplayModes.push_back(outMode);
Mathias Agopian8b736f12012-08-13 17:54:26 -07001043 }
1044
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001045 info->activeColorMode = display->getCompositionDisplay()->getState().colorMode;
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001046 info->supportedColorModes = getDisplayColorModes(*display);
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001047 info->hdrCapabilities = display->getHdrCapabilities();
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001048
Marin Shalamanovb173f752021-02-16 19:38:36 +01001049 info->autoLowLatencyModeSupported =
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001050 getHwComposer().hasDisplayCapability(*displayId,
Leon Scroggins III5967aec2021-12-29 11:14:22 -05001051 DisplayCapability::AUTO_LOW_LATENCY_MODE);
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001052 info->gameContentTypeSupported =
1053 getHwComposer().supportsContentType(*displayId, hal::ContentType::GAME);
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001054
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001055 info->preferredBootDisplayMode = static_cast<ui::DisplayModeId>(-1);
Kriti Dangac0a74d2022-03-16 11:52:35 +01001056
1057 if (getHwComposer().hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001058 if (const auto hwcId = getHwComposer().getPreferredBootDisplayMode(*displayId)) {
1059 if (const auto modeId = display->translateModeId(*hwcId)) {
1060 info->preferredBootDisplayMode = modeId->value();
1061 }
1062 }
1063 }
Kriti Dang646f8ec2022-01-18 14:35:02 +01001064
Dan Stoza7f7da322014-05-02 15:26:25 -07001065 return NO_ERROR;
1066}
Jamie Gennisdd3cb842012-10-19 18:19:11 -07001067
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001068status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>&, DisplayStatInfo* stats) {
1069 if (!stats) {
Lajos Molnar67d8bd62014-09-11 14:58:45 -07001070 return BAD_VALUE;
1071 }
1072
Ady Abrahame90dd522020-12-29 12:08:45 -08001073 *stats = mScheduler->getDisplayStatInfo(systemTime());
Lajos Molnar67d8bd62014-09-11 14:58:45 -07001074 return NO_ERROR;
1075}
1076
Dominik Laskowski76742842022-12-02 14:56:05 -05001077void SurfaceFlinger::setDesiredActiveMode(const ActiveModeInfo& info, bool force) {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001078 ATRACE_CALL();
Ady Abraham690f4612021-07-01 23:24:03 -07001079
1080 if (!info.mode) {
1081 ALOGW("requested display mode is null");
1082 return;
1083 }
1084 auto display = getDisplayDeviceLocked(info.mode->getPhysicalDisplayId());
Ady Abraham3efa3942021-06-24 19:01:25 -07001085 if (!display) {
Ady Abraham690f4612021-07-01 23:24:03 -07001086 ALOGW("%s: display is no longer valid", __func__);
Ady Abraham3efa3942021-06-24 19:01:25 -07001087 return;
1088 }
1089
Dominik Laskowski76742842022-12-02 14:56:05 -05001090 if (display->setDesiredActiveMode(info, force)) {
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07001091 scheduleComposite(FrameHint::kNone);
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001092
Alec Mouri754c98a2019-03-18 18:53:42 -07001093 // Start receiving vsync samples now, so that we can detect a period
1094 // switch.
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001095 mScheduler->resyncToHardwareVsync(true, info.mode->getFps());
Ady Abraham53852a52019-05-28 18:07:44 -07001096 // As we called to set period, we will call to onRefreshRateChangeCompleted once
Ady Abraham8cb21882020-08-26 18:22:05 -07001097 // VsyncController model is locked.
Dominik Laskowski08d05c22020-07-22 00:05:08 -07001098 modulateVsync(&VsyncModulator::onRefreshRateChangeInitiated);
Ady Abraham2139f732019-11-13 18:56:40 -08001099
Ady Abraham690f4612021-07-01 23:24:03 -07001100 updatePhaseConfiguration(info.mode->getFps());
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001101 mScheduler->setModeChangePending(true);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001102 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001103}
1104
Marin Shalamanov85b2bdf2021-11-03 14:31:21 +01001105status_t SurfaceFlinger::setActiveModeFromBackdoor(const sp<IBinder>& displayToken, int modeId) {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001106 ATRACE_CALL();
Ady Abraham838de062019-02-04 10:24:03 -08001107
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001108 if (!displayToken) {
1109 return BAD_VALUE;
1110 }
Ady Abraham838de062019-02-04 10:24:03 -08001111
Dominik Laskowski756b7892021-08-04 12:53:59 -07001112 auto future = mScheduler->schedule([=]() -> status_t {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001113 const auto display = FTL_FAKE_GUARD(mStateLock, getDisplayDeviceLocked(displayToken));
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001114 if (!display) {
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001115 ALOGE("Attempt to set allowed display modes for invalid display token %p",
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001116 displayToken.get());
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001117 return NAME_NOT_FOUND;
Marin Shalamanov5801c942020-12-17 17:00:13 +01001118 }
1119
1120 if (display->isVirtual()) {
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001121 ALOGW("Attempt to set allowed display modes for virtual display");
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001122 return INVALID_OPERATION;
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001123 }
Marin Shalamanov5801c942020-12-17 17:00:13 +01001124
1125 const auto mode = display->getMode(DisplayModeId{modeId});
1126 if (!mode) {
1127 ALOGW("Attempt to switch to an unsupported mode %d.", modeId);
1128 return BAD_VALUE;
1129 }
1130
1131 const auto fps = mode->getFps();
1132 // Keep the old switching type.
1133 const auto allowGroupSwitching =
Ady Abraham3efa3942021-06-24 19:01:25 -07001134 display->refreshRateConfigs().getCurrentPolicy().allowGroupSwitching;
Marin Shalamanov5801c942020-12-17 17:00:13 +01001135 const scheduler::RefreshRateConfigs::Policy policy{mode->getId(),
1136 allowGroupSwitching,
1137 {fps, fps}};
1138 constexpr bool kOverridePolicy = false;
1139
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001140 return setDesiredDisplayModeSpecsInternal(display, policy, kOverridePolicy);
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001141 });
1142
1143 return future.get();
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001144}
1145
Marin Shalamanov85b2bdf2021-11-03 14:31:21 +01001146void SurfaceFlinger::updateInternalStateWithChangedMode() {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001147 ATRACE_CALL();
1148
Dominik Laskowski22488f62019-03-28 09:53:04 -07001149 const auto display = getDefaultDisplayDeviceLocked();
1150 if (!display) {
1151 return;
1152 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001153
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001154 const auto upcomingModeInfo =
1155 FTL_FAKE_GUARD(kMainThreadContext, display->getUpcomingActiveMode());
1156
Ady Abrahamfaac6da2021-07-15 10:04:40 -07001157 if (!upcomingModeInfo.mode) {
1158 // There is no pending mode change. This can happen if the active
1159 // display changed and the mode change happened on a different display.
1160 return;
1161 }
1162
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001163 if (display->getActiveMode()->getResolution() != upcomingModeInfo.mode->getResolution()) {
Marin Shalamanov993ddf42021-05-26 16:54:40 +02001164 auto& state = mCurrentState.displays.editValueFor(display->getDisplayToken());
1165 // We need to generate new sequenceId in order to recreate the display (and this
1166 // way the framebuffer).
1167 state.sequenceId = DisplayDeviceState{}.sequenceId;
Ady Abraham690f4612021-07-01 23:24:03 -07001168 state.physical->activeMode = upcomingModeInfo.mode;
Marin Shalamanov993ddf42021-05-26 16:54:40 +02001169 processDisplayChangesLocked();
1170
1171 // processDisplayChangesLocked will update all necessary components so we're done here.
1172 return;
1173 }
Alec Mouri8de697e2020-03-19 10:52:01 -07001174
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001175 // We just created this display so we can call even if we are not on the main thread.
1176 ftl::FakeGuard guard(kMainThreadContext);
Ady Abraham690f4612021-07-01 23:24:03 -07001177 display->setActiveMode(upcomingModeInfo.mode->getId());
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001178
Ady Abraham690f4612021-07-01 23:24:03 -07001179 const Fps refreshRate = upcomingModeInfo.mode->getFps();
Marin Shalamanov5801c942020-12-17 17:00:13 +01001180 mRefreshRateStats->setRefreshRate(refreshRate);
Dominik Laskowski08d05c22020-07-22 00:05:08 -07001181 updatePhaseConfiguration(refreshRate);
Dominik Laskowski22488f62019-03-28 09:53:04 -07001182
Dominik Laskowski068173d2021-08-11 17:22:59 -07001183 if (upcomingModeInfo.event != DisplayModeEvent::None) {
Ady Abraham690f4612021-07-01 23:24:03 -07001184 mScheduler->onPrimaryDisplayModeChanged(mAppConnectionHandle, upcomingModeInfo.mode);
Ady Abraham447052e2019-02-13 16:07:27 -08001185 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001186}
1187
Ady Abraham690f4612021-07-01 23:24:03 -07001188void SurfaceFlinger::clearDesiredActiveModeState(const sp<DisplayDevice>& display) {
1189 display->clearDesiredActiveModeState();
1190 if (isDisplayActiveLocked(display)) {
1191 mScheduler->setModeChangePending(false);
1192 }
Ady Abraham53852a52019-05-28 18:07:44 -07001193}
1194
Ady Abraham690f4612021-07-01 23:24:03 -07001195void SurfaceFlinger::desiredActiveModeChangeDone(const sp<DisplayDevice>& display) {
1196 const auto refreshRate = display->getDesiredActiveMode()->mode->getFps();
1197 clearDesiredActiveModeState(display);
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001198 mScheduler->resyncToHardwareVsync(true, refreshRate);
Marin Shalamanov5801c942020-12-17 17:00:13 +01001199 updatePhaseConfiguration(refreshRate);
1200}
1201
Marin Shalamanov85b2bdf2021-11-03 14:31:21 +01001202void SurfaceFlinger::setActiveModeInHwcIfNeeded() {
Alec Mourife3dc942019-02-12 14:19:18 -08001203 ATRACE_CALL();
Ady Abraham690f4612021-07-01 23:24:03 -07001204
Marin Shalamanovdd594312021-11-09 16:37:37 +01001205 std::optional<PhysicalDisplayId> displayToUpdateImmediately;
1206
Ady Abraham690f4612021-07-01 23:24:03 -07001207 for (const auto& iter : mDisplays) {
1208 const auto& display = iter.second;
1209 if (!display || !display->isInternal()) {
1210 continue;
1211 }
1212
1213 // Store the local variable to release the lock.
1214 const auto desiredActiveMode = display->getDesiredActiveMode();
1215 if (!desiredActiveMode) {
1216 // No desired active mode pending to be applied
1217 continue;
1218 }
1219
1220 if (!isDisplayActiveLocked(display)) {
1221 // display is no longer the active display, so abort the mode change
1222 clearDesiredActiveModeState(display);
1223 continue;
1224 }
1225
1226 const auto desiredMode = display->getMode(desiredActiveMode->mode->getId());
1227 if (!desiredMode) {
1228 ALOGW("Desired display mode is no longer supported. Mode ID = %d",
1229 desiredActiveMode->mode->getId().value());
1230 clearDesiredActiveModeState(display);
1231 continue;
1232 }
1233
1234 const auto refreshRate = desiredMode->getFps();
1235 ALOGV("%s changing active mode to %d(%s) for display %s", __func__,
1236 desiredMode->getId().value(), to_string(refreshRate).c_str(),
1237 to_string(display->getId()).c_str());
1238
1239 if (display->getActiveMode()->getId() == desiredActiveMode->mode->getId()) {
Marin Shalamanov85b2bdf2021-11-03 14:31:21 +01001240 // we are already in the requested mode, there is nothing left to do
Ady Abraham690f4612021-07-01 23:24:03 -07001241 desiredActiveModeChangeDone(display);
1242 continue;
1243 }
1244
1245 // Desired active mode was set, it is different than the mode currently in use, however
1246 // allowed modes might have changed by the time we process the refresh.
1247 // Make sure the desired mode is still allowed
1248 const auto displayModeAllowed =
1249 display->refreshRateConfigs().isModeAllowed(desiredActiveMode->mode->getId());
1250 if (!displayModeAllowed) {
Marin Shalamanovdd00c002021-11-04 16:54:38 +01001251 clearDesiredActiveModeState(display);
Ady Abraham690f4612021-07-01 23:24:03 -07001252 continue;
1253 }
1254
1255 // TODO(b/142753666) use constrains
1256 hal::VsyncPeriodChangeConstraints constraints;
1257 constraints.desiredTimeNanos = systemTime();
1258 constraints.seamlessRequired = false;
1259 hal::VsyncPeriodChangeTimeline outTimeline;
1260
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001261 const auto status = FTL_FAKE_GUARD(kMainThreadContext,
1262 display->initiateModeChange(*desiredActiveMode,
1263 constraints, &outTimeline));
1264
Ady Abraham690f4612021-07-01 23:24:03 -07001265 if (status != NO_ERROR) {
1266 // initiateModeChange may fail if a hotplug event is just about
1267 // to be sent. We just log the error in this case.
1268 ALOGW("initiateModeChange failed: %d", status);
1269 continue;
1270 }
1271 mScheduler->onNewVsyncPeriodChangeTimeline(outTimeline);
1272
Marin Shalamanovdd594312021-11-09 16:37:37 +01001273 if (outTimeline.refreshRequired) {
Dominik Laskowskidd5827a2022-03-17 12:44:23 -07001274 scheduleComposite(FrameHint::kNone);
Marin Shalamanovdd594312021-11-09 16:37:37 +01001275 mSetActiveModePending = true;
1276 } else {
1277 // Updating the internal state should be done outside the loop,
1278 // because it can recreate a DisplayDevice and modify mDisplays
1279 // which will invalidate the iterator.
1280 displayToUpdateImmediately = display->getPhysicalId();
1281 }
1282 }
1283
1284 if (displayToUpdateImmediately) {
1285 updateInternalStateWithChangedMode();
1286
1287 const auto display = getDisplayDeviceLocked(*displayToUpdateImmediately);
1288 const auto desiredActiveMode = display->getDesiredActiveMode();
1289 if (desiredActiveMode &&
1290 display->getActiveMode()->getId() == desiredActiveMode->mode->getId()) {
1291 desiredActiveModeChangeDone(display);
1292 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001293 }
Mathias Agopianc666cae2012-07-25 18:56:13 -07001294}
Dominik Laskowski075d3172018-05-24 15:50:06 -07001295
Alec Mouridea1ac52021-06-23 18:12:18 -07001296void SurfaceFlinger::disableExpensiveRendering() {
Dominik Laskowski4d5052d2022-03-23 10:35:47 -07001297 const char* const whence = __func__;
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001298 auto future = mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) {
Dominik Laskowski4d5052d2022-03-23 10:35:47 -07001299 ATRACE_NAME(whence);
Xiang Wang839fe5b2022-04-04 17:39:38 +00001300 if (mPowerAdvisor->isUsingExpensiveRendering()) {
Dominik Laskowskibc6c8602022-01-11 08:53:24 -08001301 for (const auto& [_, display] : mDisplays) {
1302 constexpr bool kDisable = false;
Xiang Wang839fe5b2022-04-04 17:39:38 +00001303 mPowerAdvisor->setExpensiveRenderingExpected(display->getId(), kDisable);
Alec Mouridea1ac52021-06-23 18:12:18 -07001304 }
1305 }
Dominik Laskowski756b7892021-08-04 12:53:59 -07001306 });
1307
1308 future.wait();
Alec Mouridea1ac52021-06-23 18:12:18 -07001309}
1310
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001311std::vector<ColorMode> SurfaceFlinger::getDisplayColorModes(const DisplayDevice& display) {
1312 auto modes = getHwComposer().getColorModes(display.getPhysicalId());
Peiyong Linff84a152019-05-17 18:36:19 -07001313
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001314 // If the display is internal and the configuration claims it's not wide color capable,
Peiyong Linff84a152019-05-17 18:36:19 -07001315 // filter out all wide color modes. The typical reason why this happens is that the
1316 // hardware is not good enough to support GPU composition of wide color, and thus the
1317 // OEMs choose to disable this capability.
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001318 if (display.getConnectionType() == ui::DisplayConnectionType::Internal &&
1319 !hasWideColorDisplay) {
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001320 const auto newEnd = std::remove_if(modes.begin(), modes.end(), isWideColorMode);
1321 modes.erase(newEnd, modes.end());
Peiyong Linff84a152019-05-17 18:36:19 -07001322 }
Michael Wright28f24d02016-07-12 13:30:53 -07001323
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001324 return modes;
Michael Wright28f24d02016-07-12 13:30:53 -07001325}
1326
Daniel Solomon42d04562019-01-20 21:03:19 -08001327status_t SurfaceFlinger::getDisplayNativePrimaries(const sp<IBinder>& displayToken,
Dominik Laskowski3c363242022-04-07 10:44:12 -07001328 ui::DisplayPrimaries& primaries) {
Daniel Solomon42d04562019-01-20 21:03:19 -08001329 if (!displayToken) {
1330 return BAD_VALUE;
1331 }
1332
Dominik Laskowski3c363242022-04-07 10:44:12 -07001333 Mutex::Autolock lock(mStateLock);
1334
1335 const auto display = getDisplayDeviceLocked(displayToken);
1336 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001337 return NAME_NOT_FOUND;
Daniel Solomon42d04562019-01-20 21:03:19 -08001338 }
1339
Dominik Laskowski3c363242022-04-07 10:44:12 -07001340 const auto connectionType = display->getConnectionType();
1341 if (connectionType != ui::DisplayConnectionType::Internal) {
1342 return INVALID_OPERATION;
1343 }
1344
1345 // TODO(b/229846990): For now, assume that all internal displays have the same primaries.
1346 primaries = mInternalDisplayPrimaries;
Daniel Solomon42d04562019-01-20 21:03:19 -08001347 return NO_ERROR;
1348}
1349
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001350status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& displayToken, ColorMode mode) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001351 if (!displayToken) {
1352 return BAD_VALUE;
1353 }
1354
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001355 auto future = mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) -> status_t {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001356 const auto display = getDisplayDeviceLocked(displayToken);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001357 if (!display) {
1358 ALOGE("Attempt to set active color mode %s (%d) for invalid display token %p",
1359 decodeColorMode(mode).c_str(), mode, displayToken.get());
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001360 return NAME_NOT_FOUND;
1361 }
1362
1363 if (display->isVirtual()) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001364 ALOGW("Attempt to set active color mode %s (%d) for virtual display",
1365 decodeColorMode(mode).c_str(), mode);
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001366 return INVALID_OPERATION;
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001367 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001368
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001369 const auto modes = getDisplayColorModes(*display);
1370 const bool exists = std::find(modes.begin(), modes.end(), mode) != modes.end();
1371
1372 if (mode < ColorMode::NATIVE || !exists) {
1373 ALOGE("Attempt to set invalid active color mode %s (%d) for display token %p",
1374 decodeColorMode(mode).c_str(), mode, displayToken.get());
1375 return BAD_VALUE;
1376 }
1377
1378 display->getCompositionDisplay()->setColorProfile(
1379 {mode, Dataspace::UNKNOWN, RenderIntent::COLORIMETRIC, Dataspace::UNKNOWN});
1380
1381 return NO_ERROR;
1382 });
1383
Dominik Laskowski0a5f9212021-08-05 17:00:04 -07001384 // TODO(b/195698395): Propagate error.
1385 future.wait();
1386 return NO_ERROR;
Michael Wright28f24d02016-07-12 13:30:53 -07001387}
Mathias Agopianc666cae2012-07-25 18:56:13 -07001388
Kriti Dang7defaf32021-11-15 11:55:43 +01001389status_t SurfaceFlinger::getBootDisplayModeSupport(bool* outSupport) const {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001390 auto future = mScheduler->schedule(
1391 [this] { return getHwComposer().hasCapability(Capability::BOOT_DISPLAY_CONFIG); });
1392
1393 *outSupport = future.get();
1394 return NO_ERROR;
Kriti Dang7defaf32021-11-15 11:55:43 +01001395}
1396
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001397status_t SurfaceFlinger::setBootDisplayMode(const sp<IBinder>& displayToken,
1398 ui::DisplayModeId modeId) {
1399 const char* const whence = __func__;
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001400 auto future = mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) -> status_t {
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001401 const auto display = getDisplayDeviceLocked(displayToken);
1402 if (!display) {
1403 ALOGE("%s: Invalid display token %p", whence, displayToken.get());
1404 return NAME_NOT_FOUND;
1405 }
Kriti Dang30e378d2022-02-18 15:09:12 +01001406
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001407 if (display->isVirtual()) {
1408 ALOGE("%s: Invalid operation on virtual display", whence);
1409 return INVALID_OPERATION;
1410 }
1411
1412 const auto displayId = display->getPhysicalId();
1413 const auto mode = display->getMode(DisplayModeId{modeId});
1414 if (!mode) {
1415 ALOGE("%s: Invalid mode %d for display %s", whence, modeId,
1416 to_string(displayId).c_str());
Kriti Dang7defaf32021-11-15 11:55:43 +01001417 return BAD_VALUE;
1418 }
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001419
1420 return getHwComposer().setBootDisplayMode(displayId, mode->getHwcId());
Kriti Dang7defaf32021-11-15 11:55:43 +01001421 });
1422 return future.get();
1423}
1424
1425status_t SurfaceFlinger::clearBootDisplayMode(const sp<IBinder>& displayToken) {
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001426 const char* const whence = __func__;
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001427 auto future = mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) -> status_t {
Kriti Dang7defaf32021-11-15 11:55:43 +01001428 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
1429 return getHwComposer().clearBootDisplayMode(*displayId);
1430 } else {
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001431 ALOGE("%s: Invalid display token %p", whence, displayToken.get());
Kriti Dang7defaf32021-11-15 11:55:43 +01001432 return BAD_VALUE;
1433 }
1434 });
1435 return future.get();
1436}
1437
Galia Peycheva5492cb52019-10-30 14:13:16 +01001438void SurfaceFlinger::setAutoLowLatencyMode(const sp<IBinder>& displayToken, bool on) {
Dominik Laskowski756b7892021-08-04 12:53:59 -07001439 const char* const whence = __func__;
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001440 static_cast<void>(mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001441 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
1442 getHwComposer().setAutoLowLatencyMode(*displayId, on);
1443 } else {
Dominik Laskowski756b7892021-08-04 12:53:59 -07001444 ALOGE("%s: Invalid display token %p", whence, displayToken.get());
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001445 }
1446 }));
Galia Peycheva5492cb52019-10-30 14:13:16 +01001447}
1448
Galia Peycheva5492cb52019-10-30 14:13:16 +01001449void SurfaceFlinger::setGameContentType(const sp<IBinder>& displayToken, bool on) {
Dominik Laskowski756b7892021-08-04 12:53:59 -07001450 const char* const whence = __func__;
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001451 static_cast<void>(mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001452 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
Peiyong Line9d809e2020-04-14 13:10:48 -07001453 const auto type = on ? hal::ContentType::GAME : hal::ContentType::NONE;
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001454 getHwComposer().setContentType(*displayId, type);
1455 } else {
Dominik Laskowski756b7892021-08-04 12:53:59 -07001456 ALOGE("%s: Invalid display token %p", whence, displayToken.get());
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001457 }
1458 }));
Galia Peycheva5492cb52019-10-30 14:13:16 +01001459}
1460
Svetoslavd85084b2014-03-20 10:28:31 -07001461status_t SurfaceFlinger::clearAnimationFrameStats() {
1462 Mutex::Autolock _l(mStateLock);
1463 mAnimFrameTracker.clearStats();
1464 return NO_ERROR;
1465}
1466
1467status_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const {
1468 Mutex::Autolock _l(mStateLock);
1469 mAnimFrameTracker.getStats(outStats);
1470 return NO_ERROR;
1471}
1472
Kriti Dang49ad4132021-01-08 11:49:56 +01001473status_t SurfaceFlinger::overrideHdrTypes(const sp<IBinder>& displayToken,
1474 const std::vector<ui::Hdr>& hdrTypes) {
1475 Mutex::Autolock lock(mStateLock);
1476
1477 auto display = getDisplayDeviceLocked(displayToken);
1478 if (!display) {
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08001479 ALOGE("%s: Invalid display token %p", __func__, displayToken.get());
Kriti Dang49ad4132021-01-08 11:49:56 +01001480 return NAME_NOT_FOUND;
1481 }
1482
1483 display->overrideHdrTypes(hdrTypes);
1484 dispatchDisplayHotplugEvent(display->getPhysicalId(), true /* connected */);
1485 return NO_ERROR;
1486}
1487
Tej Singhe2751772021-04-06 22:05:29 -07001488status_t SurfaceFlinger::onPullAtom(const int32_t atomId, std::string* pulledData, bool* success) {
1489 *success = mTimeStats->onPullAtom(atomId, pulledData);
1490 return NO_ERROR;
1491}
1492
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001493status_t SurfaceFlinger::getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
1494 ui::PixelFormat* outFormat,
1495 ui::Dataspace* outDataspace,
1496 uint8_t* outComponentMask) const {
1497 if (!outFormat || !outDataspace || !outComponentMask) {
1498 return BAD_VALUE;
1499 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001500
1501 Mutex::Autolock lock(mStateLock);
1502
1503 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1504 if (!displayId) {
1505 return NAME_NOT_FOUND;
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001506 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001507
1508 return getHwComposer().getDisplayedContentSamplingAttributes(*displayId, outFormat,
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001509 outDataspace, outComponentMask);
1510}
1511
Kevin DuBois74e53772018-11-19 10:52:38 -08001512status_t SurfaceFlinger::setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken,
1513 bool enable, uint8_t componentMask,
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001514 uint64_t maxFrames) {
Dominik Laskowski756b7892021-08-04 12:53:59 -07001515 const char* const whence = __func__;
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001516 auto future = mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) -> status_t {
Dominik Laskowski756b7892021-08-04 12:53:59 -07001517 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
1518 return getHwComposer().setDisplayContentSamplingEnabled(*displayId, enable,
1519 componentMask, maxFrames);
1520 } else {
1521 ALOGE("%s: Invalid display token %p", whence, displayToken.get());
1522 return NAME_NOT_FOUND;
1523 }
1524 });
1525
1526 return future.get();
Kevin DuBois74e53772018-11-19 10:52:38 -08001527}
1528
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001529status_t SurfaceFlinger::getDisplayedContentSample(const sp<IBinder>& displayToken,
1530 uint64_t maxFrames, uint64_t timestamp,
1531 DisplayedFrameStats* outStats) const {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001532 Mutex::Autolock lock(mStateLock);
1533
1534 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1535 if (!displayId) {
1536 return NAME_NOT_FOUND;
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001537 }
1538
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001539 return getHwComposer().getDisplayedContentSample(*displayId, maxFrames, timestamp, outStats);
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001540}
1541
Peiyong Lin3c2791e2019-01-14 17:05:18 -08001542status_t SurfaceFlinger::getProtectedContentSupport(bool* outSupported) const {
1543 if (!outSupported) {
1544 return BAD_VALUE;
1545 }
1546 *outSupported = getRenderEngine().supportsProtectedContent();
1547 return NO_ERROR;
1548}
1549
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001550status_t SurfaceFlinger::isWideColorDisplay(const sp<IBinder>& displayToken,
1551 bool* outIsWideColorDisplay) const {
1552 if (!displayToken || !outIsWideColorDisplay) {
1553 return BAD_VALUE;
1554 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001555
1556 Mutex::Autolock lock(mStateLock);
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001557 const auto display = getDisplayDeviceLocked(displayToken);
1558 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001559 return NAME_NOT_FOUND;
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001560 }
Peiyong Linff84a152019-05-17 18:36:19 -07001561
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001562 *outIsWideColorDisplay =
1563 display->isPrimary() ? hasWideColorDisplay : display->hasWideColorGamut();
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001564 return NO_ERROR;
1565}
1566
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001567status_t SurfaceFlinger::enableVSyncInjections(bool enable) {
Dominik Laskowski756b7892021-08-04 12:53:59 -07001568 auto future = mScheduler->schedule([=] {
Dominik Laskowski6505f792019-09-18 11:10:05 -07001569 Mutex::Autolock lock(mStateLock);
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001570
Dominik Laskowski6505f792019-09-18 11:10:05 -07001571 if (const auto handle = mScheduler->enableVSyncInjection(enable)) {
Dominik Laskowski756b7892021-08-04 12:53:59 -07001572 mScheduler->setInjector(enable ? mScheduler->getEventConnection(handle) : nullptr);
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001573 }
Dominik Laskowski756b7892021-08-04 12:53:59 -07001574 });
Dominik Laskowski8c001672018-05-30 16:52:06 -07001575
Dominik Laskowski756b7892021-08-04 12:53:59 -07001576 future.wait();
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001577 return NO_ERROR;
1578}
1579
1580status_t SurfaceFlinger::injectVSync(nsecs_t when) {
Dominik Laskowski6505f792019-09-18 11:10:05 -07001581 Mutex::Autolock lock(mStateLock);
Ady Abrahame90dd522020-12-29 12:08:45 -08001582 const DisplayStatInfo stats = mScheduler->getDisplayStatInfo(when);
Ady Abraham56b42a42020-12-28 16:48:48 -08001583 const auto expectedPresent = calculateExpectedPresentTime(stats);
Ady Abraham9c53ee72020-07-22 21:16:18 -07001584 return mScheduler->injectVSync(when, /*expectedVSyncTime=*/expectedPresent,
1585 /*deadlineTimestamp=*/expectedPresent)
1586 ? NO_ERROR
1587 : BAD_VALUE;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001588}
1589
Vishnu Nair43bccf82020-06-05 10:53:37 -07001590status_t SurfaceFlinger::getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) {
Kalle Raitaa099a242017-01-11 11:17:29 -08001591 outLayers->clear();
Dominik Laskowski756b7892021-08-04 12:53:59 -07001592 auto future = mScheduler->schedule([=] {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001593 const auto display = FTL_FAKE_GUARD(mStateLock, getDefaultDisplayDeviceLocked());
Vishnu Nair43bccf82020-06-05 10:53:37 -07001594 mDrawingState.traverseInZOrder([&](Layer* layer) {
1595 outLayers->push_back(layer->getLayerDebugInfo(display.get()));
1596 });
Dominik Laskowski756b7892021-08-04 12:53:59 -07001597 });
1598
1599 future.wait();
Kalle Raitaa099a242017-01-11 11:17:29 -08001600 return NO_ERROR;
1601}
1602
Peiyong Linc6780972018-10-28 15:24:08 -07001603status_t SurfaceFlinger::getCompositionPreference(
1604 Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
1605 Dataspace* outWideColorGamutDataspace,
1606 ui::PixelFormat* outWideColorGamutPixelFormat) const {
Peiyong Lin9d846a52018-11-05 13:18:20 -08001607 *outDataspace = mDefaultCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001608 *outPixelFormat = defaultCompositionPixelFormat;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001609 *outWideColorGamutDataspace = mWideColorGamutCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001610 *outWideColorGamutPixelFormat = wideColorGamutCompositionPixelFormat;
Peiyong Lin0256f722018-08-31 15:45:10 -07001611 return NO_ERROR;
1612}
1613
Dan Stozaec460082018-12-17 15:35:09 -08001614status_t SurfaceFlinger::addRegionSamplingListener(const Rect& samplingArea,
1615 const sp<IBinder>& stopLayerHandle,
1616 const sp<IRegionSamplingListener>& listener) {
Leon Scroggins IIIae16b802022-01-12 11:42:05 -05001617 if (!listener || samplingArea == Rect::INVALID_RECT || samplingArea.isEmpty()) {
Dan Stozaec460082018-12-17 15:35:09 -08001618 return BAD_VALUE;
1619 }
Alec Mouri9a02eda2020-04-21 17:39:34 -07001620
1621 const wp<Layer> stopLayer = fromHandle(stopLayerHandle);
1622 mRegionSamplingThread->addListener(samplingArea, stopLayer, listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001623 return NO_ERROR;
1624}
1625
Dan Stozaec460082018-12-17 15:35:09 -08001626status_t SurfaceFlinger::removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) {
tangrobinaf45f012019-02-26 18:10:10 +08001627 if (!listener) {
1628 return BAD_VALUE;
1629 }
Dan Stozaec460082018-12-17 15:35:09 -08001630 mRegionSamplingThread->removeListener(listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001631 return NO_ERROR;
1632}
Dan Gittik57e63c52019-01-18 16:37:54 +00001633
Alec Mouria9a68a62021-03-04 19:14:50 -08001634status_t SurfaceFlinger::addFpsListener(int32_t taskId, const sp<gui::IFpsListener>& listener) {
Alec Mouriadebf5c2021-01-05 12:57:36 -08001635 if (!listener) {
1636 return BAD_VALUE;
1637 }
1638
Alec Mouria9a68a62021-03-04 19:14:50 -08001639 mFpsReporter->addListener(listener, taskId);
Alec Mouriadebf5c2021-01-05 12:57:36 -08001640 return NO_ERROR;
1641}
1642
1643status_t SurfaceFlinger::removeFpsListener(const sp<gui::IFpsListener>& listener) {
1644 if (!listener) {
1645 return BAD_VALUE;
1646 }
1647 mFpsReporter->removeListener(listener);
1648 return NO_ERROR;
1649}
1650
Galia Peycheva8f04b302021-04-27 13:25:38 +02001651status_t SurfaceFlinger::addTunnelModeEnabledListener(
1652 const sp<gui::ITunnelModeEnabledListener>& listener) {
1653 if (!listener) {
1654 return BAD_VALUE;
1655 }
1656
1657 mTunnelModeEnabledReporter->addListener(listener);
1658 return NO_ERROR;
1659}
1660
1661status_t SurfaceFlinger::removeTunnelModeEnabledListener(
1662 const sp<gui::ITunnelModeEnabledListener>& listener) {
1663 if (!listener) {
1664 return BAD_VALUE;
1665 }
1666
1667 mTunnelModeEnabledReporter->removeListener(listener);
1668 return NO_ERROR;
1669}
1670
Dan Gittik57e63c52019-01-18 16:37:54 +00001671status_t SurfaceFlinger::getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
1672 bool* outSupport) const {
1673 if (!displayToken || !outSupport) {
1674 return BAD_VALUE;
1675 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001676
1677 Mutex::Autolock lock(mStateLock);
1678
Dan Gittik57e63c52019-01-18 16:37:54 +00001679 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1680 if (!displayId) {
1681 return NAME_NOT_FOUND;
1682 }
Leon Scroggins III5967aec2021-12-29 11:14:22 -05001683 *outSupport = getHwComposer().hasDisplayCapability(*displayId, DisplayCapability::BRIGHTNESS);
Dan Gittik57e63c52019-01-18 16:37:54 +00001684 return NO_ERROR;
1685}
1686
Alec Mouricdf16792021-12-10 13:16:06 -08001687bool SurfaceFlinger::hasVisibleHdrLayer(const sp<DisplayDevice>& display) {
1688 bool hasHdrLayers = false;
1689 mDrawingState.traverse([&,
1690 compositionDisplay = display->getCompositionDisplay()](Layer* layer) {
1691 hasHdrLayers |= (layer->isVisible() &&
1692 compositionDisplay->includesLayer(layer->getCompositionEngineLayerFE()) &&
1693 isHdrDataspace(layer->getDataSpace()));
1694 });
1695 return hasHdrLayers;
1696}
1697
John Reck22be6962021-03-10 12:59:54 -05001698status_t SurfaceFlinger::setDisplayBrightness(const sp<IBinder>& displayToken,
1699 const gui::DisplayBrightness& brightness) {
Dan Gittik57e63c52019-01-18 16:37:54 +00001700 if (!displayToken) {
1701 return BAD_VALUE;
1702 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001703
Dominik Laskowski756b7892021-08-04 12:53:59 -07001704 const char* const whence = __func__;
Dominik Laskowskib17c6212022-05-09 09:36:19 -07001705 return ftl::Future(mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) {
John Reckac09e452021-04-07 16:35:37 -04001706 if (const auto display = getDisplayDeviceLocked(displayToken)) {
Alec Mouricdf16792021-12-10 13:16:06 -08001707 const bool supportsDisplayBrightnessCommand =
1708 getHwComposer().getComposer()->isSupported(
1709 Hwc2::Composer::OptionalFeature::DisplayBrightnessCommand);
1710 // If we support applying display brightness as a command, then we also support
1711 // dimming SDR layers.
Alec Mouri90a19272021-12-30 14:11:38 -08001712 if (supportsDisplayBrightnessCommand) {
Alec Mouri6da0e272022-02-07 12:45:57 -08001713 auto compositionDisplay = display->getCompositionDisplay();
1714 float currentDimmingRatio =
1715 compositionDisplay->editState().sdrWhitePointNits /
1716 compositionDisplay->editState().displayBrightnessNits;
1717 compositionDisplay->setDisplayBrightness(brightness.sdrWhitePointNits,
1718 brightness.displayBrightnessNits);
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001719 FTL_FAKE_GUARD(kMainThreadContext,
1720 display->stageBrightness(brightness.displayBrightness));
1721
Alec Mouri6da0e272022-02-07 12:45:57 -08001722 if (brightness.sdrWhitePointNits / brightness.displayBrightnessNits !=
1723 currentDimmingRatio) {
Alec Mouricdf16792021-12-10 13:16:06 -08001724 scheduleComposite(FrameHint::kNone);
1725 } else {
1726 scheduleCommit(FrameHint::kNone);
1727 }
1728 return ftl::yield<status_t>(OK);
1729 } else {
Alec Mouri90a19272021-12-30 14:11:38 -08001730 return getHwComposer()
1731 .setDisplayBrightness(display->getPhysicalId(),
1732 brightness.displayBrightness,
Alec Mouri4d8a05d2022-03-23 18:14:26 +00001733 brightness.displayBrightnessNits,
Alec Mouri90a19272021-12-30 14:11:38 -08001734 Hwc2::Composer::DisplayBrightnessOptions{
1735 .applyImmediately = true});
John Reckac09e452021-04-07 16:35:37 -04001736 }
Alec Mouricdf16792021-12-10 13:16:06 -08001737
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001738 } else {
Dominik Laskowski756b7892021-08-04 12:53:59 -07001739 ALOGE("%s: Invalid display token %p", whence, displayToken.get());
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -08001740 return ftl::yield<status_t>(NAME_NOT_FOUND);
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001741 }
Dominik Laskowski5690bde2020-04-23 19:04:22 -07001742 }))
Dominik Laskowskib17c6212022-05-09 09:36:19 -07001743 .then([](ftl::Future<status_t> task) { return task; })
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001744 .get();
Dan Gittik57e63c52019-01-18 16:37:54 +00001745}
1746
John Reck88270902021-03-18 11:27:35 -04001747status_t SurfaceFlinger::addHdrLayerInfoListener(const sp<IBinder>& displayToken,
1748 const sp<gui::IHdrLayerInfoListener>& listener) {
1749 if (!displayToken) {
1750 return BAD_VALUE;
1751 }
1752
1753 Mutex::Autolock lock(mStateLock);
1754
1755 const auto display = getDisplayDeviceLocked(displayToken);
1756 if (!display) {
1757 return NAME_NOT_FOUND;
1758 }
1759 const auto displayId = display->getId();
1760 sp<HdrLayerInfoReporter>& hdrInfoReporter = mHdrLayerInfoListeners[displayId];
1761 if (!hdrInfoReporter) {
1762 hdrInfoReporter = sp<HdrLayerInfoReporter>::make();
1763 }
1764 hdrInfoReporter->addListener(listener);
Robert Carr167bdde2021-07-28 11:26:51 -07001765
1766
1767 mAddingHDRLayerInfoListener = true;
John Reck88270902021-03-18 11:27:35 -04001768 return OK;
1769}
1770
1771status_t SurfaceFlinger::removeHdrLayerInfoListener(
1772 const sp<IBinder>& displayToken, const sp<gui::IHdrLayerInfoListener>& listener) {
1773 if (!displayToken) {
1774 return BAD_VALUE;
1775 }
1776
1777 Mutex::Autolock lock(mStateLock);
1778
1779 const auto display = getDisplayDeviceLocked(displayToken);
1780 if (!display) {
1781 return NAME_NOT_FOUND;
1782 }
1783 const auto displayId = display->getId();
1784 sp<HdrLayerInfoReporter>& hdrInfoReporter = mHdrLayerInfoListeners[displayId];
1785 if (hdrInfoReporter) {
1786 hdrInfoReporter->removeListener(listener);
1787 }
1788 return OK;
1789}
1790
Lais Andrade3a6e47d2020-04-02 11:20:16 +01001791status_t SurfaceFlinger::notifyPowerBoost(int32_t boostId) {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001792 using hardware::power::Boost;
Lais Andrade3a6e47d2020-04-02 11:20:16 +01001793 Boost powerBoost = static_cast<Boost>(boostId);
Ady Abraham8532d012019-05-08 14:50:56 -07001794
Lais Andrade3a6e47d2020-04-02 11:20:16 +01001795 if (powerBoost == Boost::INTERACTION) {
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001796 mScheduler->onTouchHint();
Ady Abraham8532d012019-05-08 14:50:56 -07001797 }
1798
1799 return NO_ERROR;
1800}
1801
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -05001802status_t SurfaceFlinger::getDisplayDecorationSupport(
1803 const sp<IBinder>& displayToken,
1804 std::optional<DisplayDecorationSupport>* outSupport) const {
Leon Scroggins IIIe5cff632021-12-29 11:53:36 -05001805 if (!displayToken || !outSupport) {
1806 return BAD_VALUE;
1807 }
1808
1809 Mutex::Autolock lock(mStateLock);
1810
1811 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1812 if (!displayId) {
1813 return NAME_NOT_FOUND;
1814 }
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -05001815 getHwComposer().getDisplayDecorationSupport(*displayId, outSupport);
Leon Scroggins IIIe5cff632021-12-29 11:53:36 -05001816 return NO_ERROR;
1817}
1818
Mathias Agopiand0566bc2011-11-17 17:49:17 -08001819// ----------------------------------------------------------------------------
1820
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -07001821sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection(
Ady Abraham62f216c2020-10-13 19:07:23 -07001822 ISurfaceComposer::VsyncSource vsyncSource,
1823 ISurfaceComposer::EventRegistrationFlags eventRegistration) {
Ana Krulecc2870422019-01-29 19:00:58 -08001824 const auto& handle =
1825 vsyncSource == eVsyncSourceSurfaceFlinger ? mSfConnectionHandle : mAppConnectionHandle;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001826
Ady Abraham62f216c2020-10-13 19:07:23 -07001827 return mScheduler->createDisplayEventConnection(handle, eventRegistration);
Mathias Agopianbb641242010-05-18 17:06:55 -07001828}
1829
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07001830void SurfaceFlinger::scheduleCommit(FrameHint hint) {
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001831 if (hint == FrameHint::kActive) {
1832 mScheduler->resetIdleTimer();
1833 }
Xiang Wang839fe5b2022-04-04 17:39:38 +00001834 mPowerAdvisor->notifyDisplayUpdateImminent();
Dominik Laskowski46f3e3b2021-08-10 11:44:24 -07001835 mScheduler->scheduleFrame();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001836}
1837
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07001838void SurfaceFlinger::scheduleComposite(FrameHint hint) {
1839 mMustComposite = true;
1840 scheduleCommit(hint);
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001841}
1842
1843void SurfaceFlinger::scheduleRepaint() {
1844 mGeometryDirty = true;
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07001845 scheduleComposite(FrameHint::kActive);
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001846}
1847
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07001848void SurfaceFlinger::scheduleSample() {
Dominik Laskowski756b7892021-08-04 12:53:59 -07001849 static_cast<void>(mScheduler->schedule([this] { sample(); }));
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001850}
1851
Ady Abraham2492a022020-07-24 11:09:55 -07001852nsecs_t SurfaceFlinger::getVsyncPeriodFromHWC() const {
Marin Shalamanov045b7002021-01-07 16:56:24 +01001853 if (const auto display = getDefaultDisplayDeviceLocked()) {
1854 return display->getVsyncPeriodFromHWC();
Dominik Laskowski83b88212018-12-11 13:34:06 -08001855 }
1856
Marin Shalamanov045b7002021-01-07 16:56:24 +01001857 return 0;
Dominik Laskowski83b88212018-12-11 13:34:06 -08001858}
1859
Dominik Laskowski0deb06e2021-04-16 23:18:31 -07001860void SurfaceFlinger::onComposerHalVsync(hal::HWDisplayId hwcDisplayId, int64_t timestamp,
1861 std::optional<hal::VsyncPeriodNanos> vsyncPeriod) {
Ady Abraham248bce82021-09-16 14:29:59 -07001862 const std::string tracePeriod = [vsyncPeriod]() {
1863 if (ATRACE_ENABLED() && vsyncPeriod) {
1864 std::stringstream ss;
1865 ss << "(" << *vsyncPeriod << ")";
1866 return ss.str();
1867 }
1868 return std::string();
1869 }();
1870 ATRACE_FORMAT("onComposerHalVsync%s", tracePeriod.c_str());
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001871
Steven Thomas3cfac282017-02-06 12:29:30 -08001872 Mutex::Autolock lock(mStateLock);
Ady Abrahame1166472021-07-15 10:56:06 -07001873 const auto displayId = getHwComposer().toPhysicalDisplayId(hwcDisplayId);
1874 if (displayId) {
1875 const auto token = getPhysicalDisplayTokenLocked(*displayId);
1876 const auto display = getDisplayDeviceLocked(token);
Marin Shalamanov045b7002021-01-07 16:56:24 +01001877 display->onVsync(timestamp);
1878 }
1879
Dominik Laskowski075d3172018-05-24 15:50:06 -07001880 if (!getHwComposer().onVsync(hwcDisplayId, timestamp)) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001881 return;
1882 }
1883
Ady Abrahame1166472021-07-15 10:56:06 -07001884 const bool isActiveDisplay =
1885 displayId && getPhysicalDisplayTokenLocked(*displayId) == mActiveDisplayToken;
1886 if (!isActiveDisplay) {
1887 // For now, we don't do anything with non active display vsyncs.
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001888 return;
1889 }
1890
Alec Mourif8e689c2019-05-20 18:32:22 -07001891 bool periodFlushed = false;
Ady Abraham5dee2f12020-02-05 17:49:47 -08001892 mScheduler->addResyncSample(timestamp, vsyncPeriod, &periodFlushed);
Alec Mourif8e689c2019-05-20 18:32:22 -07001893 if (periodFlushed) {
Dominik Laskowski08d05c22020-07-22 00:05:08 -07001894 modulateVsync(&VsyncModulator::onRefreshRateChangeCompleted);
Alec Mouri754c98a2019-03-18 18:53:42 -07001895 }
Mathias Agopian148994e2012-09-19 17:31:36 -07001896}
1897
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001898void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
David Sodman99974d22017-11-28 12:04:33 -08001899 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
1900 *compositorTiming = getBE().mCompositorTiming;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001901}
1902
Dominik Laskowski0deb06e2021-04-16 23:18:31 -07001903void SurfaceFlinger::onComposerHalHotplug(hal::HWDisplayId hwcDisplayId,
1904 hal::Connection connection) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001905 const bool connected = connection == hal::Connection::CONNECTED;
1906 ALOGI("%s HAL display %" PRIu64, connected ? "Connecting" : "Disconnecting", hwcDisplayId);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001907
Steven Thomasb02664d2017-07-26 18:48:28 -07001908 // Only lock if we're not on the main thread. This function is normally
1909 // called on a hwbinder thread, but for the primary display it's called on
1910 // the main thread with the state lock already held, so don't attempt to
1911 // acquire it here.
Lloyd Piqueba04e622017-12-14 17:11:26 -08001912 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
Steven Thomasb02664d2017-07-26 18:48:28 -07001913
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001914 mPendingHotplugEvents.emplace_back(HotplugEvent{hwcDisplayId, connection});
Mathias Agopian9e2463e2012-09-21 18:26:16 -07001915
Jiwen 'Steve' Caiccfd6822018-02-21 16:15:58 -08001916 if (std::this_thread::get_id() == mMainThreadId) {
1917 // Process all pending hot plug events immediately if we are on the main thread.
1918 processDisplayHotplugEventsLocked();
1919 }
1920
Lloyd Piqueba04e622017-12-14 17:11:26 -08001921 setTransactionFlags(eDisplayTransactionNeeded);
Mathias Agopian86303202012-07-24 22:46:10 -07001922}
1923
Dominik Laskowski0deb06e2021-04-16 23:18:31 -07001924void SurfaceFlinger::onComposerHalVsyncPeriodTimingChanged(
1925 hal::HWDisplayId, const hal::VsyncPeriodChangeTimeline& timeline) {
Ady Abraham3a77a7b2019-12-02 18:46:59 -08001926 Mutex::Autolock lock(mStateLock);
Dominik Laskowski0deb06e2021-04-16 23:18:31 -07001927 mScheduler->onNewVsyncPeriodChangeTimeline(timeline);
Dominik Laskowskidd5827a2022-03-17 12:44:23 -07001928
1929 if (timeline.refreshRequired) {
1930 scheduleComposite(FrameHint::kNone);
1931 }
Ady Abraham7159f572019-10-11 11:10:18 -07001932}
1933
Dominik Laskowski0deb06e2021-04-16 23:18:31 -07001934void SurfaceFlinger::onComposerHalSeamlessPossible(hal::HWDisplayId) {
Marin Shalamanov3ea1d602020-12-16 19:59:39 +01001935 // TODO(b/142753666): use constraints when calling to setActiveModeWithConstraints and
Ady Abrahamb0433bc2020-01-08 17:31:06 -08001936 // use this callback to know when to retry in case of SEAMLESS_NOT_POSSIBLE.
1937}
1938
Dominik Laskowski0deb06e2021-04-16 23:18:31 -07001939void SurfaceFlinger::onComposerHalRefresh(hal::HWDisplayId) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001940 Mutex::Autolock lock(mStateLock);
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07001941 scheduleComposite(FrameHint::kNone);
Steven Thomas3cfac282017-02-06 12:29:30 -08001942}
1943
Yichi Chen3401b562022-01-17 15:42:35 +08001944void SurfaceFlinger::onComposerHalVsyncIdle(hal::HWDisplayId) {
Ady Abrahame9befd72022-02-24 17:24:44 -08001945 ATRACE_CALL();
1946 mScheduler->forceNextResync();
Yichi Chen3401b562022-01-17 15:42:35 +08001947}
1948
Dominik Laskowski8b01cc02020-07-14 19:02:41 -07001949void SurfaceFlinger::setVsyncEnabled(bool enabled) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001950 ATRACE_CALL();
Ady Abraham9ba25122019-06-03 17:10:55 -07001951
Dominik Laskowski8b01cc02020-07-14 19:02:41 -07001952 // On main thread to avoid race conditions with display power state.
Dominik Laskowski298b08e2022-02-15 13:45:02 -08001953 static_cast<void>(mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) {
Dominik Laskowski8b01cc02020-07-14 19:02:41 -07001954 mHWCVsyncPendingState = enabled ? hal::Vsync::ENABLE : hal::Vsync::DISABLE;
Ady Abraham9ba25122019-06-03 17:10:55 -07001955
Dominik Laskowski8b01cc02020-07-14 19:02:41 -07001956 if (const auto display = getDefaultDisplayDeviceLocked();
1957 display && display->isPoweredOn()) {
Ady Abraham4f960d12021-10-13 16:59:49 -07001958 setHWCVsyncEnabled(display->getPhysicalId(), mHWCVsyncPendingState);
Ady Abraham9ba25122019-06-03 17:10:55 -07001959 }
Dominik Laskowski8b01cc02020-07-14 19:02:41 -07001960 }));
Mathias Agopian86303202012-07-24 22:46:10 -07001961}
1962
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07001963SurfaceFlinger::FenceWithFenceTime SurfaceFlinger::previousFrameFence() {
Ady Abrahamccf4b472021-05-11 19:53:01 -07001964 const auto now = systemTime();
1965 const auto vsyncPeriod = mScheduler->getDisplayStatInfo(now).vsyncPeriod;
1966 const bool expectedPresentTimeIsTheNextVsync = mExpectedPresentTime - now <= vsyncPeriod;
Jen-Chih Chang1febfb82022-08-03 11:31:30 +08001967
1968 size_t shift = 0;
1969 if (!expectedPresentTimeIsTheNextVsync) {
1970 shift = static_cast<size_t>((mExpectedPresentTime - now) / vsyncPeriod);
1971 if (shift >= mPreviousPresentFences.size()) {
1972 shift = mPreviousPresentFences.size() - 1;
1973 }
1974 }
1975 ATRACE_FORMAT("previousFrameFence shift=%zu", shift);
1976 return mPreviousPresentFences[shift];
Alec Mouri6d414b52020-03-17 11:18:05 -07001977}
1978
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001979bool SurfaceFlinger::previousFramePending(int graceTimeMs) {
Alec Mouri6d414b52020-03-17 11:18:05 -07001980 ATRACE_CALL();
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07001981 const std::shared_ptr<FenceTime>& fence = previousFrameFence().fenceTime;
Ady Abrahambe0f9482019-04-24 15:41:53 -07001982
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07001983 if (fence == FenceTime::NO_FENCE) {
Ady Abraham11579302019-09-19 12:35:58 -07001984 return false;
1985 }
1986
Dan Stoza59083052020-04-28 10:13:20 -07001987 const status_t status = fence->wait(graceTimeMs);
1988 // This is the same as Fence::Status::Unsignaled, but it saves a getStatus() call,
1989 // which calls wait(0) again internally
1990 return status == -ETIME;
Ady Abrahambe0f9482019-04-24 15:41:53 -07001991}
1992
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001993nsecs_t SurfaceFlinger::previousFramePresentTime() {
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07001994 const std::shared_ptr<FenceTime>& fence = previousFrameFence().fenceTime;
Alec Mouri6d414b52020-03-17 11:18:05 -07001995
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07001996 if (fence == FenceTime::NO_FENCE) {
Alec Mouri6d414b52020-03-17 11:18:05 -07001997 return Fence::SIGNAL_TIME_INVALID;
1998 }
1999
2000 return fence->getSignalTime();
2001}
2002
Ady Abraham56b42a42020-12-28 16:48:48 -08002003nsecs_t SurfaceFlinger::calculateExpectedPresentTime(DisplayStatInfo stats) const {
Alec Mouriaa614192019-06-06 13:28:34 -07002004 // Inflate the expected present time if we're targetting the next vsync.
Ady Abraham8cb21882020-08-26 18:22:05 -07002005 return mVsyncModulator->getVsyncConfig().sfOffset > 0 ? stats.vsyncTime
2006 : stats.vsyncTime + stats.vsyncPeriod;
Alec Mouriaa614192019-06-06 13:28:34 -07002007}
2008
Dominik Laskowski298b08e2022-02-15 13:45:02 -08002009bool SurfaceFlinger::commit(nsecs_t frameTime, int64_t vsyncId, nsecs_t expectedVsyncTime)
2010 FTL_FAKE_GUARD(kMainThreadContext) {
Dan Stoza28d46a52020-04-28 09:54:54 -07002011 // calculate the expected present time once and use the cached
2012 // value throughout this frame to make sure all layers are
2013 // seeing this same value.
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002014 if (expectedVsyncTime >= frameTime) {
2015 mExpectedPresentTime = expectedVsyncTime;
Snild Dolkow819636c2021-01-22 14:42:08 +01002016 } else {
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002017 const DisplayStatInfo stats = mScheduler->getDisplayStatInfo(frameTime);
Snild Dolkow819636c2021-01-22 14:42:08 +01002018 mExpectedPresentTime = calculateExpectedPresentTime(stats);
2019 }
2020
2021 const nsecs_t lastScheduledPresentTime = mScheduledPresentTime;
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002022 mScheduledPresentTime = expectedVsyncTime;
Dan Stoza28d46a52020-04-28 09:54:54 -07002023
Ady Abraham893c99d2021-04-30 16:00:23 -07002024 const auto vsyncIn = [&] {
2025 if (!ATRACE_ENABLED()) return 0.f;
2026 return (mExpectedPresentTime - systemTime()) / 1e6f;
2027 }();
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002028 ATRACE_FORMAT("%s %" PRId64 " vsyncIn %.2fms%s", __func__, vsyncId, vsyncIn,
2029 mExpectedPresentTime == expectedVsyncTime ? "" : " (adjusted)");
Ady Abraham893c99d2021-04-30 16:00:23 -07002030
Dan Stoza28d46a52020-04-28 09:54:54 -07002031 // When Backpressure propagation is enabled we want to give a small grace period
2032 // for the present fence to fire instead of just giving up on this frame to handle cases
2033 // where present fence is just about to get signaled.
2034 const int graceTimeForPresentFenceMs =
John Reck2ec53912020-07-07 16:53:55 -07002035 (mPropagateBackpressureClientComposition || !mHadClientComposition) ? 1 : 0;
Dan Stoza28d46a52020-04-28 09:54:54 -07002036
2037 // Pending frames may trigger backpressure propagation.
2038 const TracedOrdinal<bool> framePending = {"PrevFramePending",
2039 previousFramePending(graceTimeForPresentFenceMs)};
2040
2041 // Frame missed counts for metrics tracking.
2042 // A frame is missed if the prior frame is still pending. If no longer pending,
2043 // then we still count the frame as missed if the predicted present time
2044 // was further in the past than when the fence actually fired.
2045
2046 // Add some slop to correct for drift. This should generally be
2047 // smaller than a typical frame duration, but should not be so small
2048 // that it reports reasonable drift as a missed frame.
Ady Abrahame90dd522020-12-29 12:08:45 -08002049 const DisplayStatInfo stats = mScheduler->getDisplayStatInfo(systemTime());
Dan Stoza28d46a52020-04-28 09:54:54 -07002050 const nsecs_t frameMissedSlop = stats.vsyncPeriod / 2;
2051 const nsecs_t previousPresentTime = previousFramePresentTime();
2052 const TracedOrdinal<bool> frameMissed = {"PrevFrameMissed",
2053 framePending ||
2054 (previousPresentTime >= 0 &&
Snild Dolkow819636c2021-01-22 14:42:08 +01002055 (lastScheduledPresentTime <
Dan Stoza28d46a52020-04-28 09:54:54 -07002056 previousPresentTime - frameMissedSlop))};
2057 const TracedOrdinal<bool> hwcFrameMissed = {"PrevHwcFrameMissed",
2058 mHadDeviceComposition && frameMissed};
2059 const TracedOrdinal<bool> gpuFrameMissed = {"PrevGpuFrameMissed",
2060 mHadClientComposition && frameMissed};
2061
2062 if (frameMissed) {
2063 mFrameMissedCount++;
2064 mTimeStats->incrementMissedFrames();
Dan Stoza28d46a52020-04-28 09:54:54 -07002065 }
2066
2067 if (hwcFrameMissed) {
2068 mHwcFrameMissedCount++;
2069 }
2070
2071 if (gpuFrameMissed) {
2072 mGpuFrameMissedCount++;
2073 }
2074
Marin Shalamanova7fe3042021-01-29 21:02:08 +01002075 // If we are in the middle of a mode change and the fence hasn't
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002076 // fired yet just wait for the next commit.
Marin Shalamanova7fe3042021-01-29 21:02:08 +01002077 if (mSetActiveModePending) {
Dan Stoza28d46a52020-04-28 09:54:54 -07002078 if (framePending) {
Dominik Laskowski46f3e3b2021-08-10 11:44:24 -07002079 mScheduler->scheduleFrame();
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002080 return false;
Dan Stoza28d46a52020-04-28 09:54:54 -07002081 }
2082
2083 // We received the present fence from the HWC, so we assume it successfully updated
Marin Shalamanova7fe3042021-01-29 21:02:08 +01002084 // the mode, hence we update SF.
2085 mSetActiveModePending = false;
yuhui.zhang087d3742021-12-11 15:23:52 +08002086 {
2087 Mutex::Autolock lock(mStateLock);
2088 updateInternalStateWithChangedMode();
2089 }
Dan Stoza28d46a52020-04-28 09:54:54 -07002090 }
2091
John Reck2ec53912020-07-07 16:53:55 -07002092 if (framePending) {
Dan Stoza28d46a52020-04-28 09:54:54 -07002093 if ((hwcFrameMissed && !gpuFrameMissed) || mPropagateBackpressureClientComposition) {
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002094 scheduleCommit(FrameHint::kNone);
2095 return false;
Dan Stoza28d46a52020-04-28 09:54:54 -07002096 }
2097 }
2098
Matt Buckley50c44062022-01-17 20:48:10 +00002099 // Save this once per commit + composite to ensure consistency
Matt Buckley5b59d942022-08-02 20:10:15 +00002100 // TODO (b/240619471): consider removing active display check once AOD is fixed
2101 const auto activeDisplay =
2102 FTL_FAKE_GUARD(mStateLock, getDisplayDeviceLocked(mActiveDisplayToken));
2103 mPowerHintSessionEnabled = mPowerAdvisor->usePowerHintSession() && activeDisplay &&
2104 activeDisplay->getPowerMode() == hal::PowerMode::ON;
Matt Buckley50c44062022-01-17 20:48:10 +00002105 if (mPowerHintSessionEnabled) {
Matt Buckley672e5262022-07-29 00:13:27 +00002106 const auto& display = FTL_FAKE_GUARD(mStateLock, getDefaultDisplayDeviceLocked()).get();
2107 // get stable vsync period from display mode
2108 const nsecs_t vsyncPeriod = display->getActiveMode()->getVsyncPeriod();
Matt Buckley50c44062022-01-17 20:48:10 +00002109 mPowerAdvisor->setCommitStart(frameTime);
2110 mPowerAdvisor->setExpectedPresentTime(mExpectedPresentTime);
2111 const nsecs_t idealSfWorkDuration =
2112 mVsyncModulator->getVsyncConfig().sfWorkDuration.count();
2113 // Frame delay is how long we should have minus how long we actually have
2114 mPowerAdvisor->setFrameDelay(idealSfWorkDuration - (mExpectedPresentTime - frameTime));
2115 mPowerAdvisor->setTotalFrameTargetWorkDuration(idealSfWorkDuration);
2116 mPowerAdvisor->setTargetWorkDuration(vsyncPeriod);
2117
2118 // Send early hint here to make sure there's not another frame pending
2119 if (mPowerHintSessionMode.early) {
2120 // Send a rough prediction for this frame based on last frame's timing info
2121 mPowerAdvisor->sendPredictedWorkDuration();
2122 }
2123 }
2124
Dan Stoza28d46a52020-04-28 09:54:54 -07002125 if (mTracingEnabledChanged) {
Vishnu Nair7891e962021-11-11 12:07:21 -08002126 mLayerTracingEnabled = mLayerTracing.isEnabled();
Dan Stoza28d46a52020-04-28 09:54:54 -07002127 mTracingEnabledChanged = false;
2128 }
2129
Ady Abraham29d0da32020-07-16 18:39:33 -07002130 if (mRefreshRateOverlaySpinner) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07002131 Mutex::Autolock lock(mStateLock);
2132 if (const auto display = getDefaultDisplayDeviceLocked()) {
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002133 display->animateRefreshRateOverlay();
Ady Abraham29d0da32020-07-16 18:39:33 -07002134 }
2135 }
2136
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002137 // Composite if transactions were committed, or if requested by HWC.
2138 bool mustComposite = mMustComposite.exchange(false);
Dan Stoza28d46a52020-04-28 09:54:54 -07002139 {
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002140 mFrameTimeline->setSfWakeUp(vsyncId, frameTime, Fps::fromPeriodNsecs(stats.vsyncPeriod));
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -07002141
chaviw6b9ffea2021-11-08 09:25:48 -06002142 bool needsTraversal = false;
2143 if (clearTransactionFlags(eTransactionFlushNeeded)) {
Vishnu Nair0fc7af52022-01-13 08:11:34 -08002144 needsTraversal |= commitCreatedLayers();
2145 needsTraversal |= flushTransactionQueues(vsyncId);
chaviw6b9ffea2021-11-08 09:25:48 -06002146 }
2147
2148 const bool shouldCommit =
2149 (getTransactionFlags() & ~eTransactionFlushNeeded) || needsTraversal;
2150 if (shouldCommit) {
2151 commitTransactions();
2152 }
2153
2154 if (transactionFlushNeeded()) {
2155 setTransactionFlags(eTransactionFlushNeeded);
2156 }
2157
2158 mustComposite |= shouldCommit;
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002159 mustComposite |= latchBuffers();
2160
chaviw6b9ffea2021-11-08 09:25:48 -06002161 // This has to be called after latchBuffers because we want to include the layers that have
2162 // been latched in the commit callback
2163 if (!needsTraversal) {
2164 // Invoke empty transaction callbacks early.
2165 mTransactionCallbackInvoker.sendCallbacks(false /* onCommitOnly */);
2166 } else {
2167 // Invoke OnCommit callbacks.
2168 mTransactionCallbackInvoker.sendCallbacks(true /* onCommitOnly */);
2169 }
2170
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002171 updateLayerGeometry();
Dan Stoza28d46a52020-04-28 09:54:54 -07002172 }
2173
2174 // Layers need to get updated (in the previous line) before we can use them for
2175 // choosing the refresh rate.
2176 // Hold mStateLock as chooseRefreshRateForContent promotes wp<Layer> to sp<Layer>
2177 // and may eventually call to ~Layer() if it holds the last reference
2178 {
2179 Mutex::Autolock _l(mStateLock);
2180 mScheduler->chooseRefreshRateForContent();
yuhui.zhang087d3742021-12-11 15:23:52 +08002181 setActiveModeInHwcIfNeeded();
Dan Stoza28d46a52020-04-28 09:54:54 -07002182 }
2183
Dan Stoza28d46a52020-04-28 09:54:54 -07002184 updateCursorAsync();
2185 updateInputFlinger();
2186
Vishnu Nairb64a3b42022-01-13 15:29:32 -08002187 if (mLayerTracingEnabled && !mLayerTracing.flagIsSet(LayerTracing::TRACE_COMPOSITION)) {
2188 // This will block and tracing should only be enabled for debugging.
2189 mLayerTracing.notify(mVisibleRegionsDirty, frameTime);
2190 }
2191
Dominik Laskowski298b08e2022-02-15 13:45:02 -08002192 persistDisplayBrightness(mustComposite);
Alec Mouricdf16792021-12-10 13:16:06 -08002193
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002194 return mustComposite && CC_LIKELY(mBootStage != BootStage::BOOTLOADER);
Dan Stoza28d46a52020-04-28 09:54:54 -07002195}
2196
Dominik Laskowski298b08e2022-02-15 13:45:02 -08002197void SurfaceFlinger::composite(nsecs_t frameTime, int64_t vsyncId)
2198 FTL_FAKE_GUARD(kMainThreadContext) {
Ady Abraham302ebed2022-03-07 16:03:41 -08002199 ATRACE_FORMAT("%s %" PRId64, __func__, vsyncId);
Dominik Laskowski298b08e2022-02-15 13:45:02 -08002200
Lloyd Piqueab039b52019-02-13 14:22:42 -08002201 compositionengine::CompositionRefreshArgs refreshArgs;
Dominik Laskowski298b08e2022-02-15 13:45:02 -08002202 const auto& displays = FTL_FAKE_GUARD(mStateLock, mDisplays);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002203 refreshArgs.outputs.reserve(displays.size());
Matt Buckley50c44062022-01-17 20:48:10 +00002204 std::vector<DisplayId> displayIds;
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002205 for (const auto& [_, display] : displays) {
Lloyd Piqueab039b52019-02-13 14:22:42 -08002206 refreshArgs.outputs.push_back(display->getCompositionDisplay());
Matt Buckley50c44062022-01-17 20:48:10 +00002207 displayIds.push_back(display->getId());
Lloyd Piqueab039b52019-02-13 14:22:42 -08002208 }
Matt Buckley50c44062022-01-17 20:48:10 +00002209 mPowerAdvisor->setDisplays(displayIds);
Lloyd Piqueab039b52019-02-13 14:22:42 -08002210 mDrawingState.traverseInZOrder([&refreshArgs](Layer* layer) {
Lloyd Piquede196652020-01-22 17:29:58 -08002211 if (auto layerFE = layer->getCompositionEngineLayerFE())
2212 refreshArgs.layers.push_back(layerFE);
Lloyd Piqueab039b52019-02-13 14:22:42 -08002213 });
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002214 refreshArgs.layersWithQueuedFrames.reserve(mLayersWithQueuedFrames.size());
Alec Mouri5c9c9602020-09-01 15:10:40 -07002215 for (auto layer : mLayersWithQueuedFrames) {
Lloyd Piquede196652020-01-22 17:29:58 -08002216 if (auto layerFE = layer->getCompositionEngineLayerFE())
2217 refreshArgs.layersWithQueuedFrames.push_back(layerFE);
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002218 }
2219
Lloyd Pique6a3b4462019-03-07 20:58:12 -08002220 refreshArgs.outputColorSetting = useColorManagement
2221 ? mDisplayColorSetting
2222 : compositionengine::OutputColorSetting::kUnmanaged;
2223 refreshArgs.colorSpaceAgnosticDataspace = mColorSpaceAgnosticDataspace;
2224 refreshArgs.forceOutputColorMode = mForceColorMode;
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002225
2226 refreshArgs.updatingOutputGeometryThisFrame = mVisibleRegionsDirty;
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07002227 refreshArgs.updatingGeometryThisFrame = mGeometryDirty.exchange(false) || mVisibleRegionsDirty;
Lucas Dupin2dd6f392020-02-18 17:43:36 -08002228 refreshArgs.blursAreExpensive = mBlursAreExpensive;
Snild Dolkow9e217d62020-04-22 15:53:42 +02002229 refreshArgs.internalDisplayRotationFlags = DisplayDevice::getPrimaryDisplayRotationFlags();
Lloyd Pique3eb1b212019-03-07 21:15:40 -08002230
2231 if (CC_UNLIKELY(mDrawingState.colorMatrixChanged)) {
2232 refreshArgs.colorTransformMatrix = mDrawingState.colorMatrix;
2233 mDrawingState.colorMatrixChanged = false;
2234 }
2235
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07002236 refreshArgs.devOptForceClientComposition = mDebugDisableHWC;
Lloyd Pique3eb1b212019-03-07 21:15:40 -08002237
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07002238 if (mDebugFlashDelay != 0) {
2239 refreshArgs.devOptForceClientComposition = true;
2240 refreshArgs.devOptFlashDirtyRegionsDelay = std::chrono::milliseconds(mDebugFlashDelay);
Lloyd Piquef8cf14d2019-02-28 16:03:12 -08002241 }
Lloyd Piqueab039b52019-02-13 14:22:42 -08002242
Ady Abraham43065bd2021-12-10 17:22:15 -08002243 const auto expectedPresentTime = mExpectedPresentTime.load();
2244 const auto prevVsyncTime = mScheduler->getPreviousVsyncFrom(expectedPresentTime);
Ady Abrahamcaba2982021-06-16 16:45:04 -07002245 const auto hwcMinWorkDuration = mVsyncConfiguration->getCurrentConfigs().hwcMinWorkDuration;
2246 refreshArgs.earliestPresentTime = prevVsyncTime - hwcMinWorkDuration;
Ady Abrahamec7aa8a2021-06-28 12:37:09 -07002247 refreshArgs.previousPresentFence = mPreviousPresentFences[0].fenceTime;
Dominik Laskowski756b7892021-08-04 12:53:59 -07002248 refreshArgs.scheduledFrameTime = mScheduler->getScheduledFrameTime();
Ady Abraham43065bd2021-12-10 17:22:15 -08002249 refreshArgs.expectedPresentTime = expectedPresentTime;
Ady Abraham3645e642021-04-20 18:39:00 -07002250
Ady Abraham3a77a7b2019-12-02 18:46:59 -08002251 // Store the present time just before calling to the composition engine so we could notify
2252 // the scheduler.
2253 const auto presentTime = systemTime();
2254
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002255 mCompositionEngine->present(refreshArgs);
Matt Buckleyef51fba2021-10-12 19:30:12 +00002256
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002257 mTimeStats->recordFrameDuration(frameTime, systemTime());
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002258
Matt Buckley50c44062022-01-17 20:48:10 +00002259 // Send a power hint hint after presentation is finished
2260 if (mPowerHintSessionEnabled) {
Matt Buckley3e68cce2022-08-05 06:51:43 +00002261 mPowerAdvisor->setSfPresentTiming(mPreviousPresentFences[0].fenceTime->getSignalTime(),
2262 systemTime());
Matt Buckley50c44062022-01-17 20:48:10 +00002263 if (mPowerHintSessionMode.late) {
2264 mPowerAdvisor->sendActualWorkDuration();
2265 }
2266 }
2267
Dominik Laskowskidd5827a2022-03-17 12:44:23 -07002268 if (mScheduler->onPostComposition(presentTime)) {
2269 scheduleComposite(FrameHint::kNone);
2270 }
Ady Abraham3a77a7b2019-12-02 18:46:59 -08002271
Jorim Jaggi9c03b502020-11-24 23:51:31 +01002272 postFrame();
2273 postComposition();
2274
Midas Chien50f52e22020-09-26 17:57:42 +08002275 const bool prevFrameHadClientComposition = mHadClientComposition;
Alec Mouri8f7a0102020-04-15 12:11:10 -07002276
Vishnu Nair9cf89262022-02-26 09:17:49 -08002277 mHadClientComposition = mHadDeviceComposition = mReusedClientComposition = false;
2278 TimeStats::ClientCompositionRecord clientCompositionRecord;
2279 for (const auto& [_, display] : displays) {
2280 const auto& state = display->getCompositionDisplay()->getState();
2281 mHadClientComposition |= state.usesClientComposition && !state.reusedClientComposition;
2282 mHadDeviceComposition |= state.usesDeviceComposition;
2283 mReusedClientComposition |= state.reusedClientComposition;
2284 clientCompositionRecord.predicted |=
2285 (state.strategyPrediction != CompositionStrategyPredictionState::DISABLED);
2286 clientCompositionRecord.predictionSucceeded |=
2287 (state.strategyPrediction == CompositionStrategyPredictionState::SUCCESS);
Alec Mouri8f7a0102020-04-15 12:11:10 -07002288 }
2289
Vishnu Nair9cf89262022-02-26 09:17:49 -08002290 clientCompositionRecord.hadClientComposition = mHadClientComposition;
2291 clientCompositionRecord.reused = mReusedClientComposition;
2292 clientCompositionRecord.changed = prevFrameHadClientComposition != mHadClientComposition;
2293 mTimeStats->pushCompositionStrategyState(clientCompositionRecord);
2294
Yichi Chen28dee2c2020-07-06 21:24:14 +08002295 // TODO: b/160583065 Enable skip validation when SF caches all client composition layers
Dominik Laskowski08d05c22020-07-22 00:05:08 -07002296 const bool usedGpuComposition = mHadClientComposition || mReusedClientComposition;
2297 modulateVsync(&VsyncModulator::onDisplayRefresh, usedGpuComposition);
Dan Stoza14cd37c2015-07-09 12:43:33 -07002298
David Sodman7e4ae112018-02-09 15:02:28 -08002299 mLayersWithQueuedFrames.clear();
Vishnu Nairb64a3b42022-01-13 15:29:32 -08002300 if (mLayerTracingEnabled && mLayerTracing.flagIsSet(LayerTracing::TRACE_COMPOSITION)) {
Vishnu Nair00b90132021-11-05 14:03:40 -07002301 // This will block and should only be used for debugging.
Vishnu Nairb64a3b42022-01-13 15:29:32 -08002302 mLayerTracing.notify(mVisibleRegionsDirty, frameTime);
Vishnu Nairdf529052019-06-07 14:53:14 -07002303 }
Robert Carr167bdde2021-07-28 11:26:51 -07002304
2305 mVisibleRegionsWereDirtyThisFrame = mVisibleRegionsDirty; // Cache value for use in post-comp
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07002306 mVisibleRegionsDirty = false;
Lloyd Piqueab039b52019-02-13 14:22:42 -08002307
2308 if (mCompositionEngine->needsAnotherUpdate()) {
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002309 scheduleCommit(FrameHint::kNone);
Lloyd Piqueab039b52019-02-13 14:22:42 -08002310 }
Matt Buckleyef51fba2021-10-12 19:30:12 +00002311
Matt Buckley50c44062022-01-17 20:48:10 +00002312 if (mPowerHintSessionEnabled) {
2313 mPowerAdvisor->setCompositeEnd(systemTime());
Matt Buckleyef51fba2021-10-12 19:30:12 +00002314 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07002315}
Mathias Agopian4fec8732012-06-29 14:12:52 -07002316
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07002317void SurfaceFlinger::updateLayerGeometry() {
David Sodmanfa9b2af2017-12-24 13:28:59 -08002318 ATRACE_CALL();
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07002319
Vishnu Nair4351ad52019-02-11 14:13:02 -08002320 if (mVisibleRegionsDirty) {
2321 computeLayerBounds();
2322 }
2323
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002324 for (auto& layer : mLayersPendingRefresh) {
2325 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002326 visibleReg.set(layer->getScreenBounds());
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002327 invalidateLayerStack(layer, visibleReg);
2328 }
2329 mLayersPendingRefresh.clear();
Mathias Agopian4fec8732012-06-29 14:12:52 -07002330}
2331
Ana Krulece588e312018-09-18 12:32:24 -07002332void SurfaceFlinger::updateCompositorTiming(const DisplayStatInfo& stats, nsecs_t compositeTime,
2333 std::shared_ptr<FenceTime>& presentFenceTime) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002334 // Update queue of past composite+present times and determine the
2335 // most recently known composite to present latency.
David Sodman99974d22017-11-28 12:04:33 -08002336 getBE().mCompositePresentTimes.push({compositeTime, presentFenceTime});
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002337 nsecs_t compositeToPresentLatency = -1;
David Sodman99974d22017-11-28 12:04:33 -08002338 while (!getBE().mCompositePresentTimes.empty()) {
2339 SurfaceFlingerBE::CompositePresentTime& cpt = getBE().mCompositePresentTimes.front();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002340 // Cached values should have been updated before calling this method,
2341 // which helps avoid duplicate syscalls.
2342 nsecs_t displayTime = cpt.display->getCachedSignalTime();
2343 if (displayTime == Fence::SIGNAL_TIME_PENDING) {
2344 break;
2345 }
2346 compositeToPresentLatency = displayTime - cpt.composite;
David Sodman99974d22017-11-28 12:04:33 -08002347 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002348 }
2349
2350 // Don't let mCompositePresentTimes grow unbounded, just in case.
David Sodman99974d22017-11-28 12:04:33 -08002351 while (getBE().mCompositePresentTimes.size() > 16) {
2352 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002353 }
2354
Ana Krulece588e312018-09-18 12:32:24 -07002355 setCompositorTimingSnapped(stats, compositeToPresentLatency);
Brian Andersond0010582017-03-07 13:20:31 -08002356}
2357
Ana Krulece588e312018-09-18 12:32:24 -07002358void SurfaceFlinger::setCompositorTimingSnapped(const DisplayStatInfo& stats,
2359 nsecs_t compositeToPresentLatency) {
Ady Abraham3b9e60a2022-02-17 21:43:53 +00002360 // Avoid division by 0 by defaulting to 60Hz
2361 const auto vsyncPeriod = stats.vsyncPeriod ?: (60_Hz).getPeriodNsecs();
2362
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002363 // Integer division and modulo round toward 0 not -inf, so we need to
2364 // treat negative and positive offsets differently.
Ady Abraham8287e852020-08-12 14:44:58 -07002365 nsecs_t idealLatency = (mVsyncConfiguration->getCurrentConfigs().late.sfOffset > 0)
Ady Abraham3b9e60a2022-02-17 21:43:53 +00002366 ? (vsyncPeriod -
2367 (mVsyncConfiguration->getCurrentConfigs().late.sfOffset % vsyncPeriod))
2368 : ((-mVsyncConfiguration->getCurrentConfigs().late.sfOffset) % vsyncPeriod);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002369
Ady Abraham8287e852020-08-12 14:44:58 -07002370 // Just in case mVsyncConfiguration->getCurrentConfigs().late.sf == -vsyncInterval.
Brian Andersond0010582017-03-07 13:20:31 -08002371 if (idealLatency <= 0) {
Ady Abraham3b9e60a2022-02-17 21:43:53 +00002372 idealLatency = vsyncPeriod;
Brian Andersond0010582017-03-07 13:20:31 -08002373 }
2374
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002375 // Snap the latency to a value that removes scheduling jitter from the
2376 // composition and present times, which often have >1ms of jitter.
2377 // Reducing jitter is important if an app attempts to extrapolate
2378 // something (such as user input) to an accurate diasplay time.
Ady Abraham9e16a482019-12-03 17:19:41 -08002379 // Snapping also allows an app to precisely calculate
Ady Abraham8287e852020-08-12 14:44:58 -07002380 // mVsyncConfiguration->getCurrentConfigs().late.sf with (presentLatency % interval).
Ady Abraham3b9e60a2022-02-17 21:43:53 +00002381 const nsecs_t bias = vsyncPeriod / 2;
2382 const int64_t extraVsyncs = ((compositeToPresentLatency - idealLatency + bias) / vsyncPeriod);
Ady Abraham8d7e7842022-02-03 01:42:45 +00002383 const nsecs_t snappedCompositeToPresentLatency =
Ady Abraham3b9e60a2022-02-17 21:43:53 +00002384 (extraVsyncs > 0) ? idealLatency + (extraVsyncs * vsyncPeriod) : idealLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002385
David Sodman99974d22017-11-28 12:04:33 -08002386 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
Ana Krulece588e312018-09-18 12:32:24 -07002387 getBE().mCompositorTiming.deadline = stats.vsyncTime - idealLatency;
Ady Abraham3b9e60a2022-02-17 21:43:53 +00002388 getBE().mCompositorTiming.interval = vsyncPeriod;
David Sodman99974d22017-11-28 12:04:33 -08002389 getBE().mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002390}
2391
John Reck49d9ad32022-02-23 19:03:31 -05002392bool SurfaceFlinger::isHdrLayer(Layer* layer) const {
Alec Mouri2c0ea352022-04-12 16:30:24 +00002393 // Treat all layers as non-HDR if:
2394 // 1. They do not have a valid HDR dataspace. Currently we treat those as PQ or HLG. and
2395 // 2. The layer is allowed to be dimmed. WindowManager may disable dimming in order to
2396 // keep animations invoking SDR screenshots of HDR layers seamless. Treat such tagged
2397 // layers as HDR so that DisplayManagerService does not try to change the screen brightness
2398 if (!isHdrDataspace(layer->getDataSpace()) && layer->isDimmingEnabled()) {
John Reck49d9ad32022-02-23 19:03:31 -05002399 return false;
2400 }
2401 if (mIgnoreHdrCameraLayers) {
2402 auto buffer = layer->getBuffer();
2403 if (buffer && (buffer->getUsage() & GRALLOC_USAGE_HW_CAMERA_WRITE) != 0) {
2404 return false;
2405 }
2406 }
2407 return true;
2408}
2409
ramindani06e518e2022-03-14 18:47:53 +00002410ui::Rotation SurfaceFlinger::getPhysicalDisplayOrientation(DisplayId displayId,
2411 bool isPrimary) const {
2412 const auto id = PhysicalDisplayId::tryCast(displayId);
2413 if (!id) {
2414 return ui::ROTATION_0;
2415 }
Neha Jain7b31cca2023-01-09 23:10:42 +00002416 if (!mIgnoreHwcPhysicalDisplayOrientation &&
2417 getHwComposer().getComposer()->isSupported(
ramindani06e518e2022-03-14 18:47:53 +00002418 Hwc2::Composer::OptionalFeature::PhysicalDisplayOrientation)) {
2419 switch (getHwComposer().getPhysicalDisplayOrientation(*id)) {
2420 case Hwc2::AidlTransform::ROT_90:
2421 return ui::ROTATION_90;
2422 case Hwc2::AidlTransform::ROT_180:
2423 return ui::ROTATION_180;
2424 case Hwc2::AidlTransform::ROT_270:
2425 return ui::ROTATION_270;
2426 default:
2427 return ui::ROTATION_0;
2428 }
2429 }
2430
2431 if (isPrimary) {
2432 using Values = SurfaceFlingerProperties::primary_display_orientation_values;
2433 switch (primary_display_orientation(Values::ORIENTATION_0)) {
2434 case Values::ORIENTATION_90:
2435 return ui::ROTATION_90;
2436 case Values::ORIENTATION_180:
2437 return ui::ROTATION_180;
2438 case Values::ORIENTATION_270:
2439 return ui::ROTATION_270;
2440 default:
2441 break;
2442 }
2443 }
2444 return ui::ROTATION_0;
2445}
2446
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01002447void SurfaceFlinger::postComposition() {
Dan Stoza9e56aa02015-11-02 13:00:03 -08002448 ATRACE_CALL();
2449 ALOGV("postComposition");
2450
Dominik Laskowski298b08e2022-02-15 13:45:02 -08002451 const auto* display = FTL_FAKE_GUARD(mStateLock, getDefaultDisplayDeviceLocked()).get();
Brian Anderson3d4039d2016-09-23 16:31:30 -07002452
2453 std::shared_ptr<FenceTime> glCompositionDoneFenceTime;
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002454 if (display && display->getCompositionDisplay()->getState().usesClientComposition) {
Brian Anderson3d4039d2016-09-23 16:31:30 -07002455 glCompositionDoneFenceTime =
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002456 std::make_shared<FenceTime>(display->getCompositionDisplay()
Lloyd Pique31cb2942018-10-19 17:23:03 -07002457 ->getRenderSurface()
2458 ->getClientTargetAcquireFence());
Brian Anderson3d4039d2016-09-23 16:31:30 -07002459 } else {
2460 glCompositionDoneFenceTime = FenceTime::NO_FENCE;
2461 }
Brian Anderson3d4039d2016-09-23 16:31:30 -07002462
Jen-Chih Chang1febfb82022-08-03 11:31:30 +08002463 for (size_t i = mPreviousPresentFences.size()-1; i >= 1; i--) {
2464 mPreviousPresentFences[i] = mPreviousPresentFences[i-1];
2465 }
2466
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07002467 mPreviousPresentFences[0].fence =
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02002468 display ? getHwComposer().getPresentFence(display->getPhysicalId()) : Fence::NO_FENCE;
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07002469 mPreviousPresentFences[0].fenceTime =
2470 std::make_shared<FenceTime>(mPreviousPresentFences[0].fence);
2471
Vishnu Nair9a69a042021-06-18 13:19:49 -07002472 nsecs_t now = systemTime();
2473
Jorim Jaggi8d34c902020-12-16 21:43:07 +01002474 // Set presentation information before calling Layer::releasePendingBuffer, such that jank
2475 // information from previous' frame classification is already available when sending jank info
2476 // to clients, so they get jank classification as early as possible.
Vishnu Nair9a69a042021-06-18 13:19:49 -07002477 mFrameTimeline->setSfPresent(/* sfPresentTime */ now, mPreviousPresentFences[0].fenceTime,
Adithya Srinivasan36b01af2021-04-07 22:29:47 +00002478 glCompositionDoneFenceTime);
Jorim Jaggi8d34c902020-12-16 21:43:07 +01002479
Vishnu Nair9a69a042021-06-18 13:19:49 -07002480 const DisplayStatInfo stats = mScheduler->getDisplayStatInfo(now);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002481
Lloyd Piqueab039b52019-02-13 14:22:42 -08002482 // We use the CompositionEngine::getLastFrameRefreshTimestamp() which might
2483 // be sampled a little later than when we started doing work for this frame,
2484 // but that should be okay since updateCompositorTiming has snapping logic.
2485 updateCompositorTiming(stats, mCompositionEngine->getLastFrameRefreshTimestamp(),
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07002486 mPreviousPresentFences[0].fenceTime);
Brian Andersond0010582017-03-07 13:20:31 -08002487 CompositorTiming compositorTiming;
2488 {
David Sodman99974d22017-11-28 12:04:33 -08002489 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
2490 compositorTiming = getBE().mCompositorTiming;
Brian Andersond0010582017-03-07 13:20:31 -08002491 }
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002492
Robert Carrc747ad02021-06-11 14:01:24 -07002493 for (const auto& layer: mLayersWithQueuedFrames) {
Alec Mouri1dc4bfa2021-10-01 16:31:08 -07002494 layer->onPostComposition(display, glCompositionDoneFenceTime,
2495 mPreviousPresentFences[0].fenceTime, compositorTiming);
Vishnu Nair9a69a042021-06-18 13:19:49 -07002496 layer->releasePendingBuffer(/*dequeueReadyTime*/ now);
Robert Carrc747ad02021-06-11 14:01:24 -07002497 }
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002498
John Reck88270902021-03-18 11:27:35 -04002499 std::vector<std::pair<std::shared_ptr<compositionengine::Display>, sp<HdrLayerInfoReporter>>>
2500 hdrInfoListeners;
Robert Carr167bdde2021-07-28 11:26:51 -07002501 bool haveNewListeners = false;
Alec Mouriadebf5c2021-01-05 12:57:36 -08002502 {
2503 Mutex::Autolock lock(mStateLock);
2504 if (mFpsReporter) {
2505 mFpsReporter->dispatchLayerFps();
2506 }
Galia Peycheva8f04b302021-04-27 13:25:38 +02002507
2508 if (mTunnelModeEnabledReporter) {
2509 mTunnelModeEnabledReporter->updateTunnelModeStatus();
2510 }
John Reck88270902021-03-18 11:27:35 -04002511 hdrInfoListeners.reserve(mHdrLayerInfoListeners.size());
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -07002512 for (const auto& [displayId, reporter] : mHdrLayerInfoListeners) {
2513 if (reporter && reporter->hasListeners()) {
2514 if (const auto display = getDisplayDeviceLocked(displayId)) {
2515 hdrInfoListeners.emplace_back(display->getCompositionDisplay(), reporter);
John Reck88270902021-03-18 11:27:35 -04002516 }
2517 }
2518 }
Robert Carr167bdde2021-07-28 11:26:51 -07002519 haveNewListeners = mAddingHDRLayerInfoListener; // grab this with state lock
2520 mAddingHDRLayerInfoListener = false;
John Reck88270902021-03-18 11:27:35 -04002521 }
2522
Robert Carr167bdde2021-07-28 11:26:51 -07002523 if (haveNewListeners || mSomeDataspaceChanged || mVisibleRegionsWereDirtyThisFrame) {
2524 for (auto& [compositionDisplay, listener] : hdrInfoListeners) {
2525 HdrLayerInfoReporter::HdrLayerInfo info;
2526 int32_t maxArea = 0;
2527 mDrawingState.traverse([&, compositionDisplay = compositionDisplay](Layer* layer) {
2528 const auto layerFe = layer->getCompositionEngineLayerFE();
Dominik Laskowski29fa1462021-04-27 15:51:50 -07002529 if (layer->isVisible() && compositionDisplay->includesLayer(layerFe)) {
John Reck49d9ad32022-02-23 19:03:31 -05002530 if (isHdrLayer(layer)) {
Robert Carr167bdde2021-07-28 11:26:51 -07002531 const auto* outputLayer =
2532 compositionDisplay->getOutputLayerForLayer(layerFe);
2533 if (outputLayer) {
2534 info.numberOfHdrLayers++;
2535 const auto displayFrame = outputLayer->getState().displayFrame;
2536 const int32_t area = displayFrame.width() * displayFrame.height();
2537 if (area > maxArea) {
2538 maxArea = area;
2539 info.maxW = displayFrame.width();
2540 info.maxH = displayFrame.height();
2541 }
John Reckdb1a16b2021-07-09 13:05:52 -04002542 }
John Reck88270902021-03-18 11:27:35 -04002543 }
2544 }
Robert Carr167bdde2021-07-28 11:26:51 -07002545 });
2546 listener->dispatchHdrLayerInfo(info);
2547 }
Alec Mouriadebf5c2021-01-05 12:57:36 -08002548 }
2549
Robert Carr167bdde2021-07-28 11:26:51 -07002550 mSomeDataspaceChanged = false;
2551 mVisibleRegionsWereDirtyThisFrame = false;
2552
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07002553 mTransactionCallbackInvoker.addPresentFence(mPreviousPresentFences[0].fence);
Vishnu Naircd52e2d2021-10-18 08:42:46 -07002554 mTransactionCallbackInvoker.sendCallbacks(false /* onCommitOnly */);
Robert Carr3d1047b2021-09-20 18:22:32 -07002555 mTransactionCallbackInvoker.clearCompletedTransactions();
Valerie Hau4b678442020-04-14 10:50:42 -07002556
Ady Abrahamed3290f2021-05-17 15:12:14 -07002557 if (display && display->isInternal() && display->getPowerMode() == hal::PowerMode::ON &&
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07002558 mPreviousPresentFences[0].fenceTime->isValid()) {
2559 mScheduler->addPresentFence(mPreviousPresentFences[0].fenceTime);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07002560 }
2561
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02002562 const bool isDisplayConnected =
2563 display && getHwComposer().isConnected(display->getPhysicalId());
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002564
Fabien Sanglardcbf153b2017-03-10 17:57:12 -08002565 if (!hasSyncFramework) {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002566 if (isDisplayConnected && display->isPoweredOn()) {
Ana Krulecc2870422019-01-29 19:00:58 -08002567 mScheduler->enableHardwareVsync();
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07002568 }
2569 }
2570
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002571 if (mAnimCompositionPending) {
2572 mAnimCompositionPending = false;
2573
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07002574 if (mPreviousPresentFences[0].fenceTime->isValid()) {
2575 mAnimFrameTracker.setActualPresentFence(mPreviousPresentFences[0].fenceTime);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002576 } else if (isDisplayConnected) {
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002577 // The HWC doesn't support present fences, so use the refresh
2578 // timestamp instead.
Marin Shalamanov045b7002021-01-07 16:56:24 +01002579 const nsecs_t presentTime = display->getRefreshTimestamp();
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002580 mAnimFrameTracker.setActualPresentTime(presentTime);
2581 }
2582 mAnimFrameTracker.advanceFrame();
2583 }
Dan Stozab90cf072015-03-05 11:05:59 -08002584
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002585 mTimeStats->incrementTotalFrames();
Vishnu Nair9b079a22020-01-21 14:36:08 -08002586
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07002587 mTimeStats->setPresentFenceGlobal(mPreviousPresentFences[0].fenceTime);
Yiwei Zhangce6ebc02018-10-20 12:42:38 -07002588
Alec Mouri717bcb62020-02-10 17:07:19 -08002589 const size_t sfConnections = mScheduler->getEventThreadConnectionCount(mSfConnectionHandle);
2590 const size_t appConnections = mScheduler->getEventThreadConnectionCount(mAppConnectionHandle);
2591 mTimeStats->recordDisplayEventConnectionCount(sfConnections + appConnections);
2592
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002593 if (isDisplayConnected && !display->isPoweredOn()) {
Lars Svenssond9e54692021-12-21 07:41:57 +01002594 getRenderEngine().cleanupPostRender();
Dan Stozab90cf072015-03-05 11:05:59 -08002595 return;
2596 }
2597
2598 nsecs_t currentTime = systemTime();
2599 if (mHasPoweredOff) {
2600 mHasPoweredOff = false;
2601 } else {
David Sodman4a36e932017-11-07 14:29:47 -08002602 nsecs_t elapsedTime = currentTime - getBE().mLastSwapTime;
Ana Krulece588e312018-09-18 12:32:24 -07002603 size_t numPeriods = static_cast<size_t>(elapsedTime / stats.vsyncPeriod);
David Sodman4a36e932017-11-07 14:29:47 -08002604 if (numPeriods < SurfaceFlingerBE::NUM_BUCKETS - 1) {
2605 getBE().mFrameBuckets[numPeriods] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002606 } else {
David Sodman4a36e932017-11-07 14:29:47 -08002607 getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002608 }
David Sodman4a36e932017-11-07 14:29:47 -08002609 getBE().mTotalTime += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002610 }
David Sodman4a36e932017-11-07 14:29:47 -08002611 getBE().mLastSwapTime = currentTime;
Dan Stoza436ccf32018-06-21 12:10:12 -07002612
Lingfeng Yang2e4fef62020-04-24 14:48:43 +00002613 // Cleanup any outstanding resources due to rendering a prior frame.
2614 getRenderEngine().cleanupPostRender();
2615
Dan Stoza436ccf32018-06-21 12:10:12 -07002616 {
2617 std::lock_guard lock(mTexturePoolMutex);
Dan Stoza67765d82019-05-07 14:58:27 -07002618 if (mTexturePool.size() < mTexturePoolSize) {
2619 const size_t refillCount = mTexturePoolSize - mTexturePool.size();
Dan Stoza436ccf32018-06-21 12:10:12 -07002620 const size_t offset = mTexturePool.size();
2621 mTexturePool.resize(mTexturePoolSize);
2622 getRenderEngine().genTextures(refillCount, mTexturePool.data() + offset);
2623 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Dan Stoza67765d82019-05-07 14:58:27 -07002624 } else if (mTexturePool.size() > mTexturePoolSize) {
2625 const size_t deleteCount = mTexturePool.size() - mTexturePoolSize;
2626 const size_t offset = mTexturePoolSize;
2627 getRenderEngine().deleteTextures(deleteCount, mTexturePool.data() + offset);
2628 mTexturePool.resize(mTexturePoolSize);
2629 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Dan Stoza436ccf32018-06-21 12:10:12 -07002630 }
2631 }
Marissa Walle2ffb422018-10-12 11:33:52 -07002632
Dan Stoza45de5ba2019-04-25 14:12:09 -07002633 // Even though ATRACE_INT64 already checks if tracing is enabled, it doesn't prevent the
2634 // side-effect of getTotalSize(), so we check that again here
2635 if (ATRACE_ENABLED()) {
Marissa Wall22b2de12019-12-02 18:11:43 -08002636 // getTotalSize returns the total number of buffers that were allocated by SurfaceFlinger
Dan Stoza45de5ba2019-04-25 14:12:09 -07002637 ATRACE_INT64("Total Buffer Size", GraphicBufferAllocator::get().getTotalSize());
2638 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07002639}
2640
chaviw79468ab2021-10-27 11:11:24 -05002641FloatRect SurfaceFlinger::getMaxDisplayBounds() {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08002642 const ui::Size maxSize = [this] {
2643 ftl::FakeGuard guard(mStateLock);
Vishnu Nairf6f56952022-03-01 20:29:46 -08002644
Dominik Laskowski298b08e2022-02-15 13:45:02 -08002645 // The LayerTraceGenerator tool runs without displays.
2646 if (mDisplays.empty()) return ui::Size{5000, 5000};
Vishnu Nairf6f56952022-03-01 20:29:46 -08002647
Dominik Laskowski298b08e2022-02-15 13:45:02 -08002648 return std::accumulate(mDisplays.begin(), mDisplays.end(), ui::kEmptySize,
2649 [](ui::Size size, const auto& pair) -> ui::Size {
2650 const auto& display = pair.second;
2651 return {std::max(size.getWidth(), display->getWidth()),
2652 std::max(size.getHeight(), display->getHeight())};
2653 });
2654 }();
chaviwb09c6552021-08-12 17:20:43 -05002655
2656 // Ignore display bounds for now since they will be computed later. Use a large Rect bound
2657 // to ensure it's bigger than an actual display will be.
Dominik Laskowski298b08e2022-02-15 13:45:02 -08002658 const float xMax = maxSize.getWidth() * 10.f;
2659 const float yMax = maxSize.getHeight() * 10.f;
2660
2661 return {-xMax, -yMax, xMax, yMax};
chaviw79468ab2021-10-27 11:11:24 -05002662}
2663
2664void SurfaceFlinger::computeLayerBounds() {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08002665 const FloatRect maxBounds = getMaxDisplayBounds();
chaviwb09c6552021-08-12 17:20:43 -05002666 for (const auto& layer : mDrawingState.layersSortedByZ) {
2667 layer->computeBounds(maxBounds, ui::Transform(), 0.f /* shadowRadius */);
Vishnu Nair4351ad52019-02-11 14:13:02 -08002668 }
2669}
2670
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002671void SurfaceFlinger::postFrame() {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08002672 const auto display = FTL_FAKE_GUARD(mStateLock, getDefaultDisplayDeviceLocked());
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02002673 if (display && getHwComposer().isConnected(display->getPhysicalId())) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002674 uint32_t flipCount = display->getPageFlipCount();
David Sodmanfa9b2af2017-12-24 13:28:59 -08002675 if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
2676 logFrameStats();
2677 }
2678 }
2679}
2680
Dominik Laskowski9e168db2021-05-27 16:05:12 -07002681void SurfaceFlinger::commitTransactions() {
Mathias Agopian841cde52012-03-01 15:44:37 -08002682 ATRACE_CALL();
2683
Dominik Laskowski9e168db2021-05-27 16:05:12 -07002684 // Keep a copy of the drawing state (that is going to be overwritten
2685 // by commitTransactionsLocked) outside of mStateLock so that the side
2686 // effects of the State assignment don't happen with mStateLock held,
2687 // which can cause deadlocks.
Mathias Agopian7cc6df52013-06-05 14:30:54 -07002688 State drawingState(mDrawingState);
2689
Dominik Laskowski9e168db2021-05-27 16:05:12 -07002690 Mutex::Autolock lock(mStateLock);
Dominik Laskowski9dab3432019-03-27 13:21:10 -07002691 mDebugInTransaction = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002692
Mathias Agopianca4d3602011-05-19 15:38:14 -07002693 // Here we're guaranteed that some transaction flags are set
Dominik Laskowski9e168db2021-05-27 16:05:12 -07002694 // so we can call commitTransactionsLocked unconditionally.
2695 // We clear the flags with mStateLock held to guarantee that
2696 // mCurrentState won't change until the transaction is committed.
Dominik Laskowski08d05c22020-07-22 00:05:08 -07002697 modulateVsync(&VsyncModulator::onTransactionCommit);
Dominik Laskowski9e168db2021-05-27 16:05:12 -07002698 commitTransactionsLocked(clearTransactionFlags(eTransactionMask));
Mathias Agopiandea20b12011-05-03 17:04:02 -07002699
Mathias Agopianca4d3602011-05-19 15:38:14 -07002700 mDebugInTransaction = 0;
Mathias Agopian3d579642009-06-04 18:46:21 -07002701}
2702
Dominik Laskowskib0054a22022-03-03 09:03:06 -08002703std::pair<DisplayModes, DisplayModePtr> SurfaceFlinger::loadDisplayModes(
2704 PhysicalDisplayId displayId) const {
Marin Shalamanovd3b5c5d2021-02-11 18:26:14 +01002705 std::vector<HWComposer::HWCDisplayMode> hwcModes;
2706 std::optional<hal::HWDisplayId> activeModeHwcId;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08002707
Marin Shalamanovd3b5c5d2021-02-11 18:26:14 +01002708 int attempt = 0;
2709 constexpr int kMaxAttempts = 3;
2710 do {
2711 hwcModes = getHwComposer().getModes(displayId);
2712 activeModeHwcId = getHwComposer().getActiveMode(displayId);
2713 LOG_ALWAYS_FATAL_IF(!activeModeHwcId, "HWC returned no active mode");
2714
Dominik Laskowskib0054a22022-03-03 09:03:06 -08002715 const auto isActiveMode = [activeModeHwcId](const HWComposer::HWCDisplayMode& mode) {
2716 return mode.hwcId == *activeModeHwcId;
2717 };
2718
2719 if (std::any_of(hwcModes.begin(), hwcModes.end(), isActiveMode)) {
2720 break;
2721 }
2722 } while (++attempt < kMaxAttempts);
2723
2724 LOG_ALWAYS_FATAL_IF(attempt == kMaxAttempts,
Marin Shalamanovd3b5c5d2021-02-11 18:26:14 +01002725 "After %d attempts HWC still returns an active mode which is not"
Dominik Laskowskib0054a22022-03-03 09:03:06 -08002726 " supported. Active mode ID = %" PRIu64 ". Supported modes = %s",
Marin Shalamanovd3b5c5d2021-02-11 18:26:14 +01002727 kMaxAttempts, *activeModeHwcId, base::Join(hwcModes, ", ").c_str());
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01002728
2729 DisplayModes oldModes;
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01002730 if (const auto token = getPhysicalDisplayTokenLocked(displayId)) {
2731 oldModes = getDisplayDeviceLocked(token)->getSupportedModes();
Marin Shalamanov045b7002021-01-07 16:56:24 +01002732 }
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01002733
Dominik Laskowskib0054a22022-03-03 09:03:06 -08002734 ui::DisplayModeId nextModeId = 1 +
2735 std::accumulate(oldModes.begin(), oldModes.end(), static_cast<ui::DisplayModeId>(-1),
2736 [](ui::DisplayModeId max, const auto& pair) {
2737 return std::max(max, pair.first.value());
2738 });
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01002739
2740 DisplayModes newModes;
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01002741 for (const auto& hwcMode : hwcModes) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08002742 const DisplayModeId id{nextModeId++};
2743 newModes.try_emplace(id,
2744 DisplayMode::Builder(hwcMode.hwcId)
2745 .setId(id)
2746 .setPhysicalDisplayId(displayId)
2747 .setResolution({hwcMode.width, hwcMode.height})
2748 .setVsyncPeriod(hwcMode.vsyncPeriod)
2749 .setDpiX(hwcMode.dpiX)
2750 .setDpiY(hwcMode.dpiY)
2751 .setGroup(hwcMode.configGroup)
2752 .build());
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01002753 }
2754
Dominik Laskowskib0054a22022-03-03 09:03:06 -08002755 const bool sameModes =
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01002756 std::equal(newModes.begin(), newModes.end(), oldModes.begin(), oldModes.end(),
Dominik Laskowskib0054a22022-03-03 09:03:06 -08002757 [](const auto& lhs, const auto& rhs) {
2758 return equalsExceptDisplayModeId(*lhs.second, *rhs.second);
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01002759 });
2760
Dominik Laskowskib0054a22022-03-03 09:03:06 -08002761 // Keep IDs if modes have not changed.
2762 const auto& modes = sameModes ? oldModes : newModes;
2763 const DisplayModePtr activeMode =
2764 std::find_if(modes.begin(), modes.end(), [activeModeHwcId](const auto& pair) {
2765 return pair.second->getHwcId() == activeModeHwcId;
2766 })->second;
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01002767
Dominik Laskowskib0054a22022-03-03 09:03:06 -08002768 return {modes, activeMode};
Marin Shalamanov045b7002021-01-07 16:56:24 +01002769}
2770
Lloyd Piqueba04e622017-12-14 17:11:26 -08002771void SurfaceFlinger::processDisplayHotplugEventsLocked() {
2772 for (const auto& event : mPendingHotplugEvents) {
Marin Shalamanovf8c63722020-10-06 13:11:21 +02002773 std::optional<DisplayIdentificationInfo> info =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002774 getHwComposer().onHotplug(event.hwcDisplayId, event.connection);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002775
Dominik Laskowski075d3172018-05-24 15:50:06 -07002776 if (!info) {
Lloyd Piqueba04e622017-12-14 17:11:26 -08002777 continue;
2778 }
2779
Marin Shalamanova524a092020-07-27 21:39:55 +02002780 const auto displayId = info->id;
Dominik Laskowskieb627312022-04-07 09:13:16 -07002781 const auto token = mPhysicalDisplayTokens.get(displayId);
Dominik Laskowski55c85402020-01-21 16:25:47 -08002782
Peiyong Line9d809e2020-04-14 13:10:48 -07002783 if (event.connection == hal::Connection::CONNECTED) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08002784 auto [supportedModes, activeMode] = loadDisplayModes(displayId);
Marin Shalamanova903d032020-12-29 20:35:13 +01002785
Dominik Laskowskieb627312022-04-07 09:13:16 -07002786 if (!token) {
Dominik Laskowski55c85402020-01-21 16:25:47 -08002787 ALOGV("Creating display %s", to_string(displayId).c_str());
2788
Dominik Laskowski075d3172018-05-24 15:50:06 -07002789 DisplayDeviceState state;
Marin Shalamanov7ce87642020-05-06 13:45:58 +02002790 state.physical = {.id = displayId,
2791 .type = getHwComposer().getDisplayConnectionType(displayId),
2792 .hwcDisplayId = event.hwcDisplayId,
Marin Shalamanova903d032020-12-29 20:35:13 +01002793 .deviceProductInfo = std::move(info->deviceProductInfo),
2794 .supportedModes = std::move(supportedModes),
Dominik Laskowskib0054a22022-03-03 09:03:06 -08002795 .activeMode = std::move(activeMode)};
Dominik Laskowski075d3172018-05-24 15:50:06 -07002796 state.isSecure = true; // All physical displays are currently considered secure.
Marin Shalamanovf8c63722020-10-06 13:11:21 +02002797 state.displayName = std::move(info->name);
Dominik Laskowski55c85402020-01-21 16:25:47 -08002798
2799 sp<IBinder> token = new BBinder();
2800 mCurrentState.displays.add(token, state);
Dominik Laskowskieb627312022-04-07 09:13:16 -07002801 mPhysicalDisplayTokens.try_emplace(displayId, std::move(token));
Dominik Laskowski075d3172018-05-24 15:50:06 -07002802 mInterceptor->saveDisplayCreation(state);
Marin Shalamanov700e6392020-02-12 20:22:26 +01002803 } else {
2804 ALOGV("Recreating display %s", to_string(displayId).c_str());
2805
Dominik Laskowskieb627312022-04-07 09:13:16 -07002806 auto& state = mCurrentState.displays.editValueFor(token->get());
2807 state.sequenceId = DisplayDeviceState{}.sequenceId; // Generate new sequenceId.
Marin Shalamanova903d032020-12-29 20:35:13 +01002808 state.physical->supportedModes = std::move(supportedModes);
Dominik Laskowskib0054a22022-03-03 09:03:06 -08002809 state.physical->activeMode = std::move(activeMode);
Marin Shalamanovf8c63722020-10-06 13:11:21 +02002810 if (getHwComposer().updatesDeviceProductInfoOnHotplugReconnect()) {
2811 state.physical->deviceProductInfo = std::move(info->deviceProductInfo);
2812 }
Steven Thomaseb6d2052018-03-20 15:40:48 -07002813 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08002814 } else {
Dominik Laskowski55c85402020-01-21 16:25:47 -08002815 ALOGV("Removing display %s", to_string(displayId).c_str());
Lloyd Piqueba04e622017-12-14 17:11:26 -08002816
Dominik Laskowskieb627312022-04-07 09:13:16 -07002817 if (const ssize_t index = mCurrentState.displays.indexOfKey(token->get()); index >= 0) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002818 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
2819 mInterceptor->saveDisplayDeletion(state.sequenceId);
2820 mCurrentState.displays.removeItemsAt(index);
Lloyd Piquefcd86612017-12-14 17:15:36 -08002821 }
Dominik Laskowskieb627312022-04-07 09:13:16 -07002822
2823 mPhysicalDisplayTokens.erase(displayId);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002824 }
2825
2826 processDisplayChangesLocked();
2827 }
2828
2829 mPendingHotplugEvents.clear();
2830}
2831
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002832void SurfaceFlinger::dispatchDisplayHotplugEvent(PhysicalDisplayId displayId, bool connected) {
Marin Shalamanov9cf9e512020-12-02 13:28:06 +01002833 ALOGI("Dispatching display hotplug event displayId=%s, connected=%d",
2834 to_string(displayId).c_str(), connected);
Dominik Laskowski98041832019-08-01 18:35:59 -07002835 mScheduler->onHotplugReceived(mAppConnectionHandle, displayId, connected);
2836 mScheduler->onHotplugReceived(mSfConnectionHandle, displayId, connected);
Dominik Laskowski1eba0202019-01-24 09:14:40 -08002837}
2838
Lloyd Pique99d3da52018-01-22 17:48:03 -08002839sp<DisplayDevice> SurfaceFlinger::setupNewDisplayDeviceInternal(
Lloyd Pique9370a482019-10-03 17:58:30 -07002840 const wp<IBinder>& displayToken,
2841 std::shared_ptr<compositionengine::Display> compositionDisplay,
Marin Shalamanovae685592020-02-12 17:12:22 +01002842 const DisplayDeviceState& state,
2843 const sp<compositionengine::DisplaySurface>& displaySurface,
Dominik Laskowski075d3172018-05-24 15:50:06 -07002844 const sp<IGraphicBufferProducer>& producer) {
Marin Shalamanov12c9e5a2021-01-07 00:25:35 +01002845 DisplayDeviceCreationArgs creationArgs(this, getHwComposer(), displayToken, compositionDisplay);
Dominik Laskowskie9774092018-12-11 10:04:24 -08002846 creationArgs.sequenceId = state.sequenceId;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002847 creationArgs.isSecure = state.isSecure;
Marin Shalamanovae685592020-02-12 17:12:22 +01002848 creationArgs.displaySurface = displaySurface;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002849 creationArgs.hasWideColorGamut = false;
2850 creationArgs.supportedPerFrameMetadata = 0;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002851
Dominik Laskowski55c85402020-01-21 16:25:47 -08002852 if (const auto& physical = state.physical) {
2853 creationArgs.connectionType = physical->type;
Marin Shalamanova903d032020-12-29 20:35:13 +01002854 creationArgs.supportedModes = physical->supportedModes;
Ady Abraham3efa3942021-06-24 19:01:25 -07002855 creationArgs.activeModeId = physical->activeMode->getId();
ramindani32cf0602022-03-02 02:30:29 +00002856 const auto [kernelIdleTimerController, idleTimerTimeoutMs] =
2857 getKernelIdleTimerProperties(compositionDisplay->getId());
2858
Ady Abraham3efa3942021-06-24 19:01:25 -07002859 scheduler::RefreshRateConfigs::Config config =
2860 {.enableFrameRateOverride = android::sysprop::enable_frame_rate_override(false),
2861 .frameRateMultipleThreshold =
Ady Abraham9a2ea342021-09-03 17:32:34 -07002862 base::GetIntProperty("debug.sf.frame_rate_multiple_threshold", 0),
ramindani32cf0602022-03-02 02:30:29 +00002863 .idleTimerTimeout = idleTimerTimeoutMs,
2864 .kernelIdleTimerController = kernelIdleTimerController};
Ady Abraham3efa3942021-06-24 19:01:25 -07002865 creationArgs.refreshRateConfigs =
2866 std::make_shared<scheduler::RefreshRateConfigs>(creationArgs.supportedModes,
2867 creationArgs.activeModeId, config);
Dominik Laskowski55c85402020-01-21 16:25:47 -08002868 }
2869
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02002870 if (const auto id = PhysicalDisplayId::tryCast(compositionDisplay->getId())) {
Dominik Laskowski3c363242022-04-07 10:44:12 -07002871 creationArgs.isPrimary = id == getPrimaryDisplayIdLocked();
Dominik Laskowski075d3172018-05-24 15:50:06 -07002872
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02002873 if (useColorManagement) {
2874 std::vector<ColorMode> modes = getHwComposer().getColorModes(*id);
2875 for (ColorMode colorMode : modes) {
2876 if (isWideColorMode(colorMode)) {
2877 creationArgs.hasWideColorGamut = true;
2878 }
2879
2880 std::vector<RenderIntent> renderIntents =
2881 getHwComposer().getRenderIntents(*id, colorMode);
2882 creationArgs.hwcColorModes.emplace(colorMode, renderIntents);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002883 }
2884 }
tangrobin6753a022018-08-10 10:58:54 +08002885 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002886
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02002887 if (const auto id = HalDisplayId::tryCast(compositionDisplay->getId())) {
2888 getHwComposer().getHdrCapabilities(*id, &creationArgs.hdrCapabilities);
2889 creationArgs.supportedPerFrameMetadata = getHwComposer().getSupportedPerFrameMetadata(*id);
Chia-I Wu0f509fb2018-06-21 15:52:50 +08002890 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002891
Lloyd Pique90c115d2018-09-18 21:39:42 -07002892 auto nativeWindowSurface = getFactory().createNativeWindowSurface(producer);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002893 auto nativeWindow = nativeWindowSurface->getNativeWindow();
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002894 creationArgs.nativeWindow = nativeWindow;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002895
Lloyd Pique99d3da52018-01-22 17:48:03 -08002896 // Make sure that composition can never be stalled by a virtual display
2897 // consumer that isn't processing buffers fast enough. We have to do this
Alec Mouri0a9c7b82018-11-16 13:05:25 -08002898 // here, in case the display is composed entirely by HWC.
Dominik Laskowski281644e2018-04-19 15:47:35 -07002899 if (state.isVirtual()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002900 nativeWindow->setSwapInterval(nativeWindow.get(), 0);
2901 }
2902
Dominik Laskowski718f9602019-11-09 20:01:35 -08002903 creationArgs.physicalOrientation =
ramindani06e518e2022-03-14 18:47:53 +00002904 getPhysicalDisplayOrientation(compositionDisplay->getId(), creationArgs.isPrimary);
2905 ALOGV("Display Orientation: %s", toCString(creationArgs.physicalOrientation));
Chia-I Wua02871c2018-08-27 14:38:23 -07002906
Lloyd Pique99d3da52018-01-22 17:48:03 -08002907 // virtual displays are always considered enabled
linpetere8059322022-07-13 19:20:48 +08002908 creationArgs.initialPowerMode =
2909 state.isVirtual() ? std::make_optional(hal::PowerMode::ON) : std::nullopt;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002910
Lloyd Pique9370a482019-10-03 17:58:30 -07002911 sp<DisplayDevice> display = getFactory().createDisplayDevice(creationArgs);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002912
Ady Abraham8565ad22021-06-22 17:45:44 -07002913 nativeWindowSurface->preallocateBuffers();
Lloyd Pique99d3da52018-01-22 17:48:03 -08002914
2915 ColorMode defaultColorMode = ColorMode::NATIVE;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002916 Dataspace defaultDataSpace = Dataspace::UNKNOWN;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002917 if (display->hasWideColorGamut()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002918 defaultColorMode = ColorMode::SRGB;
Peiyong Lin14724e62018-12-05 07:27:30 -08002919 defaultDataSpace = Dataspace::V0_SRGB;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002920 }
Lloyd Pique6a3b4462019-03-07 20:58:12 -08002921 display->getCompositionDisplay()->setColorProfile(
2922 compositionengine::Output::ColorProfile{defaultColorMode, defaultDataSpace,
2923 RenderIntent::COLORIMETRIC,
2924 Dataspace::UNKNOWN});
Dominik Laskowski075d3172018-05-24 15:50:06 -07002925 if (!state.isVirtual()) {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08002926 FTL_FAKE_GUARD(kMainThreadContext,
2927 display->setActiveMode(state.physical->activeMode->getId()));
Marin Shalamanov7ce87642020-05-06 13:45:58 +02002928 display->setDeviceProductInfo(state.physical->deviceProductInfo);
Lloyd Pique3c085a02018-05-09 19:38:32 -07002929 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07002930
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002931 display->setLayerStack(state.layerStack);
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02002932 display->setProjection(state.orientation, state.layerStackSpaceRect,
2933 state.orientedDisplaySpaceRect);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002934 display->setDisplayName(state.displayName);
Vishnu Naira119aaa2021-09-24 07:19:35 -07002935 display->setFlags(state.flags);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002936
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002937 return display;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002938}
2939
Marin Shalamanovae685592020-02-12 17:12:22 +01002940void SurfaceFlinger::processDisplayAdded(const wp<IBinder>& displayToken,
2941 const DisplayDeviceState& state) {
Marin Shalamanov045b7002021-01-07 16:56:24 +01002942 ui::Size resolution(0, 0);
Marin Shalamanovae685592020-02-12 17:12:22 +01002943 ui::PixelFormat pixelFormat = static_cast<ui::PixelFormat>(PIXEL_FORMAT_UNKNOWN);
2944 if (state.physical) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08002945 resolution = state.physical->activeMode->getResolution();
Marin Shalamanovae685592020-02-12 17:12:22 +01002946 pixelFormat = static_cast<ui::PixelFormat>(PIXEL_FORMAT_RGBA_8888);
2947 } else if (state.surface != nullptr) {
Marin Shalamanov045b7002021-01-07 16:56:24 +01002948 int status = state.surface->query(NATIVE_WINDOW_WIDTH, &resolution.width);
Marin Shalamanovae685592020-02-12 17:12:22 +01002949 ALOGE_IF(status != NO_ERROR, "Unable to query width (%d)", status);
Marin Shalamanov045b7002021-01-07 16:56:24 +01002950 status = state.surface->query(NATIVE_WINDOW_HEIGHT, &resolution.height);
Marin Shalamanovae685592020-02-12 17:12:22 +01002951 ALOGE_IF(status != NO_ERROR, "Unable to query height (%d)", status);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08002952 int format;
2953 status = state.surface->query(NATIVE_WINDOW_FORMAT, &format);
Marin Shalamanovae685592020-02-12 17:12:22 +01002954 ALOGE_IF(status != NO_ERROR, "Unable to query format (%d)", status);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08002955 pixelFormat = static_cast<ui::PixelFormat>(format);
Marin Shalamanovae685592020-02-12 17:12:22 +01002956 } else {
2957 // Virtual displays without a surface are dormant:
2958 // they have external state (layer stack, projection,
2959 // etc.) but no internal state (i.e. a DisplayDevice).
2960 return;
2961 }
2962
2963 compositionengine::DisplayCreationArgsBuilder builder;
2964 if (const auto& physical = state.physical) {
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08002965 builder.setId(physical->id);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08002966 } else {
Dominik Laskowski263eec42021-07-21 23:13:24 -07002967 builder.setId(acquireVirtualDisplay(resolution, pixelFormat));
Marin Shalamanovae685592020-02-12 17:12:22 +01002968 }
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08002969
Marin Shalamanov045b7002021-01-07 16:56:24 +01002970 builder.setPixels(resolution);
Marin Shalamanovae685592020-02-12 17:12:22 +01002971 builder.setIsSecure(state.isSecure);
Xiang Wang839fe5b2022-04-04 17:39:38 +00002972 builder.setPowerAdvisor(mPowerAdvisor.get());
Marin Shalamanovae685592020-02-12 17:12:22 +01002973 builder.setName(state.displayName);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08002974 auto compositionDisplay = getCompositionEngine().createDisplay(builder.build());
Alec Mouridd8bf2d2021-05-08 16:36:33 -07002975 compositionDisplay->setLayerCachingEnabled(mLayerCachingEnabled);
Marin Shalamanovae685592020-02-12 17:12:22 +01002976
2977 sp<compositionengine::DisplaySurface> displaySurface;
2978 sp<IGraphicBufferProducer> producer;
2979 sp<IGraphicBufferProducer> bqProducer;
2980 sp<IGraphicBufferConsumer> bqConsumer;
2981 getFactory().createBufferQueue(&bqProducer, &bqConsumer, /*consumerIsSurfaceFlinger =*/false);
2982
Marin Shalamanovae685592020-02-12 17:12:22 +01002983 if (state.isVirtual()) {
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08002984 const auto displayId = VirtualDisplayId::tryCast(compositionDisplay->getId());
2985 LOG_FATAL_IF(!displayId);
2986 auto surface = sp<VirtualDisplaySurface>::make(getHwComposer(), *displayId, state.surface,
2987 bqProducer, bqConsumer, state.displayName);
2988 displaySurface = surface;
2989 producer = std::move(surface);
Marin Shalamanovae685592020-02-12 17:12:22 +01002990 } else {
2991 ALOGE_IF(state.surface != nullptr,
2992 "adding a supported display, but rendering "
2993 "surface is provided (%p), ignoring it",
2994 state.surface.get());
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08002995 const auto displayId = PhysicalDisplayId::tryCast(compositionDisplay->getId());
2996 LOG_FATAL_IF(!displayId);
2997 displaySurface =
2998 sp<FramebufferSurface>::make(getHwComposer(), *displayId, bqConsumer,
Dominik Laskowskib0054a22022-03-03 09:03:06 -08002999 state.physical->activeMode->getResolution(),
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003000 ui::Size(maxGraphicsWidth, maxGraphicsHeight));
Marin Shalamanovae685592020-02-12 17:12:22 +01003001 producer = bqProducer;
3002 }
3003
Marin Shalamanov700e6392020-02-12 20:22:26 +01003004 LOG_FATAL_IF(!displaySurface);
Dominik Laskowskieb627312022-04-07 09:13:16 -07003005 auto display = setupNewDisplayDeviceInternal(displayToken, std::move(compositionDisplay), state,
3006 displaySurface, producer);
Ady Abraham3efa3942021-06-24 19:01:25 -07003007 if (display->isPrimary()) {
3008 initScheduler(display);
3009 }
Marin Shalamanov700e6392020-02-12 20:22:26 +01003010 if (!state.isVirtual()) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02003011 dispatchDisplayHotplugEvent(display->getPhysicalId(), true);
Marin Shalamanov700e6392020-02-12 20:22:26 +01003012 }
Dominik Laskowskieb627312022-04-07 09:13:16 -07003013
3014 mDisplays.try_emplace(displayToken, std::move(display));
Marin Shalamanovae685592020-02-12 17:12:22 +01003015}
3016
3017void SurfaceFlinger::processDisplayRemoved(const wp<IBinder>& displayToken) {
Vishnu Nairf78589c2020-12-02 18:36:03 -08003018 auto display = getDisplayDeviceLocked(displayToken);
3019 if (display) {
Marin Shalamanovae685592020-02-12 17:12:22 +01003020 display->disconnect();
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003021
3022 if (display->isVirtual()) {
3023 releaseVirtualDisplay(display->getVirtualId());
3024 } else {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02003025 dispatchDisplayHotplugEvent(display->getPhysicalId(), false);
Marin Shalamanovae685592020-02-12 17:12:22 +01003026 }
3027 }
3028
3029 mDisplays.erase(displayToken);
Vishnu Nairf78589c2020-12-02 18:36:03 -08003030
3031 if (display && display->isVirtual()) {
Dominik Laskowski756b7892021-08-04 12:53:59 -07003032 static_cast<void>(mScheduler->schedule([display = std::move(display)] {
Vishnu Nairf78589c2020-12-02 18:36:03 -08003033 // Destroy the display without holding the mStateLock.
3034 // This is a temporary solution until we can manage transaction queues without
3035 // holding the mStateLock.
3036 // With blast, the IGBP that is passed to the VirtualDisplaySurface is owned by the
3037 // client. When the IGBP is disconnected, its buffer cache in SF will be cleared
3038 // via SurfaceComposerClient::doUncacheBufferTransaction. This call from the client
3039 // ends up running on the main thread causing a deadlock since setTransactionstate
3040 // will try to acquire the mStateLock. Instead we extend the lifetime of
3041 // DisplayDevice and destroy it in the main thread without holding the mStateLock.
3042 // The display will be disconnected and removed from the mDisplays list so it will
3043 // not be accessible.
3044 }));
3045 }
Marin Shalamanovae685592020-02-12 17:12:22 +01003046}
3047
3048void SurfaceFlinger::processDisplayChanged(const wp<IBinder>& displayToken,
3049 const DisplayDeviceState& currentState,
3050 const DisplayDeviceState& drawingState) {
3051 const sp<IBinder> currentBinder = IInterface::asBinder(currentState.surface);
3052 const sp<IBinder> drawingBinder = IInterface::asBinder(drawingState.surface);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003053
3054 // Recreate the DisplayDevice if the surface or sequence ID changed.
Marin Shalamanov700e6392020-02-12 20:22:26 +01003055 if (currentBinder != drawingBinder || currentState.sequenceId != drawingState.sequenceId) {
Marin Shalamanov23c31af2020-09-09 15:01:47 +02003056 getRenderEngine().cleanFramebufferCache();
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003057
Marin Shalamanovae685592020-02-12 17:12:22 +01003058 if (const auto display = getDisplayDeviceLocked(displayToken)) {
3059 display->disconnect();
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003060 if (display->isVirtual()) {
3061 releaseVirtualDisplay(display->getVirtualId());
3062 }
Marin Shalamanovae685592020-02-12 17:12:22 +01003063 }
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003064
Marin Shalamanovae685592020-02-12 17:12:22 +01003065 mDisplays.erase(displayToken);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003066
Marin Shalamanov700e6392020-02-12 20:22:26 +01003067 if (const auto& physical = currentState.physical) {
3068 getHwComposer().allocatePhysicalDisplay(physical->hwcDisplayId, physical->id);
3069 }
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003070
Marin Shalamanovae685592020-02-12 17:12:22 +01003071 processDisplayAdded(displayToken, currentState);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08003072
Marin Shalamanov700e6392020-02-12 20:22:26 +01003073 if (currentState.physical) {
Marin Shalamanov4c5e3012020-06-04 21:41:42 +02003074 const auto display = getDisplayDeviceLocked(displayToken);
3075 setPowerModeInternal(display, hal::PowerMode::ON);
Marin Shalamanovf7f6b3c2020-12-09 13:19:38 +01003076
3077 // TODO(b/175678251) Call a listener instead.
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07003078 if (currentState.physical->hwcDisplayId == getHwComposer().getPrimaryHwcDisplayId()) {
Ady Abraham3efa3942021-06-24 19:01:25 -07003079 updateInternalDisplayVsyncLocked(display);
Marin Shalamanovf7f6b3c2020-12-09 13:19:38 +01003080 }
Marin Shalamanov700e6392020-02-12 20:22:26 +01003081 }
Marin Shalamanovae685592020-02-12 17:12:22 +01003082 return;
3083 }
3084
3085 if (const auto display = getDisplayDeviceLocked(displayToken)) {
3086 if (currentState.layerStack != drawingState.layerStack) {
3087 display->setLayerStack(currentState.layerStack);
3088 }
Evan Rosky2239b372021-05-20 13:43:47 -07003089 if (currentState.flags != drawingState.flags) {
3090 display->setFlags(currentState.flags);
3091 }
Marin Shalamanovae685592020-02-12 17:12:22 +01003092 if ((currentState.orientation != drawingState.orientation) ||
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02003093 (currentState.layerStackSpaceRect != drawingState.layerStackSpaceRect) ||
3094 (currentState.orientedDisplaySpaceRect != drawingState.orientedDisplaySpaceRect)) {
3095 display->setProjection(currentState.orientation, currentState.layerStackSpaceRect,
3096 currentState.orientedDisplaySpaceRect);
Ady Abraham1273ac12021-08-26 17:31:53 -07003097 if (isDisplayActiveLocked(display)) {
3098 mActiveDisplayTransformHint = display->getTransformHint();
Arthur Hungb6aa9a02021-06-09 14:23:01 +08003099 }
Marin Shalamanovae685592020-02-12 17:12:22 +01003100 }
3101 if (currentState.width != drawingState.width ||
3102 currentState.height != drawingState.height) {
3103 display->setDisplaySize(currentState.width, currentState.height);
Dominik Laskowski20134642020-04-20 22:36:44 -07003104
Ady Abrahamed3290f2021-05-17 15:12:14 -07003105 if (isDisplayActiveLocked(display)) {
3106 onActiveDisplaySizeChanged(display);
Marin Shalamanovae685592020-02-12 17:12:22 +01003107 }
3108 }
3109 }
3110}
Ady Abraham3efa3942021-06-24 19:01:25 -07003111void SurfaceFlinger::updateInternalDisplayVsyncLocked(const sp<DisplayDevice>& activeDisplay) {
Ady Abrahamed3290f2021-05-17 15:12:14 -07003112 mVsyncConfiguration->reset();
Dominik Laskowskib0054a22022-03-03 09:03:06 -08003113 const Fps refreshRate = activeDisplay->refreshRateConfigs().getActiveMode()->getFps();
Ady Abrahamed3290f2021-05-17 15:12:14 -07003114 updatePhaseConfiguration(refreshRate);
3115 mRefreshRateStats->setRefreshRate(refreshRate);
Ady Abrahamed3290f2021-05-17 15:12:14 -07003116}
Marin Shalamanovae685592020-02-12 17:12:22 +01003117
Lloyd Pique347200f2017-12-14 17:00:15 -08003118void SurfaceFlinger::processDisplayChangesLocked() {
3119 // here we take advantage of Vector's copy-on-write semantics to
3120 // improve performance by skipping the transaction entirely when
3121 // know that the lists are identical
3122 const KeyedVector<wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
3123 const KeyedVector<wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
3124 if (!curr.isIdenticalTo(draw)) {
3125 mVisibleRegionsDirty = true;
Lloyd Pique347200f2017-12-14 17:00:15 -08003126
3127 // find the displays that were removed
3128 // (ie: in drawing state but not in current state)
3129 // also handle displays that changed
3130 // (ie: displays that are in both lists)
Marin Shalamanovae685592020-02-12 17:12:22 +01003131 for (size_t i = 0; i < draw.size(); i++) {
3132 const wp<IBinder>& displayToken = draw.keyAt(i);
3133 const ssize_t j = curr.indexOfKey(displayToken);
Lloyd Pique347200f2017-12-14 17:00:15 -08003134 if (j < 0) {
3135 // in drawing state but not in current state
Marin Shalamanovae685592020-02-12 17:12:22 +01003136 processDisplayRemoved(displayToken);
Lloyd Pique347200f2017-12-14 17:00:15 -08003137 } else {
3138 // this display is in both lists. see if something changed.
Marin Shalamanovae685592020-02-12 17:12:22 +01003139 const DisplayDeviceState& currentState = curr[j];
3140 const DisplayDeviceState& drawingState = draw[i];
3141 processDisplayChanged(displayToken, currentState, drawingState);
Lloyd Pique347200f2017-12-14 17:00:15 -08003142 }
Lloyd Pique347200f2017-12-14 17:00:15 -08003143 }
3144
3145 // find displays that were added
3146 // (ie: in current state but not in drawing state)
Marin Shalamanovae685592020-02-12 17:12:22 +01003147 for (size_t i = 0; i < curr.size(); i++) {
3148 const wp<IBinder>& displayToken = curr.keyAt(i);
3149 if (draw.indexOfKey(displayToken) < 0) {
3150 processDisplayAdded(displayToken, curr[i]);
Lloyd Pique347200f2017-12-14 17:00:15 -08003151 }
3152 }
3153 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08003154
3155 mDrawingState.displays = mCurrentState.displays;
Lloyd Pique347200f2017-12-14 17:00:15 -08003156}
3157
Dominik Laskowski9e168db2021-05-27 16:05:12 -07003158void SurfaceFlinger::commitTransactionsLocked(uint32_t transactionFlags) {
3159 // Commit display transactions.
Vishnu Nair6bdec7d2021-05-10 15:01:13 -07003160 const bool displayTransactionNeeded = transactionFlags & eDisplayTransactionNeeded;
3161 if (displayTransactionNeeded) {
3162 processDisplayChangesLocked();
3163 processDisplayHotplugEventsLocked();
3164 }
Robert Carrb552ff52021-06-11 13:35:54 -07003165 mForceTransactionDisplayChange = displayTransactionNeeded;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003166
Robert Carre450fb52021-06-11 13:21:09 -07003167 if (mSomeChildrenChanged) {
3168 mVisibleRegionsDirty = true;
3169 mSomeChildrenChanged = false;
3170 }
3171
Dominik Laskowski9e168db2021-05-27 16:05:12 -07003172 // Update transform hint.
Vishnu Nair6213bd92020-05-08 17:42:25 -07003173 if (transactionFlags & (eTransformHintUpdateNeeded | eDisplayTransactionNeeded)) {
Dominik Laskowski29fa1462021-04-27 15:51:50 -07003174 // Layers and/or displays have changed, so update the transform hint for each layer.
Mathias Agopian84300952012-11-21 16:02:13 -08003175 //
Lloyd Piquec29e4c62019-03-07 21:48:19 -08003176 // NOTE: we do this here, rather than when presenting the display so that
Mathias Agopian84300952012-11-21 16:02:13 -08003177 // the hint is set before we acquire a buffer from the surface texture.
3178 //
3179 // NOTE: layer transactions have taken place already, so we use their
3180 // drawing state. However, SurfaceFlinger's own transaction has not
3181 // happened yet, so we must use the current state layer list
3182 // (soon to become the drawing state list).
3183 //
Dominik Laskowski9fae1022018-05-29 13:17:40 -07003184 sp<const DisplayDevice> hintDisplay;
Dominik Laskowski29fa1462021-04-27 15:51:50 -07003185 ui::LayerStack layerStack;
3186
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07003187 mCurrentState.traverse([&](Layer* layer) REQUIRES(mStateLock) {
Mathias Agopian84300952012-11-21 16:02:13 -08003188 // NOTE: we rely on the fact that layers are sorted by
3189 // layerStack first (so we don't have to traverse the list
3190 // of displays for every layer).
Dominik Laskowski29fa1462021-04-27 15:51:50 -07003191 if (const auto filter = layer->getOutputFilter(); layerStack != filter.layerStack) {
3192 layerStack = filter.layerStack;
Dominik Laskowski9fae1022018-05-29 13:17:40 -07003193 hintDisplay = nullptr;
Dominik Laskowski29fa1462021-04-27 15:51:50 -07003194
3195 // Find the display that includes the layer.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07003196 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski29fa1462021-04-27 15:51:50 -07003197 if (!display->getCompositionDisplay()->includesLayer(filter)) {
3198 continue;
Mathias Agopian84300952012-11-21 16:02:13 -08003199 }
Dominik Laskowski29fa1462021-04-27 15:51:50 -07003200
3201 // Pick the primary display if another display mirrors the layer.
3202 if (hintDisplay) {
3203 hintDisplay = nullptr;
3204 break;
3205 }
3206
3207 hintDisplay = display;
Mathias Agopian84300952012-11-21 16:02:13 -08003208 }
3209 }
Chet Haase91d25932013-04-11 15:24:55 -07003210
Dominik Laskowski9fae1022018-05-29 13:17:40 -07003211 if (!hintDisplay) {
Lloyd Piqued432a7c2018-03-23 16:05:31 -07003212 // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
3213 // redraw after transform hint changes. See bug 8508397.
Robert Carr56a0b9a2017-12-04 16:06:13 -08003214
Lloyd Piqued432a7c2018-03-23 16:05:31 -07003215 // could be null when this layer is using a layerStack
3216 // that is not visible on any display. Also can occur at
3217 // screen off/on times.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07003218 hintDisplay = getDefaultDisplayDeviceLocked();
Mathias Agopian84300952012-11-21 16:02:13 -08003219 }
Lloyd Piqued432a7c2018-03-23 16:05:31 -07003220
Dominik Laskowski29fa1462021-04-27 15:51:50 -07003221 layer->updateTransformHint(hintDisplay->getTransformHint());
Robert Carr2047fae2016-11-28 14:09:09 -08003222 });
Mathias Agopian84300952012-11-21 16:02:13 -08003223 }
3224
Robert Carr1f0a16a2016-10-24 16:27:39 -07003225 if (mLayersAdded) {
3226 mLayersAdded = false;
3227 // Layers have been added.
Mathias Agopian3559b072012-08-15 13:46:03 -07003228 mVisibleRegionsDirty = true;
3229 }
3230
3231 // some layers might have been removed, so
3232 // we need to update the regions they're exposing.
3233 if (mLayersRemoved) {
3234 mLayersRemoved = false;
3235 mVisibleRegionsDirty = true;
Robert Carr2047fae2016-11-28 14:09:09 -08003236 mDrawingState.traverseInZOrder([&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003237 if (mLayersPendingRemoval.indexOf(layer) >= 0) {
Mathias Agopian3559b072012-08-15 13:46:03 -07003238 // this layer is not visible anymore
Robert Carr1f0a16a2016-10-24 16:27:39 -07003239 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08003240 visibleReg.set(layer->getScreenBounds());
Chia-I Wuab0c3192017-08-01 11:29:00 -07003241 invalidateLayerStack(layer, visibleReg);
Mathias Agopian0aa758d2009-04-22 15:23:34 -07003242 }
Robert Carr2047fae2016-11-28 14:09:09 -08003243 });
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003244 }
3245
Dominik Laskowski9e168db2021-05-27 16:05:12 -07003246 doCommitTransactions();
3247 signalSynchronousTransactions(CountDownLatch::eSyncTransaction);
3248 mAnimTransactionPending = false;
Riley Andrews03414a12014-07-01 14:22:59 -07003249}
3250
Vishnu Nair6194e2e2019-02-06 12:58:39 -08003251void SurfaceFlinger::updateInputFlinger() {
Robert Carr720e5062018-07-30 17:45:14 -07003252 ATRACE_CALL();
Jaineel Mehtaac331c52021-11-29 21:38:10 +00003253 if (!mInputFlinger) {
Vishnu Nair42a27b52021-11-18 15:35:22 -08003254 return;
3255 }
Vishnu Nair6194e2e2019-02-06 12:58:39 -08003256
Vishnu Nair03ccbd62021-12-01 17:21:16 -08003257 std::vector<WindowInfo> windowInfos;
3258 std::vector<DisplayInfo> displayInfos;
3259 bool updateWindowInfo = false;
Jaineel Mehtaac331c52021-11-29 21:38:10 +00003260 if (mVisibleRegionsDirty || mInputInfoChanged) {
3261 mInputInfoChanged = false;
Vishnu Nair03ccbd62021-12-01 17:21:16 -08003262 updateWindowInfo = true;
3263 buildWindowInfos(windowInfos, displayInfos);
Jaineel Mehtaac331c52021-11-29 21:38:10 +00003264 }
Vishnu Nair03ccbd62021-12-01 17:21:16 -08003265 if (!updateWindowInfo && mInputWindowCommands.empty()) {
3266 return;
3267 }
Alec Mouri8d7d0f42022-05-10 23:33:40 +00003268 BackgroundExecutor::getInstance().sendCallbacks({[updateWindowInfo,
3269 windowInfos = std::move(windowInfos),
3270 displayInfos = std::move(displayInfos),
3271 inputWindowCommands =
3272 std::move(mInputWindowCommands),
3273 inputFlinger = mInputFlinger, this]() {
Vishnu Nair03ccbd62021-12-01 17:21:16 -08003274 ATRACE_NAME("BackgroundExecutor::updateInputFlinger");
3275 if (updateWindowInfo) {
3276 mWindowInfosListenerInvoker->windowInfosChanged(windowInfos, displayInfos,
3277 inputWindowCommands.syncInputWindows);
3278 } else if (inputWindowCommands.syncInputWindows) {
3279 // If the caller requested to sync input windows, but there are no
3280 // changes to input windows, notify immediately.
3281 windowInfosReported();
3282 }
3283 for (const auto& focusRequest : inputWindowCommands.focusRequests) {
3284 inputFlinger->setFocusedWindow(focusRequest);
3285 }
Alec Mouri8d7d0f42022-05-10 23:33:40 +00003286 }});
Jaineel Mehtaac331c52021-11-29 21:38:10 +00003287
Arthur Hung6cbb9752019-09-05 16:38:18 +08003288 mInputWindowCommands.clear();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08003289}
3290
Alec Mouricdf16792021-12-10 13:16:06 -08003291void SurfaceFlinger::persistDisplayBrightness(bool needsComposite) {
3292 const bool supportsDisplayBrightnessCommand = getHwComposer().getComposer()->isSupported(
3293 Hwc2::Composer::OptionalFeature::DisplayBrightnessCommand);
3294 if (!supportsDisplayBrightnessCommand) {
3295 return;
3296 }
3297
Dominik Laskowski298b08e2022-02-15 13:45:02 -08003298 for (const auto& [_, display] : FTL_FAKE_GUARD(mStateLock, mDisplays)) {
Alec Mouricdf16792021-12-10 13:16:06 -08003299 if (const auto brightness = display->getStagedBrightness(); brightness) {
3300 if (!needsComposite) {
3301 const status_t error =
3302 getHwComposer()
3303 .setDisplayBrightness(display->getPhysicalId(), *brightness,
Alec Mouri4d8a05d2022-03-23 18:14:26 +00003304 display->getCompositionDisplay()
3305 ->getState()
3306 .displayBrightnessNits,
Alec Mouricdf16792021-12-10 13:16:06 -08003307 Hwc2::Composer::DisplayBrightnessOptions{
3308 .applyImmediately = true})
3309 .get();
3310
3311 ALOGE_IF(error != NO_ERROR,
3312 "Error setting display brightness for display %s: %d (%s)",
3313 display->getDebugName().c_str(), error, strerror(error));
3314 }
3315 display->persistBrightness(needsComposite);
3316 }
3317 }
3318}
3319
Vishnu Nair03ccbd62021-12-01 17:21:16 -08003320void SurfaceFlinger::buildWindowInfos(std::vector<WindowInfo>& outWindowInfos,
3321 std::vector<DisplayInfo>& outDisplayInfos) {
Dominik Laskowski9f410f02022-01-08 16:22:46 -08003322 ftl::SmallMap<ui::LayerStack, DisplayDevice::InputInfo, 4> displayInputInfos;
3323
Dominik Laskowski298b08e2022-02-15 13:45:02 -08003324 for (const auto& [_, display] : FTL_FAKE_GUARD(mStateLock, mDisplays)) {
Dominik Laskowski9f410f02022-01-08 16:22:46 -08003325 const auto layerStack = display->getLayerStack();
3326 const auto info = display->getInputInfo();
3327
3328 const auto [it, emplaced] = displayInputInfos.try_emplace(layerStack, info);
Prabir Pradhand0aba782021-12-14 00:44:21 -08003329 if (emplaced) {
Prabir Pradhan8b89c2f2021-07-29 16:30:14 +00003330 continue;
3331 }
Prabir Pradhand0aba782021-12-14 00:44:21 -08003332
Dominik Laskowski9f410f02022-01-08 16:22:46 -08003333 // If the layer stack is mirrored on multiple displays, the first display that is configured
3334 // to receive input takes precedence.
3335 auto& otherInfo = it->second;
3336 if (otherInfo.receivesInput) {
Prabir Pradhan977e7c32022-02-15 04:55:52 -08003337 ALOGW_IF(display->receivesInput(),
3338 "Multiple displays claim to accept input for the same layer stack: %u",
Dominik Laskowski9f410f02022-01-08 16:22:46 -08003339 layerStack.id);
3340 } else {
3341 otherInfo = info;
Prabir Pradhand0aba782021-12-14 00:44:21 -08003342 }
Prabir Pradhan48f8cb92021-08-26 14:05:36 -07003343 }
Robert Carr720e5062018-07-30 17:45:14 -07003344
Dominik Laskowski9f410f02022-01-08 16:22:46 -08003345 static size_t sNumWindowInfos = 0;
3346 outWindowInfos.reserve(sNumWindowInfos);
3347 sNumWindowInfos = 0;
3348
Robert Carr720e5062018-07-30 17:45:14 -07003349 mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
[1;3C2b9fc252021-02-04 16:16:50 -08003350 if (!layer->needsInputInfo()) return;
Dominik Laskowski29fa1462021-04-27 15:51:50 -07003351
Prabir Pradhan83aca382022-07-22 19:53:04 +00003352 const auto opt = displayInputInfos.get(layer->getLayerStack(),
3353 [](const auto& info) -> Layer::InputDisplayArgs {
3354 return {&info.transform, info.isSecure};
3355 });
3356 outWindowInfos.push_back(layer->fillInputInfo(opt.value_or(Layer::InputDisplayArgs{})));
Robert Carr720e5062018-07-30 17:45:14 -07003357 });
Prabir Pradhand0aba782021-12-14 00:44:21 -08003358
Dominik Laskowski9f410f02022-01-08 16:22:46 -08003359 sNumWindowInfos = outWindowInfos.size();
3360
3361 outDisplayInfos.reserve(displayInputInfos.size());
3362 for (const auto& [_, info] : displayInputInfos) {
3363 outDisplayInfos.push_back(info.info);
Prabir Pradhand0aba782021-12-14 00:44:21 -08003364 }
Robert Carr720e5062018-07-30 17:45:14 -07003365}
3366
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07003367void SurfaceFlinger::updateCursorAsync() {
Lloyd Piquec7b0c752019-03-07 20:59:59 -08003368 compositionengine::CompositionRefreshArgs refreshArgs;
Dominik Laskowski298b08e2022-02-15 13:45:02 -08003369 for (const auto& [_, display] : FTL_FAKE_GUARD(mStateLock, mDisplays)) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02003370 if (HalDisplayId::tryCast(display->getId())) {
Lloyd Piquec7b0c752019-03-07 20:59:59 -08003371 refreshArgs.outputs.push_back(display->getCompositionDisplay());
Riley Andrews03414a12014-07-01 14:22:59 -07003372 }
3373 }
Lloyd Piquec7b0c752019-03-07 20:59:59 -08003374
3375 mCompositionEngine->updateCursorAsync(refreshArgs);
Mathias Agopian4fec8732012-06-29 14:12:52 -07003376}
3377
Dominik Laskowskib0054a22022-03-03 09:03:06 -08003378void SurfaceFlinger::requestDisplayMode(DisplayModePtr mode, DisplayModeEvent event) {
Ady Abraham8a82ba62020-01-17 12:43:17 -08003379 // If this is called from the main thread mStateLock must be locked before
3380 // Currently the only way to call this function from the main thread is from
Ady Abraham62a0be22020-12-08 16:54:10 -08003381 // Scheduler::chooseRefreshRateForContent
Ady Abraham8a82ba62020-01-17 12:43:17 -08003382
3383 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
Marin Shalamanova63f9ae2021-11-03 15:05:16 +01003384
3385 const auto display = getDefaultDisplayDeviceLocked();
3386 if (!display || mBootStage != BootStage::FINISHED) {
3387 return;
3388 }
3389 ATRACE_CALL();
3390
Dominik Laskowski76742842022-12-02 14:56:05 -05003391 if (display->isInternal() && !isDisplayActiveLocked(display)) {
3392 ALOGV("%s(%s): Inactive display", __func__, to_string(display->getId()).c_str());
3393 return;
3394 }
3395
Dominik Laskowskib0054a22022-03-03 09:03:06 -08003396 if (!display->refreshRateConfigs().isModeAllowed(mode->getId())) {
Dominik Laskowski76742842022-12-02 14:56:05 -05003397 ALOGV("%s(%s): Disallowed mode %d", __func__, to_string(display->getId()).c_str(),
3398 mode->getId().value());
Marin Shalamanova63f9ae2021-11-03 15:05:16 +01003399 return;
3400 }
3401
Dominik Laskowskib0054a22022-03-03 09:03:06 -08003402 setDesiredActiveMode({std::move(mode), event});
Ady Abraham2139f732019-11-13 18:56:40 -08003403}
3404
Ady Abraham62a0be22020-12-08 16:54:10 -08003405void SurfaceFlinger::triggerOnFrameRateOverridesChanged() {
3406 PhysicalDisplayId displayId = [&]() {
3407 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
3408 return getDefaultDisplayDeviceLocked()->getPhysicalId();
3409 }();
3410
3411 mScheduler->onFrameRateOverridesChanged(mAppConnectionHandle, displayId);
3412}
3413
Ady Abraham3efa3942021-06-24 19:01:25 -07003414void SurfaceFlinger::initScheduler(const sp<DisplayDevice>& display) {
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003415 if (mScheduler) {
Ady Abrahamac2bf482021-07-20 10:59:51 -07003416 // If the scheduler is already initialized, this means that we received
3417 // a hotplug(connected) on the primary display. In that case we should
3418 // update the scheduler with the most recent display information.
3419 ALOGW("Scheduler already initialized, updating instead");
3420 mScheduler->setRefreshRateConfigs(display->holdRefreshRateConfigs());
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003421 return;
3422 }
Ady Abraham3efa3942021-06-24 19:01:25 -07003423 const auto currRefreshRate = display->getActiveMode()->getFps();
Marin Shalamanova903d032020-12-29 20:35:13 +01003424 mRefreshRateStats = std::make_unique<scheduler::RefreshRateStats>(*mTimeStats, currRefreshRate,
3425 hal::PowerMode::OFF);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003426
Marin Shalamanova903d032020-12-29 20:35:13 +01003427 mVsyncConfiguration = getFactory().createVsyncConfiguration(currRefreshRate);
Ady Abraham23ea9da2021-07-14 16:32:56 -07003428 mVsyncModulator = sp<VsyncModulator>::make(mVsyncConfiguration->getCurrentConfigs());
Ady Abraham9e16a482019-12-03 17:19:41 -08003429
Dominik Laskowski068173d2021-08-11 17:22:59 -07003430 using Feature = scheduler::Feature;
3431 scheduler::FeatureFlags features;
Dominik Laskowski9c93d602021-10-07 19:38:26 -07003432
Dominik Laskowski068173d2021-08-11 17:22:59 -07003433 if (sysprop::use_content_detection_for_refresh_rate(false)) {
3434 features |= Feature::kContentDetection;
3435 }
3436 if (base::GetBoolProperty("debug.sf.show_predicted_vsync"s, false)) {
3437 features |= Feature::kTracePredictedVsync;
3438 }
3439 if (!base::GetBoolProperty("debug.sf.vsync_reactor_ignore_present_fences"s, false) &&
Ady Abrahamde549d42022-01-26 19:19:17 -08003440 !getHwComposer().hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
Dominik Laskowski068173d2021-08-11 17:22:59 -07003441 features |= Feature::kPresentFences;
Dominik Laskowski9c93d602021-10-07 19:38:26 -07003442 }
3443
Dominik Laskowski068173d2021-08-11 17:22:59 -07003444 mScheduler = std::make_unique<scheduler::Scheduler>(static_cast<ICompositor&>(*this),
3445 static_cast<ISchedulerCallback&>(*this),
3446 features);
3447 {
3448 auto configs = display->holdRefreshRateConfigs();
ramindani32cf0602022-03-02 02:30:29 +00003449 if (configs->kernelIdleTimerController().has_value()) {
Dominik Laskowski068173d2021-08-11 17:22:59 -07003450 features |= Feature::kKernelIdleTimer;
3451 }
3452
3453 mScheduler->createVsyncSchedule(features);
3454 mScheduler->setRefreshRateConfigs(std::move(configs));
3455 }
Dominik Laskowski9c93d602021-10-07 19:38:26 -07003456 setVsyncEnabled(false);
3457 mScheduler->startTimers();
3458
Ady Abraham9c53ee72020-07-22 21:16:18 -07003459 const auto configs = mVsyncConfiguration->getCurrentConfigs();
Marin Shalamanova903d032020-12-29 20:35:13 +01003460 const nsecs_t vsyncPeriod = currRefreshRate.getPeriodNsecs();
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003461 mAppConnectionHandle =
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -07003462 mScheduler->createConnection("app", mFrameTimeline->getTokenManager(),
Ady Abraham9c53ee72020-07-22 21:16:18 -07003463 /*workDuration=*/configs.late.appWorkDuration,
3464 /*readyDuration=*/configs.late.sfWorkDuration,
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003465 impl::EventThread::InterceptVSyncsCallback());
3466 mSfConnectionHandle =
Ady Abraham55fa7272020-09-30 19:19:27 -07003467 mScheduler->createConnection("appSf", mFrameTimeline->getTokenManager(),
3468 /*workDuration=*/std::chrono::nanoseconds(vsyncPeriod),
3469 /*readyDuration=*/configs.late.sfWorkDuration,
3470 [this](nsecs_t timestamp) {
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003471 mInterceptor->saveVSyncEvent(timestamp);
3472 });
3473
Dominik Laskowski756b7892021-08-04 12:53:59 -07003474 mScheduler->initVsync(mScheduler->getVsyncDispatch(), *mFrameTimeline->getTokenManager(),
3475 configs.late.sfWorkDuration);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003476
3477 mRegionSamplingThread =
Ady Abraham562c2712021-05-07 15:10:42 -07003478 new RegionSamplingThread(*this, RegionSamplingThread::EnvironmentTimingTunables());
Alec Mouria9a68a62021-03-04 19:14:50 -08003479 mFpsReporter = new FpsReporter(*mFrameTimeline, *this);
Marin Shalamanova7fe3042021-01-29 21:02:08 +01003480 // Dispatch a mode change request for the primary display on scheduler
Alec Mouri60aee1c2019-10-28 16:18:59 -07003481 // initialization, so that the EventThreads always contain a reference to a
3482 // prior configuration.
3483 //
3484 // This is a bit hacky, but this avoids a back-pointer into the main SF
3485 // classes from EventThread, and there should be no run-time binder cost
3486 // anyway since there are no connected apps at this point.
Ady Abraham690f4612021-07-01 23:24:03 -07003487 mScheduler->onPrimaryDisplayModeChanged(mAppConnectionHandle, display->getActiveMode());
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003488}
3489
Marin Shalamanov5801c942020-12-17 17:00:13 +01003490void SurfaceFlinger::updatePhaseConfiguration(const Fps& refreshRate) {
3491 mVsyncConfiguration->setRefreshRateFps(refreshRate);
Ady Abraham55fa7272020-09-30 19:19:27 -07003492 setVsyncConfig(mVsyncModulator->setVsyncConfigSet(mVsyncConfiguration->getCurrentConfigs()),
Marin Shalamanov5801c942020-12-17 17:00:13 +01003493 refreshRate.getPeriodNsecs());
Dominik Laskowski08d05c22020-07-22 00:05:08 -07003494}
3495
Ady Abraham55fa7272020-09-30 19:19:27 -07003496void SurfaceFlinger::setVsyncConfig(const VsyncModulator::VsyncConfig& config,
3497 nsecs_t vsyncPeriod) {
Ady Abraham9c53ee72020-07-22 21:16:18 -07003498 mScheduler->setDuration(mAppConnectionHandle,
3499 /*workDuration=*/config.appWorkDuration,
3500 /*readyDuration=*/config.sfWorkDuration);
3501 mScheduler->setDuration(mSfConnectionHandle,
Ady Abraham55fa7272020-09-30 19:19:27 -07003502 /*workDuration=*/std::chrono::nanoseconds(vsyncPeriod),
3503 /*readyDuration=*/config.sfWorkDuration);
Dominik Laskowski756b7892021-08-04 12:53:59 -07003504 mScheduler->setDuration(config.sfWorkDuration);
Dominik Laskowski08d05c22020-07-22 00:05:08 -07003505}
3506
Dominik Laskowski9e168db2021-05-27 16:05:12 -07003507void SurfaceFlinger::doCommitTransactions() {
Robert Carr6a160312021-05-17 12:08:20 -07003508 ATRACE_CALL();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003509
Lloyd Pique58e24a32019-08-01 15:50:14 -07003510 if (!mLayersPendingRemoval.isEmpty()) {
3511 // Notify removed layers now that they can't be drawn from
3512 for (const auto& l : mLayersPendingRemoval) {
Lloyd Pique58e24a32019-08-01 15:50:14 -07003513 // Ensure any buffers set to display on any children are released.
3514 if (l->isRemovedFromCurrentState()) {
3515 l->latchAndReleaseBuffer();
3516 }
3517
chaviw6852bff2022-04-19 17:35:11 -05003518 // If a layer has a parent, we allow it to out-live it's handle
3519 // with the idea that the parent holds a reference and will eventually
3520 // be cleaned up. However no one cleans up the top-level so we do so
3521 // here.
3522 if (l->isAtRoot()) {
3523 l->setIsAtRoot(false);
3524 mCurrentState.layersSortedByZ.remove(l);
3525 }
3526
Lloyd Pique58e24a32019-08-01 15:50:14 -07003527 // If the layer has been removed and has no parent, then it will not be reachable
3528 // when traversing layers on screen. Add the layer to the offscreenLayers set to
3529 // ensure we can copy its current to drawing state.
3530 if (!l->getParent()) {
3531 mOffscreenLayers.emplace(l.get());
3532 }
3533 }
3534 mLayersPendingRemoval.clear();
3535 }
3536
3537 // If this transaction is part of a window animation then the next frame
3538 // we composite should be considered an animation as well.
3539 mAnimCompositionPending = mAnimTransactionPending;
3540
3541 mDrawingState = mCurrentState;
3542 // clear the "changed" flags in current state
3543 mCurrentState.colorMatrixChanged = false;
3544
Robert Carra70e91c2021-06-11 13:59:52 -07003545 if (mVisibleRegionsDirty) {
3546 for (const auto& rootLayer : mDrawingState.layersSortedByZ) {
3547 rootLayer->commitChildList();
3548 }
Andrei Stanciudadac5a2020-08-05 17:02:34 +03003549 }
Robert Carra70e91c2021-06-11 13:59:52 -07003550
Lloyd Pique58e24a32019-08-01 15:50:14 -07003551 commitOffscreenLayers();
Robert Carr6a0382d2021-07-01 15:57:17 -07003552 if (mNumClones > 0) {
3553 mDrawingState.traverse([&](Layer* layer) { layer->updateMirrorInfo(); });
3554 }
Lloyd Pique58e24a32019-08-01 15:50:14 -07003555}
3556
chaviw74d90ad2019-04-26 14:45:26 -07003557void SurfaceFlinger::commitOffscreenLayers() {
3558 for (Layer* offscreenLayer : mOffscreenLayers) {
Edgar Arriaga844fa672020-01-16 14:21:42 -08003559 offscreenLayer->traverse(LayerVector::StateSet::Drawing, [](Layer* layer) {
Dominik Laskowski9e168db2021-05-27 16:05:12 -07003560 if (layer->clearTransactionFlags(eTransactionNeeded)) {
3561 layer->doTransaction(0);
3562 layer->commitChildList();
3563 }
chaviw74d90ad2019-04-26 14:45:26 -07003564 });
3565 }
3566}
3567
Chia-I Wuab0c3192017-08-01 11:29:00 -07003568void SurfaceFlinger::invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty) {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08003569 for (const auto& [token, displayDevice] : FTL_FAKE_GUARD(mStateLock, mDisplays)) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003570 auto display = displayDevice->getCompositionDisplay();
Dominik Laskowski29fa1462021-04-27 15:51:50 -07003571 if (display->includesLayer(layer->getOutputFilter())) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003572 display->editState().dirtyRegion.orSelf(dirty);
Mathias Agopian92a979a2012-08-02 18:32:23 -07003573 }
3574 }
Mathias Agopian87baae12012-07-31 12:38:26 -07003575}
3576
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07003577bool SurfaceFlinger::latchBuffers() {
Ady Abraham09bd3922019-04-08 10:44:56 -07003578 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08003579
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07003580 const nsecs_t latchTime = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003581
Mathias Agopian4fec8732012-06-29 14:12:52 -07003582 bool visibleRegions = false;
Dan Stoza6b9454d2014-11-07 16:00:59 -08003583 bool frameQueued = false;
Mike Stroyan0cd76192017-04-20 12:10:48 -06003584 bool newDataLatched = false;
Eric Penner51c59cd2014-07-28 19:51:58 -07003585
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003586 const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
3587
Eric Penner51c59cd2014-07-28 19:51:58 -07003588 // Store the set of layers that need updates. This set must not change as
3589 // buffers are being latched, as this could result in a deadlock.
3590 // Example: Two producers share the same command stream and:
3591 // 1.) Layer 0 is latched
3592 // 2.) Layer 0 gets a new frame
3593 // 2.) Layer 1 gets a new frame
3594 // 3.) Layer 1 is latched.
3595 // Display is now waiting on Layer 1's frame, which is behind layer 0's
3596 // second frame. But layer 0's second frame could be waiting on display.
Edgar Arriaga844fa672020-01-16 14:21:42 -08003597 mDrawingState.traverse([&](Layer* layer) {
Dominik Laskowski9e168db2021-05-27 16:05:12 -07003598 if (layer->clearTransactionFlags(eTransactionNeeded) || mForceTransactionDisplayChange) {
3599 const uint32_t flags = layer->doTransaction(0);
3600 if (flags & Layer::eVisibleRegion) {
3601 mVisibleRegionsDirty = true;
3602 }
3603 }
Robert Carrb552ff52021-06-11 13:35:54 -07003604
Dominik Laskowski9e168db2021-05-27 16:05:12 -07003605 if (layer->hasReadyFrame()) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08003606 frameQueued = true;
Ana Krulec010d2192018-10-08 06:29:54 -07003607 if (layer->shouldPresentNow(expectedPresentTime)) {
Alec Mouri5c9c9602020-09-01 15:10:40 -07003608 mLayersWithQueuedFrames.emplace(layer);
Dan Stozaee44edd2015-03-23 15:50:23 -07003609 } else {
Ady Abraham09bd3922019-04-08 10:44:56 -07003610 ATRACE_NAME("!layer->shouldPresentNow()");
Dan Stozaee44edd2015-03-23 15:50:23 -07003611 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08003612 }
Dominik Laskowski9e168db2021-05-27 16:05:12 -07003613 } else {
Dan Stozaee44edd2015-03-23 15:50:23 -07003614 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08003615 }
Robert Carr2047fae2016-11-28 14:09:09 -08003616 });
Robert Carrb552ff52021-06-11 13:35:54 -07003617 mForceTransactionDisplayChange = false;
Robert Carr2047fae2016-11-28 14:09:09 -08003618
chaviw49a108c2019-08-12 11:23:06 -07003619 // The client can continue submitting buffers for offscreen layers, but they will not
3620 // be shown on screen. Therefore, we need to latch and release buffers of offscreen
3621 // layers to ensure dequeueBuffer doesn't block indefinitely.
3622 for (Layer* offscreenLayer : mOffscreenLayers) {
Edgar Arriaga844fa672020-01-16 14:21:42 -08003623 offscreenLayer->traverse(LayerVector::StateSet::Drawing,
chaviw49a108c2019-08-12 11:23:06 -07003624 [&](Layer* l) { l->latchAndReleaseBuffer(); });
3625 }
3626
Lloyd Piquef2c79392018-12-20 16:23:33 -08003627 if (!mLayersWithQueuedFrames.empty()) {
3628 // mStateLock is needed for latchBuffer as LayerRejecter::reject()
3629 // writes to Layer current state. See also b/119481871
3630 Mutex::Autolock lock(mStateLock);
3631
Alec Mouri2f7d9ae2020-11-30 19:32:33 -08003632 for (const auto& layer : mLayersWithQueuedFrames) {
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003633 if (layer->latchBuffer(visibleRegions, latchTime, expectedPresentTime)) {
Vishnu Nair6194e2e2019-02-06 12:58:39 -08003634 mLayersPendingRefresh.push_back(layer);
Lloyd Piquef2c79392018-12-20 16:23:33 -08003635 newDataLatched = true;
3636 }
Vishnu Nair1b700192022-02-04 10:09:47 -08003637 layer->useSurfaceDamage();
Mike Stroyan0cd76192017-04-20 12:10:48 -06003638 }
Mathias Agopian4fec8732012-06-29 14:12:52 -07003639 }
Mathias Agopian4da75192010-08-10 17:19:56 -07003640
Mathias Agopian3b1d2b62012-07-11 13:48:17 -07003641 mVisibleRegionsDirty |= visibleRegions;
Dan Stoza6b9454d2014-11-07 16:00:59 -08003642
3643 // If we will need to wake up at some time in the future to deal with a
3644 // queued frame that shouldn't be displayed during this vsync period, wake
3645 // up during the next vsync period to check again.
Chia-I Wua36bf922017-06-30 12:51:05 -07003646 if (frameQueued && (mLayersWithQueuedFrames.empty() || !newDataLatched)) {
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07003647 scheduleCommit(FrameHint::kNone);
Dan Stoza6b9454d2014-11-07 16:00:59 -08003648 }
3649
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08003650 // enter boot animation on first buffer latch
3651 if (CC_UNLIKELY(mBootStage == BootStage::BOOTLOADER && newDataLatched)) {
3652 ALOGI("Enter boot animation");
3653 mBootStage = BootStage::BOOTANIMATION;
3654 }
3655
Robert Carr6a0382d2021-07-01 15:57:17 -07003656 if (mNumClones > 0) {
3657 mDrawingState.traverse([&](Layer* layer) { layer->updateCloneBufferInfo(); });
3658 }
chaviw74b03172019-08-19 11:09:03 -07003659
Dan Stoza6b9454d2014-11-07 16:00:59 -08003660 // Only continue with the refresh if there is actually new work to do
Mike Stroyan0cd76192017-04-20 12:10:48 -06003661 return !mLayersWithQueuedFrames.empty() && newDataLatched;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003662}
3663
Robert Carrc0df3122019-04-11 13:18:21 -07003664status_t SurfaceFlinger::addClientLayer(const sp<Client>& client, const sp<IBinder>& handle,
Vishnu Nair0fc7af52022-01-13 08:11:34 -08003665 const sp<Layer>& layer, const wp<Layer>& parent,
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08003666 bool addToRoot, uint32_t* outTransformHint) {
arthurhungdba591c2021-02-08 17:28:49 +08003667 if (mNumLayers >= ISurfaceComposer::MAX_LAYERS) {
3668 ALOGE("AddClientLayer failed, mNumLayers (%zu) >= MAX_LAYERS (%zu)", mNumLayers.load(),
3669 ISurfaceComposer::MAX_LAYERS);
Robert Carr26b98f42022-04-11 15:54:31 -07003670 static_cast<void>(mScheduler->schedule([=] {
3671 ALOGE("Dumping random sampling of on-screen layers: ");
3672 mDrawingState.traverse([&](Layer *layer) {
3673 // Aim to dump about 200 layers to avoid totally trashing
3674 // logcat. On the other hand, if there really are 4096 layers
3675 // something has gone totally wrong its probably the most
3676 // useful information in logcat.
3677 if (rand() % 20 == 13) {
3678 ALOGE("Layer: %s", layer->getName().c_str());
3679 }
3680 });
3681 for (Layer* offscreenLayer : mOffscreenLayers) {
3682 if (rand() % 20 == 13) {
3683 ALOGE("Offscreen-layer: %s", offscreenLayer->getName().c_str());
3684 }
3685 }
3686 }));
arthurhungdba591c2021-02-08 17:28:49 +08003687 return NO_MEMORY;
Dan Stoza7d89d062015-04-30 13:29:25 -07003688 }
3689
Vishnu Nair0fc7af52022-01-13 08:11:34 -08003690 {
3691 std::scoped_lock<std::mutex> lock(mCreatedLayersLock);
3692 mCreatedLayers.emplace_back(layer, parent, addToRoot);
3693 }
arthurhungdba591c2021-02-08 17:28:49 +08003694
Vishnu Nair0fc7af52022-01-13 08:11:34 -08003695 layer->updateTransformHint(mActiveDisplayTransformHint);
arthurhungdba591c2021-02-08 17:28:49 +08003696 if (outTransformHint) {
Ady Abraham1273ac12021-08-26 17:31:53 -07003697 *outTransformHint = mActiveDisplayTransformHint;
arthurhungdba591c2021-02-08 17:28:49 +08003698 }
Mathias Agopian96f08192010-06-02 23:28:45 -07003699 // attach this layer to the client
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08003700 if (client != nullptr) {
Vishnu Nair0fc7af52022-01-13 08:11:34 -08003701 client->attachLayer(handle, layer);
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08003702 }
Mathias Agopian4f113742011-05-03 16:21:41 -07003703
Vishnu Nair0fc7af52022-01-13 08:11:34 -08003704 setTransactionFlags(eTransactionNeeded);
3705 return NO_ERROR;
Mathias Agopian96f08192010-06-02 23:28:45 -07003706}
3707
Dominik Laskowski9e168db2021-05-27 16:05:12 -07003708uint32_t SurfaceFlinger::getTransactionFlags() const {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003709 return mTransactionFlags;
Mathias Agopiandea20b12011-05-03 17:04:02 -07003710}
3711
Dominik Laskowski9e168db2021-05-27 16:05:12 -07003712uint32_t SurfaceFlinger::clearTransactionFlags(uint32_t mask) {
3713 return mTransactionFlags.fetch_and(~mask) & mask;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003714}
3715
Dominik Laskowski94000c42022-03-17 12:55:14 -07003716void SurfaceFlinger::setTransactionFlags(uint32_t mask, TransactionSchedule schedule,
Dominik Laskowski1f6fc702022-03-21 08:34:50 -07003717 const sp<IBinder>& applyToken, FrameHint frameHint) {
Dominik Laskowski9e168db2021-05-27 16:05:12 -07003718 modulateVsync(&VsyncModulator::setTransactionSchedule, schedule, applyToken);
Dominik Laskowski94000c42022-03-17 12:55:14 -07003719
3720 if (const bool scheduled = mTransactionFlags.fetch_or(mask) & mask; !scheduled) {
Dominik Laskowski1f6fc702022-03-21 08:34:50 -07003721 scheduleCommit(frameHint);
Dominik Laskowski94000c42022-03-17 12:55:14 -07003722 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003723}
3724
Ady Abraham9dada822022-02-03 10:26:59 -08003725bool SurfaceFlinger::stopTransactionProcessing(
3726 const std::unordered_set<sp<IBinder>, SpHash<IBinder>>&
3727 applyTokensWithUnsignaledTransactions) const {
3728 if (enableLatchUnsignaledConfig == LatchUnsignaledConfig::AutoSingleLayer) {
3729 // if we are in LatchUnsignaledConfig::AutoSingleLayer
3730 // then we should have only one applyToken for processing.
3731 // so we can stop further transactions on this applyToken.
3732 return !applyTokensWithUnsignaledTransactions.empty();
3733 }
3734
3735 return false;
3736}
3737
ramindani9eff2492022-03-23 00:28:26 +00003738int SurfaceFlinger::flushUnsignaledPendingTransactionQueues(
3739 std::vector<TransactionState>& transactions,
3740 std::unordered_map<sp<IBinder>, uint64_t, SpHash<IBinder>>& bufferLayersReadyToPresent,
3741 std::unordered_set<sp<IBinder>, SpHash<IBinder>>& applyTokensWithUnsignaledTransactions) {
3742 return flushPendingTransactionQueues(transactions, bufferLayersReadyToPresent,
3743 applyTokensWithUnsignaledTransactions,
3744 /*tryApplyUnsignaled*/ true);
3745}
3746
Robert Carr79dc06a2022-02-22 15:28:59 -08003747int SurfaceFlinger::flushPendingTransactionQueues(
Ady Abrahame1bfaac2022-02-22 21:32:08 -08003748 std::vector<TransactionState>& transactions,
Robert Carr79dc06a2022-02-22 15:28:59 -08003749 std::unordered_map<sp<IBinder>, uint64_t, SpHash<IBinder>>& bufferLayersReadyToPresent,
Ady Abrahame1bfaac2022-02-22 21:32:08 -08003750 std::unordered_set<sp<IBinder>, SpHash<IBinder>>& applyTokensWithUnsignaledTransactions,
3751 bool tryApplyUnsignaled) {
Robert Carr79dc06a2022-02-22 15:28:59 -08003752 int transactionsPendingBarrier = 0;
Ady Abrahame1bfaac2022-02-22 21:32:08 -08003753 auto it = mPendingTransactionQueues.begin();
3754 while (it != mPendingTransactionQueues.end()) {
3755 auto& [applyToken, transactionQueue] = *it;
3756 while (!transactionQueue.empty()) {
3757 if (stopTransactionProcessing(applyTokensWithUnsignaledTransactions)) {
3758 ATRACE_NAME("stopTransactionProcessing");
3759 break;
3760 }
3761
3762 auto& transaction = transactionQueue.front();
3763 const auto ready =
Robert Carr4c1b6462021-12-21 10:30:50 -08003764 transactionIsReadyToBeApplied(transaction,
3765 transaction.frameTimelineInfo,
3766 transaction.isAutoTimestamp,
3767 transaction.desiredPresentTime,
3768 transaction.originUid, transaction.states,
3769 bufferLayersReadyToPresent, transactions.size(),
3770 tryApplyUnsignaled);
Ady Abrahame1bfaac2022-02-22 21:32:08 -08003771 ATRACE_INT("TransactionReadiness", static_cast<int>(ready));
3772 if (ready == TransactionReadiness::NotReady) {
3773 setTransactionFlags(eTransactionFlushNeeded);
3774 break;
3775 }
Robert Carr79dc06a2022-02-22 15:28:59 -08003776 if (ready == TransactionReadiness::NotReadyBarrier) {
3777 transactionsPendingBarrier++;
3778 setTransactionFlags(eTransactionFlushNeeded);
3779 break;
3780 }
Ady Abrahame1bfaac2022-02-22 21:32:08 -08003781 transaction.traverseStatesWithBuffers([&](const layer_state_t& state) {
Xiang Wang76236e12022-03-22 17:25:30 +00003782 const bool frameNumberChanged = state.bufferData->flags.test(
3783 BufferData::BufferDataChange::frameNumberChanged);
Robert Carr79dc06a2022-02-22 15:28:59 -08003784 if (frameNumberChanged) {
3785 bufferLayersReadyToPresent[state.surface] = state.bufferData->frameNumber;
3786 } else {
3787 // Barrier function only used for BBQ which always includes a frame number
3788 bufferLayersReadyToPresent[state.surface] =
3789 std::numeric_limits<uint64_t>::max();
3790 }
Ady Abrahame1bfaac2022-02-22 21:32:08 -08003791 });
3792 const bool appliedUnsignaled = (ready == TransactionReadiness::ReadyUnsignaled);
3793 if (appliedUnsignaled) {
3794 applyTokensWithUnsignaledTransactions.insert(transaction.applyToken);
3795 }
3796
3797 transactions.emplace_back(std::move(transaction));
3798 transactionQueue.pop();
3799 }
3800
3801 if (transactionQueue.empty()) {
3802 it = mPendingTransactionQueues.erase(it);
3803 mTransactionQueueCV.broadcast();
3804 } else {
3805 it = std::next(it, 1);
3806 }
3807 }
Robert Carr79dc06a2022-02-22 15:28:59 -08003808 return transactionsPendingBarrier;
Ady Abrahame1bfaac2022-02-22 21:32:08 -08003809}
3810
Vishnu Nair7891e962021-11-11 12:07:21 -08003811bool SurfaceFlinger::flushTransactionQueues(int64_t vsyncId) {
Valerie Haufce31b82019-04-30 16:41:14 -07003812 // to prevent onHandleDestroyed from being called while the lock is held,
3813 // we must keep a copy of the transactions (specifically the composer
3814 // states) around outside the scope of the lock
ramindani4d48f902021-09-20 21:07:45 +00003815 std::vector<TransactionState> transactions;
Vishnu Nair12f62a02021-02-03 16:23:16 -08003816 // Layer handles that have transactions with buffers that are ready to be applied.
Robert Carr79dc06a2022-02-22 15:28:59 -08003817 std::unordered_map<sp<IBinder>, uint64_t, SpHash<IBinder>> bufferLayersReadyToPresent;
Ady Abraham9dada822022-02-03 10:26:59 -08003818 std::unordered_set<sp<IBinder>, SpHash<IBinder>> applyTokensWithUnsignaledTransactions;
Valerie Haufce31b82019-04-30 16:41:14 -07003819 {
Vishnu Nair12f62a02021-02-03 16:23:16 -08003820 Mutex::Autolock _l(mStateLock);
3821 {
3822 Mutex::Autolock _l(mQueueLock);
Ady Abraham9dada822022-02-03 10:26:59 -08003823
Robert Carr79dc06a2022-02-22 15:28:59 -08003824 int lastTransactionsPendingBarrier = 0;
3825 int transactionsPendingBarrier = 0;
Ady Abrahame1bfaac2022-02-22 21:32:08 -08003826 // First collect transactions from the pending transaction queues.
3827 // We are not allowing unsignaled buffers here as we want to
3828 // collect all the transactions from applyTokens that are ready first.
Robert Carr79dc06a2022-02-22 15:28:59 -08003829 transactionsPendingBarrier =
3830 flushPendingTransactionQueues(transactions, bufferLayersReadyToPresent,
3831 applyTokensWithUnsignaledTransactions, /*tryApplyUnsignaled*/ false);
Ady Abraham9dada822022-02-03 10:26:59 -08003832
Ady Abrahame1bfaac2022-02-22 21:32:08 -08003833 // Second, collect transactions from the transaction queue.
3834 // Here as well we are not allowing unsignaled buffers for the same
3835 // reason as above.
Vishnu Nair12f62a02021-02-03 16:23:16 -08003836 while (!mTransactionQueue.empty()) {
arthurhungf1b7c7b2021-03-03 17:42:23 +08003837 auto& transaction = mTransactionQueue.front();
Ady Abraham9dada822022-02-03 10:26:59 -08003838 const bool pendingTransactions =
3839 mPendingTransactionQueues.find(transaction.applyToken) !=
Vishnu Nair12f62a02021-02-03 16:23:16 -08003840 mPendingTransactionQueues.end();
Ady Abraham9dada822022-02-03 10:26:59 -08003841 const auto ready = [&]() REQUIRES(mStateLock) {
Ady Abrahame1bfaac2022-02-22 21:32:08 -08003842 if (pendingTransactions) {
3843 ATRACE_NAME("pendingTransactions");
Ady Abraham9dada822022-02-03 10:26:59 -08003844 return TransactionReadiness::NotReady;
3845 }
3846
Robert Carr4c1b6462021-12-21 10:30:50 -08003847 return transactionIsReadyToBeApplied(transaction, transaction.frameTimelineInfo,
Ady Abraham9dada822022-02-03 10:26:59 -08003848 transaction.isAutoTimestamp,
3849 transaction.desiredPresentTime,
3850 transaction.originUid, transaction.states,
3851 bufferLayersReadyToPresent,
Ady Abrahame1bfaac2022-02-22 21:32:08 -08003852 transactions.size(),
3853 /*tryApplyUnsignaled*/ false);
Ady Abraham9dada822022-02-03 10:26:59 -08003854 }();
Ady Abraham16f48f12022-02-14 21:54:59 -08003855 ATRACE_INT("TransactionReadiness", static_cast<int>(ready));
Robert Carr79dc06a2022-02-22 15:28:59 -08003856 if (ready != TransactionReadiness::Ready) {
3857 if (ready == TransactionReadiness::NotReadyBarrier) {
3858 transactionsPendingBarrier++;
3859 }
arthurhungf1b7c7b2021-03-03 17:42:23 +08003860 mPendingTransactionQueues[transaction.applyToken].push(std::move(transaction));
Vishnu Nair12f62a02021-02-03 16:23:16 -08003861 } else {
Vishnu Nair83df0342021-03-30 11:50:44 -07003862 transaction.traverseStatesWithBuffers([&](const layer_state_t& state) {
Xiang Wang76236e12022-03-22 17:25:30 +00003863 const bool frameNumberChanged = state.bufferData->flags.test(
3864 BufferData::BufferDataChange::frameNumberChanged);
Robert Carr79dc06a2022-02-22 15:28:59 -08003865 if (frameNumberChanged) {
3866 bufferLayersReadyToPresent[state.surface] = state.bufferData->frameNumber;
3867 } else {
3868 // Barrier function only used for BBQ which always includes a frame number.
3869 // This value only used for barrier logic.
3870 bufferLayersReadyToPresent[state.surface] =
3871 std::numeric_limits<uint64_t>::max();
3872 }
Xiang Wang76236e12022-03-22 17:25:30 +00003873 });
Ady Abraham9dada822022-02-03 10:26:59 -08003874 transactions.emplace_back(std::move(transaction));
Valerie Haufce31b82019-04-30 16:41:14 -07003875 }
ramindani4d48f902021-09-20 21:07:45 +00003876 mTransactionQueue.pop_front();
Ady Abrahame46243a2021-02-23 19:33:49 -08003877 ATRACE_INT("TransactionQueue", mTransactionQueue.size());
Valerie Haufce31b82019-04-30 16:41:14 -07003878 }
Arthur Hung58144272021-01-16 03:43:53 +00003879
Robert Carr79dc06a2022-02-22 15:28:59 -08003880 // Transactions with a buffer pending on a barrier may be on a different applyToken
3881 // than the transaction which satisfies our barrier. In fact this is the exact use case
3882 // that the primitive is designed for. This means we may first process
3883 // the barrier dependent transaction, determine it ineligible to complete
3884 // and then satisfy in a later inner iteration of flushPendingTransactionQueues.
3885 // The barrier dependent transaction was eligible to be presented in this frame
3886 // but we would have prevented it without case. To fix this we continually
3887 // loop through flushPendingTransactionQueues until we perform an iteration
3888 // where the number of transactionsPendingBarrier doesn't change. This way
3889 // we can continue to resolve dependency chains of barriers as far as possible.
3890 while (lastTransactionsPendingBarrier != transactionsPendingBarrier) {
3891 lastTransactionsPendingBarrier = transactionsPendingBarrier;
3892 transactionsPendingBarrier =
3893 flushPendingTransactionQueues(transactions, bufferLayersReadyToPresent,
3894 applyTokensWithUnsignaledTransactions,
3895 /*tryApplyUnsignaled*/ false);
3896 }
3897
Ady Abrahame1bfaac2022-02-22 21:32:08 -08003898 // We collected all transactions that could apply without latching unsignaled buffers.
3899 // If we are allowing latch unsignaled of some form, now it's the time to go over the
3900 // transactions that were not applied and try to apply them unsignaled.
3901 if (enableLatchUnsignaledConfig != LatchUnsignaledConfig::Disabled) {
ramindani9eff2492022-03-23 00:28:26 +00003902 flushUnsignaledPendingTransactionQueues(transactions, bufferLayersReadyToPresent,
3903 applyTokensWithUnsignaledTransactions);
Ady Abrahame1bfaac2022-02-22 21:32:08 -08003904 }
3905
Vishnu Nair7891e962021-11-11 12:07:21 -08003906 return applyTransactions(transactions, vsyncId);
Arthur Hung58144272021-01-16 03:43:53 +00003907 }
ramindani4d48f902021-09-20 21:07:45 +00003908 }
3909}
3910
Vishnu Nair7891e962021-11-11 12:07:21 -08003911bool SurfaceFlinger::applyTransactions(std::vector<TransactionState>& transactions,
3912 int64_t vsyncId) {
ramindani4d48f902021-09-20 21:07:45 +00003913 bool needsTraversal = false;
3914 // Now apply all transactions.
Robert Carrff7663b2022-02-08 12:46:49 -08003915 for (auto& transaction : transactions) {
ramindani4d48f902021-09-20 21:07:45 +00003916 needsTraversal |=
3917 applyTransactionState(transaction.frameTimelineInfo, transaction.states,
3918 transaction.displays, transaction.flags,
3919 transaction.inputWindowCommands,
3920 transaction.desiredPresentTime, transaction.isAutoTimestamp,
3921 transaction.buffer, transaction.postTime,
3922 transaction.permissions, transaction.hasListenerCallbacks,
3923 transaction.listenerCallbacks, transaction.originPid,
3924 transaction.originUid, transaction.id);
3925 if (transaction.transactionCommittedSignal) {
3926 mTransactionCommittedSignals.emplace_back(
3927 std::move(transaction.transactionCommittedSignal));
3928 }
3929 }
Vishnu Nair7891e962021-11-11 12:07:21 -08003930
Dominik Laskowski46471e62022-01-14 15:34:03 -08003931 if (mTransactionTracing) {
3932 mTransactionTracing->addCommittedTransactions(transactions, vsyncId);
Vishnu Nair7891e962021-11-11 12:07:21 -08003933 }
Vishnu Naircd52e2d2021-10-18 08:42:46 -07003934 return needsTraversal;
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003935}
3936
3937bool SurfaceFlinger::transactionFlushNeeded() {
Arthur Hung58144272021-01-16 03:43:53 +00003938 Mutex::Autolock _l(mQueueLock);
Robert Carr79bf8a92021-03-11 16:24:28 -08003939 return !mPendingTransactionQueues.empty() || !mTransactionQueue.empty();
Marissa Wall713b63f2018-10-17 15:42:43 -07003940}
3941
Ady Abraham8db10102021-03-15 17:19:23 -07003942bool SurfaceFlinger::frameIsEarly(nsecs_t expectedPresentTime, int64_t vsyncId) const {
3943 // The amount of time SF can delay a frame if it is considered early based
3944 // on the VsyncModulator::VsyncConfig::appWorkDuration
3945 constexpr static std::chrono::nanoseconds kEarlyLatchMaxThreshold = 100ms;
3946
3947 const auto currentVsyncPeriod = mScheduler->getDisplayStatInfo(systemTime()).vsyncPeriod;
3948 const auto earlyLatchVsyncThreshold = currentVsyncPeriod / 2;
3949
3950 const auto prediction = mFrameTimeline->getTokenManager()->getPredictionsForToken(vsyncId);
3951 if (!prediction.has_value()) {
3952 return false;
3953 }
3954
3955 if (std::abs(prediction->presentTime - expectedPresentTime) >=
3956 kEarlyLatchMaxThreshold.count()) {
3957 return false;
3958 }
3959
3960 return prediction->presentTime >= expectedPresentTime &&
3961 prediction->presentTime - expectedPresentTime >= earlyLatchVsyncThreshold;
3962}
Ady Abraham9dada822022-02-03 10:26:59 -08003963bool SurfaceFlinger::shouldLatchUnsignaled(const sp<Layer>& layer, const layer_state_t& state,
Ady Abraham2739e832022-02-14 17:42:00 -08003964 size_t numStates, size_t totalTXapplied) const {
Ady Abraham9dada822022-02-03 10:26:59 -08003965 if (enableLatchUnsignaledConfig == LatchUnsignaledConfig::Disabled) {
3966 ALOGV("%s: false (LatchUnsignaledConfig::Disabled)", __func__);
3967 return false;
3968 }
Ady Abraham8db10102021-03-15 17:19:23 -07003969
Ady Abraham9dada822022-02-03 10:26:59 -08003970 if (enableLatchUnsignaledConfig == LatchUnsignaledConfig::Always) {
3971 ALOGV("%s: true (LatchUnsignaledConfig::Always)", __func__);
3972 return true;
3973 }
3974
3975 // We only want to latch unsignaled when a single layer is updated in this
3976 // transaction (i.e. not a blast sync transaction).
3977 if (numStates != 1) {
3978 ALOGV("%s: false (numStates=%zu)", __func__, numStates);
3979 return false;
3980 }
3981
Ady Abraham2739e832022-02-14 17:42:00 -08003982 if (enableLatchUnsignaledConfig == LatchUnsignaledConfig::AutoSingleLayer) {
3983 if (totalTXapplied > 0) {
3984 ALOGV("%s: false (LatchUnsignaledConfig::AutoSingleLayer; totalTXapplied=%zu)",
3985 __func__, totalTXapplied);
3986 return false;
3987 }
3988
3989 // We don't want to latch unsignaled if are in early / client composition
3990 // as it leads to jank due to RenderEngine waiting for unsignaled buffer
3991 // or window animations being slow.
3992 const auto isDefaultVsyncConfig = mVsyncModulator->isVsyncConfigDefault();
3993 if (!isDefaultVsyncConfig) {
3994 ALOGV("%s: false (LatchUnsignaledConfig::AutoSingleLayer; !isDefaultVsyncConfig)",
3995 __func__);
3996 return false;
3997 }
Ady Abraham9dada822022-02-03 10:26:59 -08003998 }
3999
4000 if (!layer->simpleBufferUpdate(state)) {
4001 ALOGV("%s: false (!simpleBufferUpdate)", __func__);
4002 return false;
4003 }
4004
4005 ALOGV("%s: true", __func__);
4006 return true;
4007}
4008
Robert Carr4c1b6462021-12-21 10:30:50 -08004009auto SurfaceFlinger::transactionIsReadyToBeApplied(TransactionState& transaction,
Ady Abraham43752eb2021-03-04 16:24:25 -08004010 const FrameTimelineInfo& info, bool isAutoTimestamp, int64_t desiredPresentTime,
Ady Abraham5690bda2021-03-12 15:01:18 -08004011 uid_t originUid, const Vector<ComposerState>& states,
Robert Carr79dc06a2022-02-22 15:28:59 -08004012 const std::unordered_map<
4013 sp<IBinder>, uint64_t, SpHash<IBinder>>& bufferLayersReadyToPresent,
Ady Abrahame1bfaac2022-02-22 21:32:08 -08004014 size_t totalTXapplied, bool tryApplyUnsignaled) const -> TransactionReadiness {
Ady Abraham3bea4252021-11-30 23:18:13 +00004015 ATRACE_FORMAT("transactionIsReadyToBeApplied vsyncId: %" PRId64, info.vsyncId);
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07004016 const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
Marissa Wall17b4e452018-12-26 16:32:34 -08004017 // Do not present if the desiredPresentTime has not passed unless it is more than one second
4018 // in the future. We ignore timestamps more than 1 second in the future for stability reasons.
Vishnu Nairf6eddb62021-01-27 22:02:11 -08004019 if (!isAutoTimestamp && desiredPresentTime >= expectedPresentTime &&
Marissa Wall17b4e452018-12-26 16:32:34 -08004020 desiredPresentTime < expectedPresentTime + s2ns(1)) {
Ady Abraham2f43b202021-03-12 12:34:52 -08004021 ATRACE_NAME("not current");
Ady Abraham9dada822022-02-03 10:26:59 -08004022 return TransactionReadiness::NotReady;
Marissa Wall17b4e452018-12-26 16:32:34 -08004023 }
4024
Ady Abraham5690bda2021-03-12 15:01:18 -08004025 if (!mScheduler->isVsyncValid(expectedPresentTime, originUid)) {
4026 ATRACE_NAME("!isVsyncValid");
Ady Abraham9dada822022-02-03 10:26:59 -08004027 return TransactionReadiness::NotReady;
Ady Abraham5690bda2021-03-12 15:01:18 -08004028 }
4029
Ady Abraham8db10102021-03-15 17:19:23 -07004030 // If the client didn't specify desiredPresentTime, use the vsyncId to determine the expected
4031 // present time of this transaction.
4032 if (isAutoTimestamp && frameIsEarly(expectedPresentTime, info.vsyncId)) {
4033 ATRACE_NAME("frameIsEarly");
Ady Abraham9dada822022-02-03 10:26:59 -08004034 return TransactionReadiness::NotReady;
Ady Abraham8db10102021-03-15 17:19:23 -07004035 }
4036
Ady Abraham9dada822022-02-03 10:26:59 -08004037 bool fenceUnsignaled = false;
Robert Carr4c1b6462021-12-21 10:30:50 -08004038 auto queueProcessTime = systemTime();
Marissa Wall713b63f2018-10-17 15:42:43 -07004039 for (const ComposerState& state : states) {
4040 const layer_state_t& s = state.state;
Robert Carr4c1b6462021-12-21 10:30:50 -08004041
Ady Abrahamf20c1922020-12-21 18:39:01 -08004042 sp<Layer> layer = nullptr;
4043 if (s.surface) {
Vishnu Nairf9096652021-07-20 18:49:42 -07004044 layer = fromHandle(s.surface).promote();
Vishnu Nairddf9b5c2021-03-29 18:53:41 -07004045 } else if (s.hasBufferChanges()) {
Ady Abrahamf20c1922020-12-21 18:39:01 -08004046 ALOGW("Transaction with buffer, but no Layer?");
4047 continue;
4048 }
Vishnu Nairf6eddb62021-01-27 22:02:11 -08004049 if (!layer) {
4050 continue;
4051 }
Ady Abraham43752eb2021-03-04 16:24:25 -08004052
Robert Carr79dc06a2022-02-22 15:28:59 -08004053 if (s.hasBufferChanges() && s.bufferData->hasBarrier &&
4054 ((layer->getDrawingState().frameNumber) < s.bufferData->barrierFrameNumber)) {
4055 const bool willApplyBarrierFrame =
4056 (bufferLayersReadyToPresent.find(s.surface) != bufferLayersReadyToPresent.end()) &&
4057 (bufferLayersReadyToPresent.at(s.surface) >= s.bufferData->barrierFrameNumber);
4058 if (!willApplyBarrierFrame) {
4059 ATRACE_NAME("NotReadyBarrier");
4060 return TransactionReadiness::NotReadyBarrier;
4061 }
4062 }
4063
Ady Abrahame1bfaac2022-02-22 21:32:08 -08004064 const bool allowLatchUnsignaled = tryApplyUnsignaled &&
Ady Abraham9dada822022-02-03 10:26:59 -08004065 shouldLatchUnsignaled(layer, s, states.size(), totalTXapplied);
Ady Abraham16f48f12022-02-14 21:54:59 -08004066 ATRACE_FORMAT("%s allowLatchUnsignaled=%s", layer->getName().c_str(),
4067 allowLatchUnsignaled ? "true" : "false");
Ady Abraham9dada822022-02-03 10:26:59 -08004068
4069 const bool acquireFenceChanged = s.bufferData &&
4070 s.bufferData->flags.test(BufferData::BufferDataChange::fenceChanged) &&
4071 s.bufferData->acquireFence;
4072 fenceUnsignaled = fenceUnsignaled ||
4073 (acquireFenceChanged &&
4074 s.bufferData->acquireFence->getStatus() == Fence::Status::Unsignaled);
4075
4076 if (fenceUnsignaled && !allowLatchUnsignaled) {
Robert Carr4c1b6462021-12-21 10:30:50 -08004077 if (!transaction.sentFenceTimeoutWarning &&
4078 queueProcessTime - transaction.queueTime > std::chrono::nanoseconds(4s).count()) {
4079 transaction.sentFenceTimeoutWarning = true;
4080 auto listener = s.bufferData->releaseBufferListener;
4081 if (listener) {
4082 listener->onTransactionQueueStalled();
4083 }
4084 }
4085
Ady Abraham9dada822022-02-03 10:26:59 -08004086 ATRACE_NAME("fence unsignaled");
4087 return TransactionReadiness::NotReady;
4088 }
4089
Vishnu Nairddf9b5c2021-03-29 18:53:41 -07004090 if (s.hasBufferChanges()) {
Ady Abraham29d16cb2021-03-08 13:19:21 -08004091 // If backpressure is enabled and we already have a buffer to commit, keep the
4092 // transaction in the queue.
Robert Carr79dc06a2022-02-22 15:28:59 -08004093 const bool hasPendingBuffer = bufferLayersReadyToPresent.find(s.surface) !=
4094 bufferLayersReadyToPresent.end();
Ady Abraham29d16cb2021-03-08 13:19:21 -08004095 if (layer->backpressureEnabled() && hasPendingBuffer && isAutoTimestamp) {
Ady Abraham2f43b202021-03-12 12:34:52 -08004096 ATRACE_NAME("hasPendingBuffer");
Ady Abraham9dada822022-02-03 10:26:59 -08004097 return TransactionReadiness::NotReady;
Ady Abraham29d16cb2021-03-08 13:19:21 -08004098 }
Marissa Wall713b63f2018-10-17 15:42:43 -07004099 }
4100 }
Ady Abraham9dada822022-02-03 10:26:59 -08004101 return fenceUnsignaled ? TransactionReadiness::ReadyUnsignaled : TransactionReadiness::Ready;
Marissa Wall713b63f2018-10-17 15:42:43 -07004102}
4103
arthurhungf1b7c7b2021-03-03 17:42:23 +08004104void SurfaceFlinger::queueTransaction(TransactionState& state) {
Robert Carr4c1b6462021-12-21 10:30:50 -08004105 state.queueTime = systemTime();
4106
Dominik Laskowski1f6fc702022-03-21 08:34:50 -07004107 Mutex::Autolock lock(mQueueLock);
Ady Abrahame46243a2021-02-23 19:33:49 -08004108
arthurhungf1b7c7b2021-03-03 17:42:23 +08004109 // Generate a CountDownLatch pending state if this is a synchronous transaction.
4110 if ((state.flags & eSynchronous) || state.inputWindowCommands.syncInputWindows) {
4111 state.transactionCommittedSignal = std::make_shared<CountDownLatch>(
Arthur Hung2274a312021-04-28 15:13:06 +00004112 (state.inputWindowCommands.syncInputWindows
4113 ? (CountDownLatch::eSyncInputWindows | CountDownLatch::eSyncTransaction)
4114 : CountDownLatch::eSyncTransaction));
arthurhungf1b7c7b2021-03-03 17:42:23 +08004115 }
4116
ramindani4d48f902021-09-20 21:07:45 +00004117 mTransactionQueue.emplace_back(state);
Ady Abrahame46243a2021-02-23 19:33:49 -08004118 ATRACE_INT("TransactionQueue", mTransactionQueue.size());
4119
Ady Abrahame46243a2021-02-23 19:33:49 -08004120 const auto schedule = [](uint32_t flags) {
Ady Abraham8cbd3072021-03-15 16:39:06 -07004121 if (flags & eEarlyWakeupEnd) return TransactionSchedule::EarlyEnd;
4122 if (flags & eEarlyWakeupStart) return TransactionSchedule::EarlyStart;
Ady Abrahame46243a2021-02-23 19:33:49 -08004123 return TransactionSchedule::Late;
4124 }(state.flags);
4125
Dominik Laskowski1f6fc702022-03-21 08:34:50 -07004126 const auto frameHint = state.isFrameActive() ? FrameHint::kActive : FrameHint::kNone;
4127
4128 setTransactionFlags(eTransactionFlushNeeded, schedule, state.applyToken, frameHint);
Ady Abrahame46243a2021-02-23 19:33:49 -08004129}
4130
arthurhungf1b7c7b2021-03-03 17:42:23 +08004131void SurfaceFlinger::waitForSynchronousTransaction(
4132 const CountDownLatch& transactionCommittedSignal) {
4133 // applyTransactionState is called on the main SF thread. While a given process may wish
4134 // to wait on synchronous transactions, the main SF thread should apply the transaction and
4135 // set the value to notify this after committed.
Ady Abrahame9ebce02022-02-03 12:05:06 -08004136 if (!transactionCommittedSignal.wait_until(
4137 std::chrono::nanoseconds(mAnimationTransactionTimeout))) {
arthurhungf1b7c7b2021-03-03 17:42:23 +08004138 ALOGE("setTransactionState timed out!");
Ady Abrahame46243a2021-02-23 19:33:49 -08004139 }
arthurhungf1b7c7b2021-03-03 17:42:23 +08004140}
Ady Abrahame46243a2021-02-23 19:33:49 -08004141
Arthur Hung2274a312021-04-28 15:13:06 +00004142void SurfaceFlinger::signalSynchronousTransactions(const uint32_t flag) {
arthurhungf1b7c7b2021-03-03 17:42:23 +08004143 for (auto it = mTransactionCommittedSignals.begin();
4144 it != mTransactionCommittedSignals.end();) {
Arthur Hung2274a312021-04-28 15:13:06 +00004145 if ((*it)->countDown(flag)) {
arthurhungf1b7c7b2021-03-03 17:42:23 +08004146 it = mTransactionCommittedSignals.erase(it);
4147 } else {
4148 it++;
Ady Abrahame46243a2021-02-23 19:33:49 -08004149 }
4150 }
4151}
4152
chaviw308ddba2020-08-11 16:23:51 -07004153status_t SurfaceFlinger::setTransactionState(
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10004154 const FrameTimelineInfo& frameTimelineInfo, const Vector<ComposerState>& states,
Ady Abraham22c7b5c2020-09-22 19:33:40 -07004155 const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
4156 const InputWindowCommands& inputWindowCommands, int64_t desiredPresentTime,
Ady Abrahamf0c56492020-12-17 18:04:15 -08004157 bool isAutoTimestamp, const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
Pablo Gamito7eb7ee72020-08-05 10:57:05 +00004158 const std::vector<ListenerCallbacks>& listenerCallbacks, uint64_t transactionId) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07004159 ATRACE_CALL();
Robert Carr14167e02019-02-13 13:50:55 -08004160
Vishnu Nair24e3bba2021-02-23 14:19:36 -08004161 uint32_t permissions =
Robert Carrde6d7b42022-01-07 18:23:06 -08004162 callingThreadHasUnscopedSurfaceFlingerAccess() ?
4163 layer_state_t::Permission::ACCESS_SURFACE_FLINGER : 0;
Vishnu Nair24e3bba2021-02-23 14:19:36 -08004164 // Avoid checking for rotation permissions if the caller already has ACCESS_SURFACE_FLINGER
4165 // permissions.
Robert Carrde6d7b42022-01-07 18:23:06 -08004166 if ((permissions & layer_state_t::Permission::ACCESS_SURFACE_FLINGER) ||
Vishnu Nair24e3bba2021-02-23 14:19:36 -08004167 callingThreadHasRotateSurfaceFlingerAccess()) {
Robert Carrde6d7b42022-01-07 18:23:06 -08004168 permissions |= layer_state_t::Permission::ROTATE_SURFACE_FLINGER;
Vishnu Nair24e3bba2021-02-23 14:19:36 -08004169 }
4170
Leon Scroggins9a20f722021-12-28 14:43:12 +00004171 if (callingThreadHasInternalSystemWindowAccess()) {
Robert Carrde6d7b42022-01-07 18:23:06 -08004172 permissions |= layer_state_t::Permission::INTERNAL_SYSTEM_WINDOW;
Leon Scroggins9a20f722021-12-28 14:43:12 +00004173 }
4174
Robert Carrde6d7b42022-01-07 18:23:06 -08004175 if (!(permissions & layer_state_t::Permission::ACCESS_SURFACE_FLINGER) &&
Ady Abraham8cbd3072021-03-15 16:39:06 -07004176 (flags & (eEarlyWakeupStart | eEarlyWakeupEnd))) {
4177 ALOGE("Only WindowManager is allowed to use eEarlyWakeup[Start|End] flags");
4178 flags &= ~(eEarlyWakeupStart | eEarlyWakeupEnd);
arthurhungf1b7c7b2021-03-03 17:42:23 +08004179 }
4180
Vishnu Nair24e3bba2021-02-23 14:19:36 -08004181 const int64_t postTime = systemTime();
4182
4183 IPCThreadState* ipc = IPCThreadState::self();
4184 const int originPid = ipc->getCallingPid();
4185 const int originUid = ipc->getCallingUid();
arthurhungf1b7c7b2021-03-03 17:42:23 +08004186 TransactionState state{frameTimelineInfo, states,
4187 displays, flags,
4188 applyToken, inputWindowCommands,
4189 desiredPresentTime, isAutoTimestamp,
4190 uncacheBuffer, postTime,
4191 permissions, hasListenerCallbacks,
4192 listenerCallbacks, originPid,
4193 originUid, transactionId};
Vishnu Nair83df0342021-03-30 11:50:44 -07004194
4195 // Check for incoming buffer updates and increment the pending buffer count.
4196 state.traverseStatesWithBuffers([&](const layer_state_t& state) {
4197 mBufferCountTracker.increment(state.surface->localBinder());
4198 });
Vishnu Nair7891e962021-11-11 12:07:21 -08004199
Dominik Laskowski46471e62022-01-14 15:34:03 -08004200 if (mTransactionTracing) {
4201 mTransactionTracing->addQueuedTransaction(state);
Vishnu Nair7891e962021-11-11 12:07:21 -08004202 }
arthurhungf1b7c7b2021-03-03 17:42:23 +08004203 queueTransaction(state);
Vishnu Nair24e3bba2021-02-23 14:19:36 -08004204
arthurhungf1b7c7b2021-03-03 17:42:23 +08004205 // Check the pending state to make sure the transaction is synchronous.
4206 if (state.transactionCommittedSignal) {
4207 waitForSynchronousTransaction(*state.transactionCommittedSignal);
Arthur Hung58144272021-01-16 03:43:53 +00004208 }
4209
Zhuoyao Zhang3d3540d2021-01-14 05:14:54 +00004210 return NO_ERROR;
4211}
Marissa Wall713b63f2018-10-17 15:42:43 -07004212
Vishnu Naircd52e2d2021-10-18 08:42:46 -07004213bool SurfaceFlinger::applyTransactionState(const FrameTimelineInfo& frameTimelineInfo,
Robert Carrff7663b2022-02-08 12:46:49 -08004214 Vector<ComposerState>& states,
Arthur Hung58144272021-01-16 03:43:53 +00004215 const Vector<DisplayState>& displays, uint32_t flags,
4216 const InputWindowCommands& inputWindowCommands,
4217 const int64_t desiredPresentTime, bool isAutoTimestamp,
4218 const client_cache_t& uncacheBuffer,
Vishnu Nair24e3bba2021-02-23 14:19:36 -08004219 const int64_t postTime, uint32_t permissions,
Arthur Hung58144272021-01-16 03:43:53 +00004220 bool hasListenerCallbacks,
4221 const std::vector<ListenerCallbacks>& listenerCallbacks,
4222 int originPid, int originUid, uint64_t transactionId) {
Zhuoyao Zhang3d3540d2021-01-14 05:14:54 +00004223 uint32_t transactionFlags = 0;
chaviwca27f252018-02-06 16:46:39 -08004224 for (const DisplayState& display : displays) {
4225 transactionFlags |= setDisplayStateLocked(display);
Jamie Gennisb8d69a52011-10-10 15:48:06 -07004226 }
4227
Jiakai Zhanga5505cb2021-11-09 11:46:30 +00004228 // start and end registration for listeners w/ no surface so they can get their callback. Note
4229 // that listeners with SurfaceControls will start registration during setClientStateLocked
4230 // below.
Valerie Hau9dab9732019-08-20 09:29:25 -07004231 for (const auto& listener : listenerCallbacks) {
Jiakai Zhanga5505cb2021-11-09 11:46:30 +00004232 mTransactionCallbackInvoker.addEmptyTransaction(listener);
Marissa Walld600d572019-03-26 15:38:50 -07004233 }
4234
Marissa Walle2ffb422018-10-12 11:33:52 -07004235 uint32_t clientStateFlags = 0;
Robert Carrff7663b2022-02-08 12:46:49 -08004236 for (int i = 0; i < states.size(); i++) {
4237 ComposerState& state = states.editItemAt(i);
4238 clientStateFlags |= setClientStateLocked(frameTimelineInfo, state, desiredPresentTime,
Vishnu Naircd52e2d2021-10-18 08:42:46 -07004239 isAutoTimestamp, postTime, permissions);
Ady Abraham5def7332020-05-29 16:13:47 -07004240 if ((flags & eAnimation) && state.state.surface) {
Dominik Laskowski068173d2021-08-11 17:22:59 -07004241 if (const auto layer = fromHandle(state.state.surface).promote()) {
4242 using LayerUpdateType = scheduler::LayerHistory::LayerUpdateType;
Ady Abrahamf0c56492020-12-17 18:04:15 -08004243 mScheduler->recordLayerHistory(layer.get(),
4244 isAutoTimestamp ? 0 : desiredPresentTime,
Dominik Laskowski068173d2021-08-11 17:22:59 -07004245 LayerUpdateType::AnimationTX);
Ady Abraham5def7332020-05-29 16:13:47 -07004246 }
4247 }
Marissa Wall3dad52d2019-03-22 14:03:19 -07004248 }
4249
Marissa Walle2ffb422018-10-12 11:33:52 -07004250 transactionFlags |= clientStateFlags;
chaviwca27f252018-02-06 16:46:39 -08004251
Robert Carrde6d7b42022-01-07 18:23:06 -08004252 if (permissions & layer_state_t::Permission::ACCESS_SURFACE_FLINGER) {
Vishnu Nair958da932020-08-21 17:12:37 -07004253 transactionFlags |= addInputWindowCommands(inputWindowCommands);
4254 } else if (!inputWindowCommands.empty()) {
4255 ALOGE("Only privileged callers are allowed to send input commands.");
4256 }
chaviw273171b2018-12-26 11:46:30 -08004257
Marissa Wall947d34e2019-03-29 14:03:53 -07004258 if (uncacheBuffer.isValid()) {
4259 ClientCache::getInstance().erase(uncacheBuffer);
Marissa Wall78b72202019-03-15 14:58:34 -07004260 }
4261
Jorim Jaggibdcf09c2017-08-08 15:22:08 +02004262 // If a synchronous transaction is explicitly requested without any changes, force a transaction
4263 // anyway. This can be used as a flush mechanism for previous async transactions.
4264 // Empty animation transaction can be used to simulate back-pressure, so also force a
4265 // transaction for empty animation transactions.
4266 if (transactionFlags == 0 &&
4267 ((flags & eSynchronous) || (flags & eAnimation))) {
Robert Carr2a7dbb42016-05-24 11:41:28 -07004268 transactionFlags = eTransactionNeeded;
4269 }
4270
Vishnu Naircd52e2d2021-10-18 08:42:46 -07004271 bool needsTraversal = false;
Mathias Agopian386aa982011-11-07 21:58:03 -08004272 if (transactionFlags) {
Arthur Hung1bedccb2020-09-24 10:09:25 +00004273 if (mInterceptor->isEnabled()) {
4274 mInterceptor->saveTransaction(states, mCurrentState.displays, displays, flags,
Pablo Gamito7eb7ee72020-08-05 10:57:05 +00004275 originPid, originUid, transactionId);
Arthur Hung1bedccb2020-09-24 10:09:25 +00004276 }
4277
Arthur Hung58144272021-01-16 03:43:53 +00004278 // We are on the main thread, we are about to preform a traversal. Clear the traversal bit
4279 // so we don't have to wake up again next frame to preform an unnecessary traversal.
4280 if (transactionFlags & eTraversalNeeded) {
4281 transactionFlags = transactionFlags & (~eTraversalNeeded);
Vishnu Naircd52e2d2021-10-18 08:42:46 -07004282 needsTraversal = true;
Arthur Hung1bedccb2020-09-24 10:09:25 +00004283 }
Arthur Hung58144272021-01-16 03:43:53 +00004284 if (transactionFlags) {
4285 setTransactionFlags(transactionFlags);
Arthur Hung1bedccb2020-09-24 10:09:25 +00004286 }
4287
Jamie Gennis2d5e2302012-10-15 18:24:43 -07004288 if (flags & eAnimation) {
4289 mAnimTransactionPending = true;
4290 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004291 }
Vishnu Naircd52e2d2021-10-18 08:42:46 -07004292
4293 return needsTraversal;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004294}
4295
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07004296uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s) {
4297 const ssize_t index = mCurrentState.displays.indexOfKey(s.token);
4298 if (index < 0) return 0;
Jesse Hall9a143922012-10-04 16:29:19 -07004299
Mathias Agopiane57f2922012-08-09 16:29:12 -07004300 uint32_t flags = 0;
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07004301 DisplayDeviceState& state = mCurrentState.displays.editValueAt(index);
4302
4303 const uint32_t what = s.what;
4304 if (what & DisplayState::eSurfaceChanged) {
4305 if (IInterface::asBinder(state.surface) != IInterface::asBinder(s.surface)) {
4306 state.surface = s.surface;
4307 flags |= eDisplayTransactionNeeded;
Michael Lentine47e45402014-07-18 15:34:25 -07004308 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07004309 }
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07004310 if (what & DisplayState::eLayerStackChanged) {
4311 if (state.layerStack != s.layerStack) {
4312 state.layerStack = s.layerStack;
4313 flags |= eDisplayTransactionNeeded;
4314 }
4315 }
Evan Rosky2239b372021-05-20 13:43:47 -07004316 if (what & DisplayState::eFlagsChanged) {
4317 if (state.flags != s.flags) {
4318 state.flags = s.flags;
4319 flags |= eDisplayTransactionNeeded;
4320 }
4321 }
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07004322 if (what & DisplayState::eDisplayProjectionChanged) {
4323 if (state.orientation != s.orientation) {
4324 state.orientation = s.orientation;
4325 flags |= eDisplayTransactionNeeded;
4326 }
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02004327 if (state.orientedDisplaySpaceRect != s.orientedDisplaySpaceRect) {
4328 state.orientedDisplaySpaceRect = s.orientedDisplaySpaceRect;
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07004329 flags |= eDisplayTransactionNeeded;
4330 }
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02004331 if (state.layerStackSpaceRect != s.layerStackSpaceRect) {
4332 state.layerStackSpaceRect = s.layerStackSpaceRect;
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07004333 flags |= eDisplayTransactionNeeded;
4334 }
4335 }
4336 if (what & DisplayState::eDisplaySizeChanged) {
4337 if (state.width != s.width) {
4338 state.width = s.width;
4339 flags |= eDisplayTransactionNeeded;
4340 }
4341 if (state.height != s.height) {
4342 state.height = s.height;
4343 flags |= eDisplayTransactionNeeded;
4344 }
4345 }
4346
Mathias Agopiane57f2922012-08-09 16:29:12 -07004347 return flags;
4348}
4349
Steven Thomasd4071902020-03-24 16:02:53 -07004350bool SurfaceFlinger::callingThreadHasUnscopedSurfaceFlingerAccess(bool usePermissionCache) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07004351 IPCThreadState* ipc = IPCThreadState::self();
4352 const int pid = ipc->getCallingPid();
4353 const int uid = ipc->getCallingUid();
Robert Carrd4ae7f32018-06-07 16:10:57 -07004354 if ((uid != AID_GRAPHICS && uid != AID_SYSTEM) &&
Steven Thomasd4071902020-03-24 16:02:53 -07004355 (usePermissionCache ? !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)
4356 : !checkPermission(sAccessSurfaceFlinger, pid, uid))) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07004357 return false;
4358 }
4359 return true;
4360}
4361
Vishnu Naircd52e2d2021-10-18 08:42:46 -07004362uint32_t SurfaceFlinger::setClientStateLocked(const FrameTimelineInfo& frameTimelineInfo,
Robert Carrde6d7b42022-01-07 18:23:06 -08004363 ComposerState& composerState,
Vishnu Naircd52e2d2021-10-18 08:42:46 -07004364 int64_t desiredPresentTime, bool isAutoTimestamp,
4365 int64_t postTime, uint32_t permissions) {
Robert Carrde6d7b42022-01-07 18:23:06 -08004366 layer_state_t& s = composerState.state;
4367 s.sanitize(permissions);
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07004368
4369 std::vector<ListenerCallbacks> filteredListeners;
Valerie Hau9dab9732019-08-20 09:29:25 -07004370 for (auto& listener : s.listeners) {
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07004371 // Starts a registration but separates the callback ids according to callback type. This
4372 // allows the callback invoker to send on latch callbacks earlier.
Valerie Hau9dab9732019-08-20 09:29:25 -07004373 // note that startRegistration will not re-register if the listener has
4374 // already be registered for a prior surface control
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07004375
4376 ListenerCallbacks onCommitCallbacks = listener.filter(CallbackId::Type::ON_COMMIT);
4377 if (!onCommitCallbacks.callbackIds.empty()) {
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07004378 filteredListeners.push_back(onCommitCallbacks);
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07004379 }
4380
4381 ListenerCallbacks onCompleteCallbacks = listener.filter(CallbackId::Type::ON_COMPLETE);
4382 if (!onCompleteCallbacks.callbackIds.empty()) {
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07004383 filteredListeners.push_back(onCompleteCallbacks);
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07004384 }
Valerie Hau9dab9732019-08-20 09:29:25 -07004385 }
4386
arthurhungdba591c2021-02-08 17:28:49 +08004387 const uint64_t what = s.what;
4388 uint32_t flags = 0;
Vishnu Nairdc6f5b92019-12-03 07:33:37 -08004389 sp<Layer> layer = nullptr;
4390 if (s.surface) {
Vishnu Nair0fc7af52022-01-13 08:11:34 -08004391 layer = fromHandle(s.surface).promote();
Vishnu Nairdc6f5b92019-12-03 07:33:37 -08004392 } else {
4393 // The client may provide us a null handle. Treat it as if the layer was removed.
4394 ALOGW("Attempt to set client state with a null layer handle");
4395 }
chaviw8b3871a2017-11-01 17:41:01 -07004396 if (layer == nullptr) {
Valerie Hau9dab9732019-08-20 09:29:25 -07004397 for (auto& [listener, callbackIds] : s.listeners) {
Jiakai Zhanga5505cb2021-11-09 11:46:30 +00004398 mTransactionCallbackInvoker.registerUnpresentedCallbackHandle(
Valerie Hau9dab9732019-08-20 09:29:25 -07004399 new CallbackHandle(listener, callbackIds, s.surface));
Marissa Wall88e20482019-06-24 10:49:42 -07004400 }
chaviw8b3871a2017-11-01 17:41:01 -07004401 return 0;
4402 }
4403
Valerie Hau871d6352020-01-29 08:44:02 -08004404 // Only set by BLAST adapter layers
4405 if (what & layer_state_t::eProducerDisconnect) {
4406 layer->onDisconnect();
4407 }
4408
chaviw8b3871a2017-11-01 17:41:01 -07004409 if (what & layer_state_t::ePositionChanged) {
chaviw214c89d2019-09-04 16:03:53 -07004410 if (layer->setPosition(s.x, s.y)) {
chaviw8b3871a2017-11-01 17:41:01 -07004411 flags |= eTraversalNeeded;
Mathias Agopiane57f2922012-08-09 16:29:12 -07004412 }
chaviw8b3871a2017-11-01 17:41:01 -07004413 }
4414 if (what & layer_state_t::eLayerChanged) {
4415 // NOTE: index needs to be calculated before we update the state
Rob Carrc6d2d2b2021-10-25 16:51:49 +00004416 const auto& p = layer->getParent();
chaviw8b3871a2017-11-01 17:41:01 -07004417 if (p == nullptr) {
chaviw64f7b422017-07-12 10:31:58 -07004418 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
chaviw8b3871a2017-11-01 17:41:01 -07004419 if (layer->setLayer(s.z) && idx >= 0) {
Mathias Agopiane57f2922012-08-09 16:29:12 -07004420 mCurrentState.layersSortedByZ.removeAt(idx);
4421 mCurrentState.layersSortedByZ.add(layer);
4422 // we need traversal (state changed)
4423 // AND transaction (list changed)
4424 flags |= eTransactionNeeded|eTraversalNeeded;
4425 }
chaviw8b3871a2017-11-01 17:41:01 -07004426 } else {
4427 if (p->setChildLayer(layer, s.z)) {
chaviw06178942017-07-27 10:25:59 -07004428 flags |= eTransactionNeeded|eTraversalNeeded;
4429 }
4430 }
chaviw8b3871a2017-11-01 17:41:01 -07004431 }
4432 if (what & layer_state_t::eRelativeLayerChanged) {
Robert Carr503c7042017-09-27 15:06:08 -07004433 // NOTE: index needs to be calculated before we update the state
Rob Carrc6d2d2b2021-10-25 16:51:49 +00004434 const auto& p = layer->getParent();
Robert Carrbc384962021-01-27 15:44:50 -08004435 const auto& relativeHandle = s.relativeLayerSurfaceControl ?
4436 s.relativeLayerSurfaceControl->getHandle() : nullptr;
Robert Carr503c7042017-09-27 15:06:08 -07004437 if (p == nullptr) {
4438 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
Robert Carrbc384962021-01-27 15:44:50 -08004439 if (layer->setRelativeLayer(relativeHandle, s.z) &&
Pablo Gamito11dcc222020-09-12 15:49:39 +00004440 idx >= 0) {
Robert Carr503c7042017-09-27 15:06:08 -07004441 mCurrentState.layersSortedByZ.removeAt(idx);
4442 mCurrentState.layersSortedByZ.add(layer);
4443 // we need traversal (state changed)
4444 // AND transaction (list changed)
4445 flags |= eTransactionNeeded|eTraversalNeeded;
4446 }
4447 } else {
Robert Carrbc384962021-01-27 15:44:50 -08004448 if (p->setChildRelativeLayer(layer, relativeHandle, s.z)) {
Robert Carr503c7042017-09-27 15:06:08 -07004449 flags |= eTransactionNeeded|eTraversalNeeded;
4450 }
chaviw8b3871a2017-11-01 17:41:01 -07004451 }
4452 }
4453 if (what & layer_state_t::eSizeChanged) {
4454 if (layer->setSize(s.w, s.h)) {
4455 flags |= eTraversalNeeded;
4456 }
4457 }
4458 if (what & layer_state_t::eAlphaChanged) {
4459 if (layer->setAlpha(s.alpha))
4460 flags |= eTraversalNeeded;
4461 }
4462 if (what & layer_state_t::eColorChanged) {
4463 if (layer->setColor(s.color))
4464 flags |= eTraversalNeeded;
4465 }
Peiyong Lind3788632018-09-18 16:01:31 -07004466 if (what & layer_state_t::eColorTransformChanged) {
4467 if (layer->setColorTransform(s.colorTransform)) {
4468 flags |= eTraversalNeeded;
4469 }
4470 }
Valerie Haudd0b7572019-01-29 14:59:27 -08004471 if (what & layer_state_t::eBackgroundColorChanged) {
4472 if (layer->setBackgroundColor(s.color, s.bgColorAlpha, s.bgColorDataspace)) {
4473 flags |= eTraversalNeeded;
4474 }
4475 }
chaviw8b3871a2017-11-01 17:41:01 -07004476 if (what & layer_state_t::eMatrixChanged) {
Robert Carrde6d7b42022-01-07 18:23:06 -08004477 if (layer->setMatrix(s.matrix)) flags |= eTraversalNeeded;
chaviw8b3871a2017-11-01 17:41:01 -07004478 }
4479 if (what & layer_state_t::eTransparentRegionChanged) {
4480 if (layer->setTransparentRegionHint(s.transparentRegion))
4481 flags |= eTraversalNeeded;
4482 }
4483 if (what & layer_state_t::eFlagsChanged) {
Robert Carrde6d7b42022-01-07 18:23:06 -08004484 if (layer->setFlags(s.flags, s.mask)) flags |= eTraversalNeeded;
chaviw8b3871a2017-11-01 17:41:01 -07004485 }
Lucas Dupin1b6531c2018-07-05 17:18:21 -07004486 if (what & layer_state_t::eCornerRadiusChanged) {
4487 if (layer->setCornerRadius(s.cornerRadius))
4488 flags |= eTraversalNeeded;
4489 }
Galia Peycheva33713f72021-05-27 10:24:20 +02004490 if (what & layer_state_t::eBackgroundBlurRadiusChanged && mSupportsBlur) {
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08004491 if (layer->setBackgroundBlurRadius(s.backgroundBlurRadius)) flags |= eTraversalNeeded;
4492 }
Galia Peychevae11d5752021-01-22 13:50:16 +00004493 if (what & layer_state_t::eBlurRegionsChanged) {
Lucas Dupinc3800b82020-10-02 16:24:48 -07004494 if (layer->setBlurRegions(s.blurRegions)) flags |= eTraversalNeeded;
4495 }
chaviw8b3871a2017-11-01 17:41:01 -07004496 if (what & layer_state_t::eLayerStackChanged) {
4497 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
4498 // We only allow setting layer stacks for top level layers,
4499 // everything else inherits layer stack from its parent.
4500 if (layer->hasParent()) {
4501 ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004502 layer->getDebugName());
chaviw8b3871a2017-11-01 17:41:01 -07004503 } else if (idx < 0) {
4504 ALOGE("Attempt to set layer stack on layer without parent (%s) that "
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004505 "that also does not appear in the top level layer list. Something"
4506 " has gone wrong.",
4507 layer->getDebugName());
chaviw8b3871a2017-11-01 17:41:01 -07004508 } else if (layer->setLayerStack(s.layerStack)) {
4509 mCurrentState.layersSortedByZ.removeAt(idx);
4510 mCurrentState.layersSortedByZ.add(layer);
4511 // we need traversal (state changed)
4512 // AND transaction (list changed)
Vishnu Nair6213bd92020-05-08 17:42:25 -07004513 flags |= eTransactionNeeded | eTraversalNeeded | eTransformHintUpdateNeeded;
chaviw8b3871a2017-11-01 17:41:01 -07004514 }
4515 }
Marissa Wall61c58622018-07-18 10:12:20 -07004516 if (what & layer_state_t::eTransformChanged) {
4517 if (layer->setTransform(s.transform)) flags |= eTraversalNeeded;
4518 }
4519 if (what & layer_state_t::eTransformToDisplayInverseChanged) {
4520 if (layer->setTransformToDisplayInverse(s.transformToDisplayInverse))
4521 flags |= eTraversalNeeded;
4522 }
4523 if (what & layer_state_t::eCropChanged) {
4524 if (layer->setCrop(s.crop)) flags |= eTraversalNeeded;
4525 }
Marissa Wall61c58622018-07-18 10:12:20 -07004526 if (what & layer_state_t::eDataspaceChanged) {
4527 if (layer->setDataspace(s.dataspace)) flags |= eTraversalNeeded;
4528 }
4529 if (what & layer_state_t::eHdrMetadataChanged) {
4530 if (layer->setHdrMetadata(s.hdrMetadata)) flags |= eTraversalNeeded;
4531 }
4532 if (what & layer_state_t::eSurfaceDamageRegionChanged) {
4533 if (layer->setSurfaceDamageRegion(s.surfaceDamageRegion)) flags |= eTraversalNeeded;
4534 }
4535 if (what & layer_state_t::eApiChanged) {
4536 if (layer->setApi(s.api)) flags |= eTraversalNeeded;
4537 }
4538 if (what & layer_state_t::eSidebandStreamChanged) {
4539 if (layer->setSidebandStream(s.sidebandStream)) flags |= eTraversalNeeded;
4540 }
Robert Carr720e5062018-07-30 17:45:14 -07004541 if (what & layer_state_t::eInputInfoChanged) {
Robert Carrde6d7b42022-01-07 18:23:06 -08004542 layer->setInputInfo(*s.windowInfoHandle->getInfo());
4543 flags |= eTraversalNeeded;
Robert Carr720e5062018-07-30 17:45:14 -07004544 }
Vishnu Nairadf632b2021-01-07 14:05:08 -08004545 std::optional<nsecs_t> dequeueBufferTimestamp;
Evan Rosky1f6d6d52018-12-06 10:47:26 -08004546 if (what & layer_state_t::eMetadataChanged) {
Vishnu Nairadf632b2021-01-07 14:05:08 -08004547 dequeueBufferTimestamp = s.metadata.getInt64(METADATA_DEQUEUE_TIME);
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -07004548
4549 if (const int32_t gameMode = s.metadata.getInt32(METADATA_GAME_MODE, -1); gameMode != -1) {
Adithya Srinivasanac977e62021-05-21 22:50:56 +00004550 // The transaction will be received on the Task layer and needs to be applied to all
4551 // child layers. Child layers that are added at a later point will obtain the game mode
4552 // info through addChild().
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -07004553 layer->setGameModeForTree(static_cast<GameMode>(gameMode));
Adithya Srinivasanac977e62021-05-21 22:50:56 +00004554 }
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -07004555
Evan Rosky1f6d6d52018-12-06 10:47:26 -08004556 if (layer->setMetadata(s.metadata)) flags |= eTraversalNeeded;
4557 }
Peiyong Linc502cb72019-03-01 15:00:23 -08004558 if (what & layer_state_t::eColorSpaceAgnosticChanged) {
4559 if (layer->setColorSpaceAgnostic(s.colorSpaceAgnostic)) {
4560 flags |= eTraversalNeeded;
4561 }
4562 }
Vishnu Nairc97b8db2019-10-29 18:19:35 -07004563 if (what & layer_state_t::eShadowRadiusChanged) {
4564 if (layer->setShadowRadius(s.shadowRadius)) flags |= eTraversalNeeded;
4565 }
Ana Krulecc84d09b2019-11-02 23:10:29 +01004566 if (what & layer_state_t::eFrameRateSelectionPriority) {
Robert Carrde6d7b42022-01-07 18:23:06 -08004567 if (layer->setFrameRateSelectionPriority(s.frameRateSelectionPriority)) {
Ana Krulecc84d09b2019-11-02 23:10:29 +01004568 flags |= eTraversalNeeded;
4569 }
4570 }
Steven Thomas3172e202020-01-06 19:25:30 -08004571 if (what & layer_state_t::eFrameRateChanged) {
Robert Carrde6d7b42022-01-07 18:23:06 -08004572 const auto compatibility =
4573 Layer::FrameRate::convertCompatibility(s.frameRateCompatibility);
4574 const auto strategy =
4575 Layer::FrameRate::convertChangeFrameRateStrategy(s.changeFrameRateStrategy);
Marin Shalamanovc5986772021-03-16 16:09:49 +01004576
Robert Carrde6d7b42022-01-07 18:23:06 -08004577 if (layer->setFrameRate(
4578 Layer::FrameRate(Fps::fromValue(s.frameRate), compatibility, strategy))) {
4579 flags |= eTraversalNeeded;
Steven Thomas62a4cf82020-01-31 12:04:03 -08004580 }
Steven Thomas3172e202020-01-06 19:25:30 -08004581 }
Vishnu Nair6213bd92020-05-08 17:42:25 -07004582 if (what & layer_state_t::eFixedTransformHintChanged) {
4583 if (layer->setFixedTransformHint(s.fixedTransformHint)) {
4584 flags |= eTraversalNeeded | eTransformHintUpdateNeeded;
4585 }
4586 }
Vishnu Naircf26a0a2020-11-13 12:56:20 -08004587 if (what & layer_state_t::eAutoRefreshChanged) {
4588 layer->setAutoRefresh(s.autoRefresh);
4589 }
Sally Qi81d95e62022-03-21 19:41:33 -07004590 if (what & layer_state_t::eDimmingEnabledChanged) {
4591 if (layer->setDimmingEnabled(s.dimmingEnabled)) flags |= eTraversalNeeded;
4592 }
Winson Chunga30f7c92021-06-29 15:42:56 -07004593 if (what & layer_state_t::eTrustedOverlayChanged) {
Robert Carrde6d7b42022-01-07 18:23:06 -08004594 if (layer->setTrustedOverlay(s.isTrustedOverlay)) {
4595 flags |= eTraversalNeeded;
Winson Chunga30f7c92021-06-29 15:42:56 -07004596 }
4597 }
John Reckcdb4ed72021-02-04 13:39:33 -05004598 if (what & layer_state_t::eStretchChanged) {
4599 if (layer->setStretchEffect(s.stretchEffect)) {
4600 flags |= eTraversalNeeded;
4601 }
4602 }
chaviwf3f40fe2021-04-27 15:54:02 -05004603 if (what & layer_state_t::eBufferCropChanged) {
4604 if (layer->setBufferCrop(s.bufferCrop)) {
4605 flags |= eTraversalNeeded;
4606 }
4607 }
Vishnu Nair6bdec7d2021-05-10 15:01:13 -07004608 if (what & layer_state_t::eDestinationFrameChanged) {
4609 if (layer->setDestinationFrame(s.destinationFrame)) {
4610 flags |= eTraversalNeeded;
4611 }
4612 }
Vishnu Nair9cf4a4d2021-09-17 12:16:08 -07004613 if (what & layer_state_t::eDropInputModeChanged) {
Robert Carrde6d7b42022-01-07 18:23:06 -08004614 if (layer->setDropInputMode(s.dropInputMode)) {
4615 flags |= eTraversalNeeded;
4616 mInputInfoChanged = true;
Vishnu Nair9cf4a4d2021-09-17 12:16:08 -07004617 }
4618 }
Vishnu Nair14d76922019-08-05 08:41:20 -07004619 // This has to happen after we reparent children because when we reparent to null we remove
4620 // child layers from current state and remove its relative z. If the children are reparented in
4621 // the same transaction, then we have to make sure we reparent the children first so we do not
4622 // lose its relative z order.
4623 if (what & layer_state_t::eReparent) {
4624 bool hadParent = layer->hasParent();
Pablo Gamito11dcc222020-09-12 15:49:39 +00004625 auto parentHandle = (s.parentSurfaceControlForChild)
4626 ? s.parentSurfaceControlForChild->getHandle()
4627 : nullptr;
4628 if (layer->reparent(parentHandle)) {
Vishnu Nair14d76922019-08-05 08:41:20 -07004629 if (!hadParent) {
Vishnu Nair14d218b2021-07-13 13:57:39 -07004630 layer->setIsAtRoot(false);
Vishnu Nair14d76922019-08-05 08:41:20 -07004631 mCurrentState.layersSortedByZ.remove(layer);
4632 }
4633 flags |= eTransactionNeeded | eTraversalNeeded;
4634 }
4635 }
Jiakai Zhanga5505cb2021-11-09 11:46:30 +00004636 std::vector<sp<CallbackHandle>> callbackHandles;
4637 if ((what & layer_state_t::eHasListenerCallbacksChanged) && (!filteredListeners.empty())) {
4638 for (auto& [listener, callbackIds] : filteredListeners) {
4639 callbackHandles.emplace_back(new CallbackHandle(listener, callbackIds, s.surface));
4640 }
4641 }
Vishnu Nair6b7c5c92020-09-29 17:27:05 -07004642
Vishnu Nairdbbe3852022-01-12 20:22:11 -08004643 if (what & layer_state_t::eBufferChanged) {
4644 std::shared_ptr<renderengine::ExternalTexture> buffer =
4645 getExternalTextureFromBufferData(*s.bufferData, layer->getDebugName());
4646 if (layer->setBuffer(buffer, *s.bufferData, postTime, desiredPresentTime, isAutoTimestamp,
4647 dequeueBufferTimestamp, frameTimelineInfo)) {
4648 flags |= eTraversalNeeded;
4649 }
Ady Abraham8db10102021-03-15 17:19:23 -07004650 } else if (frameTimelineInfo.vsyncId != FrameTimelineInfo::INVALID_VSYNC_ID) {
4651 layer->setFrameTimelineVsyncForBufferlessTransaction(frameTimelineInfo, postTime);
Marissa Wallebc2c052019-01-16 19:16:55 -08004652 }
Ady Abraham22c7b5c2020-09-22 19:33:40 -07004653
Jiakai Zhanga5505cb2021-11-09 11:46:30 +00004654 if (layer->setTransactionCompletedListeners(callbackHandles)) flags |= eTraversalNeeded;
Marissa Walle2ffb422018-10-12 11:33:52 -07004655 // Do not put anything that updates layer state or modifies flags after
4656 // setTransactionCompletedListener
Mathias Agopiane57f2922012-08-09 16:29:12 -07004657 return flags;
4658}
4659
chaviw273171b2018-12-26 11:46:30 -08004660uint32_t SurfaceFlinger::addInputWindowCommands(const InputWindowCommands& inputWindowCommands) {
Arthur Hung58144272021-01-16 03:43:53 +00004661 bool hasChanges = mInputWindowCommands.merge(inputWindowCommands);
Vishnu Naire798b472020-07-23 13:52:21 -07004662 return hasChanges ? eTraversalNeeded : 0;
chaviw273171b2018-12-26 11:46:30 -08004663}
4664
Vishnu Nair84125ac2021-12-02 08:47:48 -08004665status_t SurfaceFlinger::mirrorLayer(const LayerCreationArgs& args,
4666 const sp<IBinder>& mirrorFromHandle, sp<IBinder>* outHandle,
4667 int32_t* outLayerId) {
chaviwfe94a222019-08-21 13:52:59 -07004668 if (!mirrorFromHandle) {
4669 return NAME_NOT_FOUND;
4670 }
4671
4672 sp<Layer> mirrorLayer;
4673 sp<Layer> mirrorFrom;
chaviwfe94a222019-08-21 13:52:59 -07004674 {
4675 Mutex::Autolock _l(mStateLock);
Vishnu Nairf9096652021-07-20 18:49:42 -07004676 mirrorFrom = fromHandle(mirrorFromHandle).promote();
chaviwfe94a222019-08-21 13:52:59 -07004677 if (!mirrorFrom) {
4678 return NAME_NOT_FOUND;
4679 }
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08004680 status_t result = createContainerLayer(args, outHandle, &mirrorLayer);
chaviwfe94a222019-08-21 13:52:59 -07004681 if (result != NO_ERROR) {
4682 return result;
4683 }
4684
Robert Carr6a0382d2021-07-01 15:57:17 -07004685 mirrorLayer->setClonedChild(mirrorFrom->createClone());
chaviwfe94a222019-08-21 13:52:59 -07004686 }
4687
Ady Abraham9f0a4002020-10-05 15:47:26 -07004688 *outLayerId = mirrorLayer->sequence;
Dominik Laskowski46471e62022-01-14 15:34:03 -08004689 if (mTransactionTracing) {
4690 mTransactionTracing->onMirrorLayerAdded((*outHandle)->localBinder(), mirrorLayer->sequence,
4691 args.name, mirrorFrom->sequence);
Vishnu Nair84125ac2021-12-02 08:47:48 -08004692 }
4693 return addClientLayer(args.client, *outHandle, mirrorLayer /* layer */, nullptr /* parent */,
Vishnu Nair858a3b42022-01-12 20:42:28 -08004694 false /* addToRoot */, nullptr /* outTransformHint */);
chaviwfe94a222019-08-21 13:52:59 -07004695}
4696
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08004697status_t SurfaceFlinger::createLayer(LayerCreationArgs& args, sp<IBinder>* outHandle,
Ady Abraham9f0a4002020-10-05 15:47:26 -07004698 const sp<IBinder>& parentHandle, int32_t* outLayerId,
4699 const sp<Layer>& parentLayer, uint32_t* outTransformHint) {
Robert Carrc0df3122019-04-11 13:18:21 -07004700 ALOG_ASSERT(parentLayer == nullptr || parentHandle == nullptr,
4701 "Expected only one of parentLayer or parentHandle to be non-null. "
4702 "Programmer error?");
4703
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004704 status_t result = NO_ERROR;
4705
4706 sp<Layer> layer;
4707
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08004708 switch (args.flags & ISurfaceComposerClient::eFXSurfaceMask) {
Marissa Wall61c58622018-07-18 10:12:20 -07004709 case ISurfaceComposerClient::eFXSurfaceBufferQueue:
Vishnu Nair8eda69e2021-02-26 10:42:10 -08004710 case ISurfaceComposerClient::eFXSurfaceBufferState: {
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08004711 result = createBufferStateLayer(args, outHandle, &layer);
Vishnu Nair8eda69e2021-02-26 10:42:10 -08004712 std::atomic<int32_t>* pendingBufferCounter = layer->getPendingBufferCounter();
4713 if (pendingBufferCounter) {
4714 std::string counterName = layer->getPendingBufferCounterName();
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08004715 mBufferCountTracker.add((*outHandle)->localBinder(), counterName,
Vishnu Nair8eda69e2021-02-26 10:42:10 -08004716 pendingBufferCounter);
4717 }
4718 } break;
Vishnu Nairfa247b12020-02-11 08:58:26 -08004719 case ISurfaceComposerClient::eFXSurfaceEffect:
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08004720 result = createEffectLayer(args, outHandle, &layer);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004721 break;
Robert Carr6b3f6c52018-08-13 13:05:17 -07004722 case ISurfaceComposerClient::eFXSurfaceContainer:
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08004723 result = createContainerLayer(args, outHandle, &layer);
Robert Carr6b3f6c52018-08-13 13:05:17 -07004724 break;
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004725 default:
4726 result = BAD_VALUE;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004727 break;
4728 }
4729
Dan Stoza7d89d062015-04-30 13:29:25 -07004730 if (result != NO_ERROR) {
4731 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004732 }
Dan Stoza7d89d062015-04-30 13:29:25 -07004733
Vishnu Nair858a3b42022-01-12 20:42:28 -08004734 bool addToRoot = args.addToRoot && callingThreadHasUnscopedSurfaceFlingerAccess();
Garfield Tandbc93d72021-10-26 18:28:57 -07004735 wp<Layer> parent(parentHandle != nullptr ? fromHandle(parentHandle) : parentLayer);
4736 if (parentHandle != nullptr && parent == nullptr) {
4737 ALOGE("Invalid parent handle %p.", parentHandle.get());
4738 addToRoot = false;
4739 }
4740 if (parentLayer != nullptr) {
4741 addToRoot = false;
4742 }
Dan Stoza7d89d062015-04-30 13:29:25 -07004743
Vishnu Nair0cc69e12021-11-18 09:05:49 -08004744 int parentId = -1;
4745 // We can safely promote the layer in binder thread because we have a strong reference
4746 // to the layer's handle inside this scope or we were passed in a sp reference to the layer.
4747 sp<Layer> parentSp = parent.promote();
4748 if (parentSp != nullptr) {
4749 parentId = parentSp->getSequence();
4750 }
Dominik Laskowski46471e62022-01-14 15:34:03 -08004751 if (mTransactionTracing) {
4752 mTransactionTracing->onLayerAdded((*outHandle)->localBinder(), layer->sequence, args.name,
4753 args.flags, parentId);
Vishnu Nair84125ac2021-12-02 08:47:48 -08004754 }
Vishnu Nair0cc69e12021-11-18 09:05:49 -08004755
Vishnu Nair047fb332021-12-09 09:54:36 -08004756 result = addClientLayer(args.client, *outHandle, layer, parent, addToRoot, outTransformHint);
4757 if (result != NO_ERROR) {
4758 return result;
4759 }
4760
Ady Abraham9f0a4002020-10-05 15:47:26 -07004761 *outLayerId = layer->sequence;
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004762 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004763}
4764
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08004765status_t SurfaceFlinger::createBufferQueueLayer(LayerCreationArgs& args, PixelFormat& format,
Evan Roskya1f1e152019-01-24 16:17:46 -08004766 sp<IBinder>* handle,
Marissa Wallfd668622018-05-10 10:21:13 -07004767 sp<IGraphicBufferProducer>* gbp,
4768 sp<Layer>* outLayer) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004769 // initialize the surfaces
Mathias Agopian92a979a2012-08-02 18:32:23 -07004770 switch (format) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004771 case PIXEL_FORMAT_TRANSPARENT:
4772 case PIXEL_FORMAT_TRANSLUCENT:
4773 format = PIXEL_FORMAT_RGBA_8888;
4774 break;
4775 case PIXEL_FORMAT_OPAQUE:
Mathias Agopian8f105402010-04-05 18:01:24 -07004776 format = PIXEL_FORMAT_RGBX_8888;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004777 break;
4778 }
4779
chaviwb4c6e582019-08-16 14:35:07 -07004780 sp<BufferQueueLayer> layer;
chaviwb4c6e582019-08-16 14:35:07 -07004781 args.textureName = getNewTexture();
4782 {
4783 // Grab the SF state lock during this since it's the only safe way to access
4784 // RenderEngine when creating a BufferLayerConsumer
4785 // TODO: Check if this lock is still needed here
4786 Mutex::Autolock lock(mStateLock);
4787 layer = getFactory().createBufferQueueLayer(args);
4788 }
4789
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08004790 status_t err = layer->setDefaultBufferProperties(0, 0, format);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004791 if (err == NO_ERROR) {
David Sodman0c69cad2017-08-21 12:12:51 -07004792 *handle = layer->getHandle();
4793 *gbp = layer->getProducer();
4794 *outLayer = layer;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004795 }
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004796
Marissa Wallfd668622018-05-10 10:21:13 -07004797 ALOGE_IF(err, "createBufferQueueLayer() failed (%s)", strerror(-err));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004798 return err;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004799}
4800
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08004801status_t SurfaceFlinger::createBufferStateLayer(LayerCreationArgs& args, sp<IBinder>* handle,
Vishnu Nair6213bd92020-05-08 17:42:25 -07004802 sp<Layer>* outLayer) {
chaviwb4c6e582019-08-16 14:35:07 -07004803 args.textureName = getNewTexture();
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08004804 *outLayer = getFactory().createBufferStateLayer(args);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004805 *handle = (*outLayer)->getHandle();
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004806 return NO_ERROR;
Mathias Agopian118d0242011-10-13 16:02:48 -07004807}
4808
Vishnu Nair84125ac2021-12-02 08:47:48 -08004809status_t SurfaceFlinger::createEffectLayer(const LayerCreationArgs& args, sp<IBinder>* handle,
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08004810 sp<Layer>* outLayer) {
4811 *outLayer = getFactory().createEffectLayer(args);
4812 *handle = (*outLayer)->getHandle();
4813 return NO_ERROR;
4814}
4815
Vishnu Nair84125ac2021-12-02 08:47:48 -08004816status_t SurfaceFlinger::createContainerLayer(const LayerCreationArgs& args, sp<IBinder>* handle,
Evan Roskya1f1e152019-01-24 16:17:46 -08004817 sp<Layer>* outLayer) {
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08004818 *outLayer = getFactory().createContainerLayer(args);
Robert Carr6b3f6c52018-08-13 13:05:17 -07004819 *handle = (*outLayer)->getHandle();
4820 return NO_ERROR;
4821}
4822
Robert Carr6fb1a7e2018-12-11 12:07:25 -08004823void SurfaceFlinger::markLayerPendingRemovalLocked(const sp<Layer>& layer) {
Robert Carr2e102c92018-10-23 12:11:15 -07004824 mLayersPendingRemoval.add(layer);
4825 mLayersRemoved = true;
4826 setTransactionFlags(eTransactionNeeded);
4827}
4828
Vishnu Nairf9096652021-07-20 18:49:42 -07004829void SurfaceFlinger::onHandleDestroyed(BBinder* handle, sp<Layer>& layer) {
Robert Carr2e102c92018-10-23 12:11:15 -07004830 Mutex::Autolock lock(mStateLock);
Robert Carr6fb1a7e2018-12-11 12:07:25 -08004831 markLayerPendingRemovalLocked(layer);
Vishnu Nairf9096652021-07-20 18:49:42 -07004832 mBufferCountTracker.remove(handle);
Robert Carr695d5282018-12-18 15:27:58 -08004833 layer.clear();
Dominik Laskowski46471e62022-01-14 15:34:03 -08004834 if (mTransactionTracing) {
4835 mTransactionTracing->onHandleRemoved(handle);
Vishnu Nair047fb332021-12-09 09:54:36 -08004836 }
Rob Carr4bba3702018-10-08 21:53:30 +00004837}
4838
Mathias Agopianb60314a2012-04-10 22:09:54 -07004839// ---------------------------------------------------------------------------
4840
Andy McFadden13a082e2012-08-24 10:16:42 -07004841void SurfaceFlinger::onInitializeDisplays() {
Dominik Laskowski83b88212018-12-11 13:34:06 -08004842 const auto display = getDefaultDisplayDeviceLocked();
4843 if (!display) return;
4844
4845 const sp<IBinder> token = display->getDisplayToken().promote();
4846 LOG_ALWAYS_FATAL_IF(token == nullptr);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004847
Jesse Hall01e29052013-02-19 16:13:35 -08004848 // reset screen orientation and use primary layer stack
Andy McFadden13a082e2012-08-24 10:16:42 -07004849 Vector<ComposerState> state;
4850 Vector<DisplayState> displays;
4851 DisplayState d;
Jesse Hall01e29052013-02-19 16:13:35 -08004852 d.what = DisplayState::eDisplayProjectionChanged |
4853 DisplayState::eLayerStackChanged;
Dominik Laskowski83b88212018-12-11 13:34:06 -08004854 d.token = token;
Dominik Laskowski29fa1462021-04-27 15:51:50 -07004855 d.layerStack = ui::DEFAULT_LAYER_STACK;
Dominik Laskowski718f9602019-11-09 20:01:35 -08004856 d.orientation = ui::ROTATION_0;
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02004857 d.orientedDisplaySpaceRect.makeInvalid();
4858 d.layerStackSpaceRect.makeInvalid();
Michael Lentine47e45402014-07-18 15:34:25 -07004859 d.width = 0;
4860 d.height = 0;
Andy McFadden13a082e2012-08-24 10:16:42 -07004861 displays.add(d);
Arthur Hung58144272021-01-16 03:43:53 +00004862
Vishnu Nair9a69a042021-06-18 13:19:49 -07004863 nsecs_t now = systemTime();
Vishnu Nair7891e962021-11-11 12:07:21 -08004864
4865 int64_t transactionId = (((int64_t)mPid) << 32) | mUniqueTransactionId++;
Arthur Hung58144272021-01-16 03:43:53 +00004866 // It should be on the main thread, apply it directly.
4867 applyTransactionState(FrameTimelineInfo{}, state, displays, 0, mInputWindowCommands,
Vishnu Nair9a69a042021-06-18 13:19:49 -07004868 /* desiredPresentTime */ now, true, {}, /* postTime */ now, true, false,
Vishnu Nair7891e962021-11-11 12:07:21 -08004869 {}, mPid, getuid(), transactionId);
Jamie Gennis6547ff42013-07-16 20:12:42 -07004870
Peiyong Lin65248e02020-04-18 21:15:07 -07004871 setPowerModeInternal(display, hal::PowerMode::ON);
Dominik Laskowskib0054a22022-03-03 09:03:06 -08004872 const nsecs_t vsyncPeriod = display->refreshRateConfigs().getActiveMode()->getVsyncPeriod();
Dominik Laskowski83b88212018-12-11 13:34:06 -08004873 mAnimFrameTracker.setDisplayRefreshPeriod(vsyncPeriod);
Ady Abraham1273ac12021-08-26 17:31:53 -07004874 mActiveDisplayTransformHint = display->getTransformHint();
Brian Andersond0010582017-03-07 13:20:31 -08004875 // Use phase of 0 since phase is not known.
4876 // Use latency of 0, which will snap to the ideal latency.
Dominik Laskowski83b88212018-12-11 13:34:06 -08004877 DisplayStatInfo stats{0 /* vsyncTime */, vsyncPeriod};
Ana Krulece588e312018-09-18 12:32:24 -07004878 setCompositorTimingSnapped(stats, 0);
Andy McFadden13a082e2012-08-24 10:16:42 -07004879}
4880
4881void SurfaceFlinger::initializeDisplays() {
Dominik Laskowski8c001672018-05-30 16:52:06 -07004882 // Async since we may be called from the main thread.
Dominik Laskowski298b08e2022-02-15 13:45:02 -08004883 static_cast<void>(
4884 mScheduler->schedule([this]() FTL_FAKE_GUARD(mStateLock) { onInitializeDisplays(); }));
Andy McFadden13a082e2012-08-24 10:16:42 -07004885}
4886
Peiyong Lin65248e02020-04-18 21:15:07 -07004887void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& display, hal::PowerMode mode) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004888 if (display->isVirtual()) {
Dominik Laskowski6c7b36e2022-03-03 08:27:58 -08004889 ALOGE("%s: Invalid operation on virtual display", __func__);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004890 return;
4891 }
4892
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02004893 const auto displayId = display->getPhysicalId();
4894 ALOGD("Setting power mode %d on display %s", mode, to_string(displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004895
linpetere8059322022-07-13 19:20:48 +08004896 std::optional<hal::PowerMode> currentMode = display->getPowerMode();
4897 if (currentMode.has_value() && mode == *currentMode) {
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004898 return;
4899 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004900
Ady Abraham4f960d12021-10-13 16:59:49 -07004901 const auto activeDisplay = getDisplayDeviceLocked(mActiveDisplayToken);
4902 if (activeDisplay != display && display->isInternal() && activeDisplay &&
4903 activeDisplay->isPoweredOn()) {
4904 ALOGW("Trying to change power mode on non active display while the active display is ON");
4905 }
4906
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004907 display->setPowerMode(mode);
4908
Lloyd Pique4dccc412018-01-22 17:21:36 -08004909 if (mInterceptor->isEnabled()) {
Peiyong Lin65248e02020-04-18 21:15:07 -07004910 mInterceptor->savePowerModeUpdate(display->getSequenceId(), static_cast<int32_t>(mode));
Irvelffc9efc2016-07-27 15:16:37 -07004911 }
Dominik Laskowskib0054a22022-03-03 09:03:06 -08004912 const auto refreshRate = display->refreshRateConfigs().getActiveMode()->getFps();
Dominik Laskowskie63a5922022-11-22 13:59:53 -05004913 if (!currentMode || *currentMode == hal::PowerMode::OFF) {
Ady Abraham4f960d12021-10-13 16:59:49 -07004914 // Turn on the display
Ady Abrahamed3290f2021-05-17 15:12:14 -07004915 if (display->isInternal() && (!activeDisplay || !activeDisplay->isPoweredOn())) {
Ady Abrahamdb036a82021-07-16 14:18:34 -07004916 onActiveDisplayChangedLocked(display);
Ady Abrahamed3290f2021-05-17 15:12:14 -07004917 }
Wei Wang23aa5a62021-06-04 15:56:57 -07004918 // Keep uclamp in a separate syscall and set it before changing to RT due to b/190237315.
4919 // We can merge the syscall later.
4920 if (SurfaceFlinger::setSchedAttr(true) != NO_ERROR) {
4921 ALOGW("Couldn't set uclamp.min on display on: %s\n", strerror(errno));
4922 }
Martin Liu4a322352020-03-24 21:30:38 +08004923 if (SurfaceFlinger::setSchedFifo(true) != NO_ERROR) {
4924 ALOGW("Couldn't set SCHED_FIFO on display on: %s\n", strerror(errno));
4925 }
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02004926 getHwComposer().setPowerMode(displayId, mode);
Ady Abrahamadc914c2021-10-13 17:04:27 -07004927 if (isDisplayActiveLocked(display) && mode != hal::PowerMode::DOZE_SUSPEND) {
Ady Abraham4f960d12021-10-13 16:59:49 -07004928 setHWCVsyncEnabled(displayId, mHWCVsyncPendingState);
Ana Krulecc2870422019-01-29 19:00:58 -08004929 mScheduler->onScreenAcquired(mAppConnectionHandle);
Dominik Laskowskib0054a22022-03-03 09:03:06 -08004930 mScheduler->resyncToHardwareVsync(true, refreshRate);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004931 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004932
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004933 mVisibleRegionsDirty = true;
Dan Stozab90cf072015-03-05 11:05:59 -08004934 mHasPoweredOff = true;
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07004935 scheduleComposite(FrameHint::kActive);
Peiyong Lin65248e02020-04-18 21:15:07 -07004936 } else if (mode == hal::PowerMode::OFF) {
Tim Murrayf9d4e442016-08-02 15:43:59 -07004937 // Turn off the display
Martin Liu4a322352020-03-24 21:30:38 +08004938 if (SurfaceFlinger::setSchedFifo(false) != NO_ERROR) {
4939 ALOGW("Couldn't set SCHED_OTHER on display off: %s\n", strerror(errno));
Tim Murrayf9d4e442016-08-02 15:43:59 -07004940 }
Wei Wang23aa5a62021-06-04 15:56:57 -07004941 if (SurfaceFlinger::setSchedAttr(false) != NO_ERROR) {
4942 ALOGW("Couldn't set uclamp.min on display off: %s\n", strerror(errno));
4943 }
linpetere8059322022-07-13 19:20:48 +08004944 if (isDisplayActiveLocked(display) && *currentMode != hal::PowerMode::DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08004945 mScheduler->disableHardwareVsync(true);
4946 mScheduler->onScreenReleased(mAppConnectionHandle);
Mathias Agopiancde87a32012-09-13 14:09:01 -07004947 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004948
Ady Abraham27c70212019-06-11 10:52:26 -07004949 // Make sure HWVsync is disabled before turning off the display
Ady Abraham4f960d12021-10-13 16:59:49 -07004950 setHWCVsyncEnabled(displayId, hal::Vsync::DISABLE);
Ady Abraham27c70212019-06-11 10:52:26 -07004951
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02004952 getHwComposer().setPowerMode(displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004953 mVisibleRegionsDirty = true;
4954 // from this point on, SF will stop drawing on this display
Peiyong Lin65248e02020-04-18 21:15:07 -07004955 } else if (mode == hal::PowerMode::DOZE || mode == hal::PowerMode::ON) {
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004956 // Update display while dozing
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02004957 getHwComposer().setPowerMode(displayId, mode);
linpetere8059322022-07-13 19:20:48 +08004958 if (isDisplayActiveLocked(display) && *currentMode == hal::PowerMode::DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08004959 mScheduler->onScreenAcquired(mAppConnectionHandle);
Dominik Laskowskib0054a22022-03-03 09:03:06 -08004960 mScheduler->resyncToHardwareVsync(true, refreshRate);
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004961 }
Peiyong Lin65248e02020-04-18 21:15:07 -07004962 } else if (mode == hal::PowerMode::DOZE_SUSPEND) {
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004963 // Leave display going to doze
Ady Abrahamadc914c2021-10-13 17:04:27 -07004964 if (isDisplayActiveLocked(display)) {
Ana Krulecc2870422019-01-29 19:00:58 -08004965 mScheduler->disableHardwareVsync(true);
4966 mScheduler->onScreenReleased(mAppConnectionHandle);
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004967 }
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02004968 getHwComposer().setPowerMode(displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004969 } else {
Matthew Bouyack38d49612017-05-12 12:49:32 -07004970 ALOGE("Attempting to set unknown power mode: %d\n", mode);
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02004971 getHwComposer().setPowerMode(displayId, mode);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004972 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004973
Ady Abrahamadc914c2021-10-13 17:04:27 -07004974 if (isDisplayActiveLocked(display)) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08004975 mTimeStats->setPowerMode(mode);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07004976 mRefreshRateStats->setPowerMode(mode);
Rachel Lee6a9731d2022-06-06 17:08:14 -07004977 mScheduler->setDisplayPowerMode(mode);
Yiwei Zhang3a226d22018-10-16 09:23:03 -07004978 }
4979
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02004980 ALOGD("Finished setting power mode %d on display %s", mode, to_string(displayId).c_str());
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004981}
4982
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004983void SurfaceFlinger::setPowerMode(const sp<IBinder>& displayToken, int mode) {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08004984 auto future = mScheduler->schedule([=]() FTL_FAKE_GUARD(mStateLock) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07004985 const auto display = getDisplayDeviceLocked(displayToken);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004986 if (!display) {
4987 ALOGE("Attempt to set power mode %d for invalid display token %p", mode,
4988 displayToken.get());
4989 } else if (display->isVirtual()) {
4990 ALOGW("Attempt to set power mode %d for virtual display", mode);
4991 } else {
Peiyong Lin65248e02020-04-18 21:15:07 -07004992 setPowerModeInternal(display, static_cast<hal::PowerMode>(mode));
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004993 }
Dominik Laskowski756b7892021-08-04 12:53:59 -07004994 });
4995
4996 future.wait();
Mathias Agopianb60314a2012-04-10 22:09:54 -07004997}
4998
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07004999status_t SurfaceFlinger::doDump(int fd, const DumpArgs& args, bool asProto) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08005000 std::string result;
Mathias Agopian99b49842011-06-27 16:05:52 -07005001
Mathias Agopianbd115332013-04-18 16:41:04 -07005002 IPCThreadState* ipc = IPCThreadState::self();
5003 const int pid = ipc->getCallingPid();
5004 const int uid = ipc->getCallingUid();
Vishnu Nair6a408532017-10-24 09:11:27 -07005005
Mathias Agopianbd115332013-04-18 16:41:04 -07005006 if ((uid != AID_SHELL) &&
5007 !PermissionCache::checkPermission(sDump, pid, uid)) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08005008 StringAppendF(&result, "Permission Denial: can't dump SurfaceFlinger from pid=%d, uid=%d\n",
5009 pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005010 } else {
Dominik Laskowskic2867142019-01-21 11:33:38 -08005011 static const std::unordered_map<std::string, Dumper> dumpers = {
Dominik Laskowski0acc3842022-04-07 11:23:42 -07005012 {"--comp-displays"s, dumper(&SurfaceFlinger::dumpCompositionDisplays)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08005013 {"--display-id"s, dumper(&SurfaceFlinger::dumpDisplayIdentificationData)},
Dominik Laskowski0acc3842022-04-07 11:23:42 -07005014 {"--displays"s, dumper(&SurfaceFlinger::dumpDisplays)},
Ady Abraham8cb21882020-08-26 18:22:05 -07005015 {"--dispsync"s, dumper([this](std::string& s) { mScheduler->dumpVsync(s); })},
Dominik Laskowskib6e54372019-09-04 14:06:28 -07005016 {"--edid"s, argsDumper(&SurfaceFlinger::dumpRawDisplayIdentificationData)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08005017 {"--latency"s, argsDumper(&SurfaceFlinger::dumpStatsLocked)},
5018 {"--latency-clear"s, argsDumper(&SurfaceFlinger::clearStatsLocked)},
5019 {"--list"s, dumper(&SurfaceFlinger::listLayersLocked)},
Dan Stoza269dc4d2021-01-15 15:07:43 -08005020 {"--planner"s, argsDumper(&SurfaceFlinger::dumpPlannerInfo)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08005021 {"--static-screen"s, dumper(&SurfaceFlinger::dumpStaticScreenStats)},
5022 {"--timestats"s, protoDumper(&SurfaceFlinger::dumpTimeStats)},
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08005023 {"--vsync"s, dumper(&SurfaceFlinger::dumpVSync)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08005024 {"--wide-color"s, dumper(&SurfaceFlinger::dumpWideColorInfo)},
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -07005025 {"--frametimeline"s, argsDumper(&SurfaceFlinger::dumpFrameTimeline)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08005026 };
Mathias Agopian25e66fc2012-01-28 22:31:55 -08005027
Dominik Laskowskic2867142019-01-21 11:33:38 -08005028 const auto flag = args.empty() ? ""s : std::string(String8(args[0]));
Mathias Agopian25e66fc2012-01-28 22:31:55 -08005029
Alec Mouri3b3e5912022-09-26 21:37:01 +00005030 // Traversal of drawing state must happen on the main thread.
5031 // Otherwise, SortedVector may have shared ownership during concurrent
5032 // traversals, which can result in use-after-frees.
5033 std::string compositionLayers;
5034 mScheduler
5035 ->schedule([&] {
5036 StringAppendF(&compositionLayers, "Composition layers\n");
5037 mDrawingState.traverseInZOrder([&](Layer* layer) {
5038 auto* compositionState = layer->getCompositionState();
5039 if (!compositionState || !compositionState->isVisible) return;
5040
5041 android::base::StringAppendF(&compositionLayers, "* Layer %p (%s)\n", layer,
5042 layer->getDebugName() ? layer->getDebugName()
5043 : "<unknown>");
5044 compositionState->dump(compositionLayers);
5045 });
5046 })
5047 .get();
5048
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07005049 bool dumpLayers = true;
5050 {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08005051 TimedLock lock(mStateLock, s2ns(1), __func__);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07005052 if (!lock.locked()) {
5053 StringAppendF(&result, "Dumping without lock after timeout: %s (%d)\n",
5054 strerror(-lock.status), lock.status);
5055 }
5056
5057 if (const auto it = dumpers.find(flag); it != dumpers.end()) {
5058 (it->second)(args, asProto, result);
5059 dumpLayers = false;
5060 } else if (!asProto) {
Alec Mouri3b3e5912022-09-26 21:37:01 +00005061 dumpAllLocked(args, compositionLayers, result);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07005062 }
Mathias Agopian48b888a2011-01-19 16:15:53 -08005063 }
5064
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07005065 if (dumpLayers) {
Vishnu Nair00b90132021-11-05 14:03:40 -07005066 LayersTraceFileProto traceFileProto = mLayerTracing.createTraceFileProto();
chaviw0a398992021-08-13 10:13:01 -05005067 LayersTraceProto* layersTrace = traceFileProto.add_entry();
5068 LayersProto layersProto = dumpProtoFromMainThread();
5069 layersTrace->mutable_layers()->Swap(&layersProto);
5070 dumpDisplayProto(*layersTrace);
5071
Dominik Laskowski46470112019-08-02 13:13:11 -07005072 if (asProto) {
chaviw0a398992021-08-13 10:13:01 -05005073 result.append(traceFileProto.SerializeAsString());
Dominik Laskowski46470112019-08-02 13:13:11 -07005074 } else {
Vishnu Nair0f085c62019-08-30 08:49:12 -07005075 // Dump info that we need to access from the main thread
chaviwa2b9fab2021-09-08 14:46:30 -05005076 const auto layerTree = LayerProtoParser::generateLayerTree(layersTrace->layers());
Dominik Laskowski46470112019-08-02 13:13:11 -07005077 result.append(LayerProtoParser::layerTreeToString(layerTree));
5078 result.append("\n");
Vishnu Nair0f085c62019-08-30 08:49:12 -07005079 dumpOffscreenLayers(result);
Dominik Laskowski46470112019-08-02 13:13:11 -07005080 }
Vishnu Nair8406fd72019-07-30 11:29:31 -07005081 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005082 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08005083 write(fd, result.c_str(), result.size());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005084 return NO_ERROR;
5085}
5086
Nataniel Borges8e7dc722019-02-28 15:10:28 -08005087status_t SurfaceFlinger::dumpCritical(int fd, const DumpArgs&, bool asProto) {
Vishnu Nair7891e962021-11-11 12:07:21 -08005088 if (asProto) {
Vishnu Nair00b90132021-11-05 14:03:40 -07005089 mLayerTracing.writeToFile();
Dominik Laskowski46471e62022-01-14 15:34:03 -08005090 if (mTransactionTracing) {
5091 mTransactionTracing->writeToFile();
5092 }
Nataniel Borges8e7dc722019-02-28 15:10:28 -08005093 }
5094
5095 return doDump(fd, DumpArgs(), asProto);
5096}
5097
Dominik Laskowskic2867142019-01-21 11:33:38 -08005098void SurfaceFlinger::listLayersLocked(std::string& result) const {
Yiwei Zhang5434a782018-12-05 18:06:32 -08005099 mCurrentState.traverseInZOrder(
Dominik Laskowski87a07e42019-10-10 20:38:02 -07005100 [&](Layer* layer) { StringAppendF(&result, "%s\n", layer->getDebugName()); });
Mathias Agopian25e66fc2012-01-28 22:31:55 -08005101}
5102
Dominik Laskowskic2867142019-01-21 11:33:38 -08005103void SurfaceFlinger::dumpStatsLocked(const DumpArgs& args, std::string& result) const {
Ady Abraham2492a022020-07-24 11:09:55 -07005104 StringAppendF(&result, "%" PRId64 "\n", getVsyncPeriodFromHWC());
Jamie Gennis4b0eba92013-02-05 13:30:24 -08005105
Dominik Laskowskic2867142019-01-21 11:33:38 -08005106 if (args.size() > 1) {
5107 const auto name = String8(args[1]);
Robert Carr2047fae2016-11-28 14:09:09 -08005108 mCurrentState.traverseInZOrder([&](Layer* layer) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07005109 if (layer->getName() == name.string()) {
Svetoslavd85084b2014-03-20 10:28:31 -07005110 layer->dumpFrameStats(result);
Jamie Gennis4b0eba92013-02-05 13:30:24 -08005111 }
Robert Carr2047fae2016-11-28 14:09:09 -08005112 });
Dominik Laskowskic2867142019-01-21 11:33:38 -08005113 } else {
5114 mAnimFrameTracker.dumpStats(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005115 }
5116}
5117
Dominik Laskowskic2867142019-01-21 11:33:38 -08005118void SurfaceFlinger::clearStatsLocked(const DumpArgs& args, std::string&) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07005119 const bool clearAll = args.size() < 2;
5120 const auto name = clearAll ? String8() : String8(args[1]);
5121
Edgar Arriaga844fa672020-01-16 14:21:42 -08005122 mCurrentState.traverse([&](Layer* layer) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07005123 if (clearAll || layer->getName() == name.string()) {
Svetoslavd85084b2014-03-20 10:28:31 -07005124 layer->clearFrameStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08005125 }
Robert Carr2047fae2016-11-28 14:09:09 -08005126 });
Jamie Gennis4b0eba92013-02-05 13:30:24 -08005127
Svetoslavd85084b2014-03-20 10:28:31 -07005128 mAnimFrameTracker.clearStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08005129}
5130
Dominik Laskowskic2867142019-01-21 11:33:38 -08005131void SurfaceFlinger::dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const {
5132 mTimeStats->parseArgs(asProto, args, result);
5133}
5134
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -07005135void SurfaceFlinger::dumpFrameTimeline(const DumpArgs& args, std::string& result) const {
5136 mFrameTimeline->parseArgs(args, result);
5137}
5138
Jamie Gennis6547ff42013-07-16 20:12:42 -07005139void SurfaceFlinger::logFrameStats() {
Edgar Arriaga844fa672020-01-16 14:21:42 -08005140 mDrawingState.traverse([&](Layer* layer) {
Jamie Gennis6547ff42013-07-16 20:12:42 -07005141 layer->logFrameStats();
Robert Carr2047fae2016-11-28 14:09:09 -08005142 });
Jamie Gennis6547ff42013-07-16 20:12:42 -07005143
Dominik Laskowski87a07e42019-10-10 20:38:02 -07005144 mAnimFrameTracker.logAndResetStats("<win-anim>");
Jamie Gennis6547ff42013-07-16 20:12:42 -07005145}
5146
Yiwei Zhang5434a782018-12-05 18:06:32 -08005147void SurfaceFlinger::appendSfConfigString(std::string& result) const {
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08005148 result.append(" [sf");
Fabien Sanglardc93afd52017-03-13 13:02:42 -07005149
Yiwei Zhang5434a782018-12-05 18:06:32 -08005150 StringAppendF(&result, " PRESENT_TIME_OFFSET=%" PRId64, dispSyncPresentTimeOffset);
5151 StringAppendF(&result, " FORCE_HWC_FOR_RBG_TO_YUV=%d", useHwcForRgbToYuv);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08005152 StringAppendF(&result, " MAX_VIRT_DISPLAY_DIM=%zu",
5153 getHwComposer().getMaxVirtualDisplayDimension());
Yiwei Zhang5434a782018-12-05 18:06:32 -08005154 StringAppendF(&result, " RUNNING_WITHOUT_SYNC_FRAMEWORK=%d", !hasSyncFramework);
5155 StringAppendF(&result, " NUM_FRAMEBUFFER_SURFACE_BUFFERS=%" PRId64,
5156 maxFrameBufferAcquiredBuffers);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08005157 result.append("]");
Andy McFadden4803b742012-09-24 19:07:20 -07005158}
5159
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08005160void SurfaceFlinger::dumpVSync(std::string& result) const {
Dominik Laskowski98041832019-08-01 18:35:59 -07005161 mScheduler->dump(result);
Dominik Laskowski98041832019-08-01 18:35:59 -07005162
Steven Thomas2bbaabe2019-08-28 16:08:35 -07005163 mRefreshRateStats->dump(result);
Dominik Laskowski98041832019-08-01 18:35:59 -07005164 result.append("\n");
5165
Ady Abraham8287e852020-08-12 14:44:58 -07005166 mVsyncConfiguration->dump(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08005167 StringAppendF(&result,
Dominik Laskowski98041832019-08-01 18:35:59 -07005168 " present offset: %9" PRId64 " ns\t VSYNC period: %9" PRId64 " ns\n\n",
Ady Abraham2492a022020-07-24 11:09:55 -07005169 dispSyncPresentTimeOffset, getVsyncPeriodFromHWC());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08005170
Marin Shalamanova7fe3042021-01-29 21:02:08 +01005171 StringAppendF(&result, "(mode override by backdoor: %s)\n\n",
5172 mDebugDisplayModeSetByBackdoor ? "yes" : "no");
Dominik Laskowski98041832019-08-01 18:35:59 -07005173
Ana Krulecc2870422019-01-29 19:00:58 -08005174 mScheduler->dump(mAppConnectionHandle, result);
Ady Abraham8cb21882020-08-26 18:22:05 -07005175 mScheduler->dumpVsync(result);
Ady Abraham4f960d12021-10-13 16:59:49 -07005176 StringAppendF(&result, "mHWCVsyncPendingState=%s mLastHWCVsyncState=%s\n",
5177 to_string(mHWCVsyncPendingState).c_str(), to_string(mLastHWCVsyncState).c_str());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08005178}
5179
Dan Stoza269dc4d2021-01-15 15:07:43 -08005180void SurfaceFlinger::dumpPlannerInfo(const DumpArgs& args, std::string& result) const {
5181 for (const auto& [token, display] : mDisplays) {
5182 const auto compositionDisplay = display->getCompositionDisplay();
5183 compositionDisplay->dumpPlannerInfo(args, result);
5184 }
5185}
5186
Yiwei Zhang5434a782018-12-05 18:06:32 -08005187void SurfaceFlinger::dumpStaticScreenStats(std::string& result) const {
5188 result.append("Static screen stats:\n");
David Sodman4a36e932017-11-07 14:29:47 -08005189 for (size_t b = 0; b < SurfaceFlingerBE::NUM_BUCKETS - 1; ++b) {
5190 float bucketTimeSec = getBE().mFrameBuckets[b] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08005191 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08005192 static_cast<float>(getBE().mFrameBuckets[b]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08005193 StringAppendF(&result, " < %zd frames: %.3f s (%.1f%%)\n", b + 1, bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08005194 }
David Sodman4a36e932017-11-07 14:29:47 -08005195 float bucketTimeSec = getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08005196 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08005197 static_cast<float>(getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08005198 StringAppendF(&result, " %zd+ frames: %.3f s (%.1f%%)\n", SurfaceFlingerBE::NUM_BUCKETS - 1,
5199 bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08005200}
5201
Dominik Laskowski0acc3842022-04-07 11:23:42 -07005202void SurfaceFlinger::dumpCompositionDisplays(std::string& result) const {
5203 for (const auto& [token, display] : mDisplays) {
5204 display->getCompositionDisplay()->dump(result);
5205 result += '\n';
5206 }
5207}
5208
5209void SurfaceFlinger::dumpDisplays(std::string& result) const {
5210 for (const auto& [token, display] : mDisplays) {
5211 display->dump(result);
5212 result += '\n';
5213 }
5214}
5215
Yiwei Zhang5434a782018-12-05 18:06:32 -08005216void SurfaceFlinger::dumpDisplayIdentificationData(std::string& result) const {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07005217 for (const auto& [token, display] : mDisplays) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02005218 const auto displayId = PhysicalDisplayId::tryCast(display->getId());
Dominik Laskowski075d3172018-05-24 15:50:06 -07005219 if (!displayId) {
5220 continue;
5221 }
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02005222 const auto hwcDisplayId = getHwComposer().fromPhysicalDisplayId(*displayId);
Dominik Laskowski7e045462018-05-30 13:02:02 -07005223 if (!hwcDisplayId) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07005224 continue;
5225 }
5226
Yiwei Zhang5434a782018-12-05 18:06:32 -08005227 StringAppendF(&result,
5228 "Display %s (HWC display %" PRIu64 "): ", to_string(*displayId).c_str(),
5229 *hwcDisplayId);
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07005230 uint8_t port;
5231 DisplayIdentificationData data;
Dominik Laskowski7e045462018-05-30 13:02:02 -07005232 if (!getHwComposer().getDisplayIdentificationData(*hwcDisplayId, &port, &data)) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07005233 result.append("no identification data\n");
5234 continue;
5235 }
5236
5237 if (!isEdid(data)) {
Dominik Laskowskib6e54372019-09-04 14:06:28 -07005238 result.append("unknown identification data\n");
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07005239 continue;
5240 }
5241
5242 const auto edid = parseEdid(data);
5243 if (!edid) {
Dominik Laskowskib6e54372019-09-04 14:06:28 -07005244 result.append("invalid EDID\n");
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07005245 continue;
5246 }
5247
Yiwei Zhang5434a782018-12-05 18:06:32 -08005248 StringAppendF(&result, "port=%u pnpId=%s displayName=\"", port, edid->pnpId.data());
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07005249 result.append(edid->displayName.data(), edid->displayName.length());
5250 result.append("\"\n");
5251 }
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07005252}
5253
Dominik Laskowskib6e54372019-09-04 14:06:28 -07005254void SurfaceFlinger::dumpRawDisplayIdentificationData(const DumpArgs& args,
5255 std::string& result) const {
Peiyong Line9d809e2020-04-14 13:10:48 -07005256 hal::HWDisplayId hwcDisplayId;
Dominik Laskowskib6e54372019-09-04 14:06:28 -07005257 uint8_t port;
5258 DisplayIdentificationData data;
5259
5260 if (args.size() > 1 && base::ParseUint(String8(args[1]), &hwcDisplayId) &&
5261 getHwComposer().getDisplayIdentificationData(hwcDisplayId, &port, &data)) {
5262 result.append(reinterpret_cast<const char*>(data.data()), data.size());
5263 }
5264}
5265
Yiwei Zhang5434a782018-12-05 18:06:32 -08005266void SurfaceFlinger::dumpWideColorInfo(std::string& result) const {
Peiyong Linff84a152019-05-17 18:36:19 -07005267 StringAppendF(&result, "Device has wide color built-in display: %d\n", hasWideColorDisplay);
Yiwei Zhang5434a782018-12-05 18:06:32 -08005268 StringAppendF(&result, "Device uses color management: %d\n", useColorManagement);
5269 StringAppendF(&result, "DisplayColorSetting: %s\n",
5270 decodeDisplayColorSetting(mDisplayColorSetting).c_str());
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06005271
5272 // TODO: print out if wide-color mode is active or not
5273
Dominik Laskowski9fae1022018-05-29 13:17:40 -07005274 for (const auto& [token, display] : mDisplays) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02005275 const auto displayId = PhysicalDisplayId::tryCast(display->getId());
Dominik Laskowski075d3172018-05-24 15:50:06 -07005276 if (!displayId) {
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06005277 continue;
5278 }
5279
Yiwei Zhang5434a782018-12-05 18:06:32 -08005280 StringAppendF(&result, "Display %s color modes:\n", to_string(*displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07005281 std::vector<ColorMode> modes = getHwComposer().getColorModes(*displayId);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06005282 for (auto&& mode : modes) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08005283 StringAppendF(&result, " %s (%d)\n", decodeColorMode(mode).c_str(), mode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06005284 }
5285
Lloyd Pique32cbe282018-10-19 13:09:22 -07005286 ColorMode currentMode = display->getCompositionDisplay()->getState().colorMode;
Yiwei Zhang5434a782018-12-05 18:06:32 -08005287 StringAppendF(&result, " Current color mode: %s (%d)\n",
5288 decodeColorMode(currentMode).c_str(), currentMode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06005289 }
5290 result.append("\n");
5291}
5292
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07005293LayersProto SurfaceFlinger::dumpDrawingStateProto(uint32_t traceFlags) const {
chaviw1d044282017-09-27 12:19:28 -07005294 LayersProto layersProto;
chaviw08f3cb22020-01-13 13:17:21 -08005295 for (const sp<Layer>& layer : mDrawingState.layersSortedByZ) {
Vishnu Naird8f5e9f2022-02-03 10:23:28 -08005296 layer->writeToProto(layersProto, traceFlags);
chaviw08f3cb22020-01-13 13:17:21 -08005297 }
Alec Mouri6b9e9912020-01-21 10:50:24 -08005298
chaviw1d044282017-09-27 12:19:28 -07005299 return layersProto;
5300}
5301
chaviw0a398992021-08-13 10:13:01 -05005302void SurfaceFlinger::dumpDisplayProto(LayersTraceProto& layersTraceProto) const {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08005303 for (const auto& [_, display] : FTL_FAKE_GUARD(mStateLock, mDisplays)) {
chaviw0a398992021-08-13 10:13:01 -05005304 DisplayProto* displayProto = layersTraceProto.add_displays();
5305 displayProto->set_id(display->getId().value);
5306 displayProto->set_name(display->getDisplayName());
5307 displayProto->set_layer_stack(display->getLayerStack().id);
5308 LayerProtoHelper::writeSizeToProto(display->getWidth(), display->getHeight(),
5309 [&]() { return displayProto->mutable_size(); });
5310 LayerProtoHelper::writeToProto(display->getLayerStackSpaceRect(), [&]() {
5311 return displayProto->mutable_layer_stack_space_rect();
5312 });
5313 LayerProtoHelper::writeTransformToProto(display->getTransform(),
5314 displayProto->mutable_transform());
Vishnu Nair791d48a2021-12-02 16:55:13 -08005315 displayProto->set_is_virtual(display->isVirtual());
chaviw0a398992021-08-13 10:13:01 -05005316 }
5317}
5318
Alec Mouri6b9e9912020-01-21 10:50:24 -08005319void SurfaceFlinger::dumpHwc(std::string& result) const {
5320 getHwComposer().dump(result);
5321}
5322
Vishnu Nair0f085c62019-08-30 08:49:12 -07005323void SurfaceFlinger::dumpOffscreenLayersProto(LayersProto& layersProto, uint32_t traceFlags) const {
5324 // Add a fake invisible root layer to the proto output and parent all the offscreen layers to
5325 // it.
5326 LayerProto* rootProto = layersProto.add_layers();
5327 const int32_t offscreenRootLayerId = INT32_MAX - 2;
5328 rootProto->set_id(offscreenRootLayerId);
5329 rootProto->set_name("Offscreen Root");
Vishnu Naird5aeb612019-09-20 14:39:39 -07005330 rootProto->set_parent(-1);
Vishnu Nair0f085c62019-08-30 08:49:12 -07005331
5332 for (Layer* offscreenLayer : mOffscreenLayers) {
5333 // Add layer as child of the fake root
5334 rootProto->add_children(offscreenLayer->sequence);
5335
5336 // Add layer
Vishnu Naird8f5e9f2022-02-03 10:23:28 -08005337 LayerProto* layerProto = offscreenLayer->writeToProto(layersProto, traceFlags);
Vishnu Nair0f085c62019-08-30 08:49:12 -07005338 layerProto->set_parent(offscreenRootLayerId);
Vishnu Nair0f085c62019-08-30 08:49:12 -07005339 }
5340}
5341
Vishnu Nair8406fd72019-07-30 11:29:31 -07005342LayersProto SurfaceFlinger::dumpProtoFromMainThread(uint32_t traceFlags) {
Dominik Laskowski756b7892021-08-04 12:53:59 -07005343 return mScheduler->schedule([=] { return dumpDrawingStateProto(traceFlags); }).get();
Vishnu Nair8406fd72019-07-30 11:29:31 -07005344}
5345
Vishnu Nair0f085c62019-08-30 08:49:12 -07005346void SurfaceFlinger::dumpOffscreenLayers(std::string& result) {
Dominik Laskowski756b7892021-08-04 12:53:59 -07005347 auto future = mScheduler->schedule([this] {
5348 std::string result;
5349 for (Layer* offscreenLayer : mOffscreenLayers) {
5350 offscreenLayer->traverse(LayerVector::StateSet::Drawing,
5351 [&](Layer* layer) { layer->dumpCallingUidPid(result); });
5352 }
5353 return result;
5354 });
5355
Vishnu Nair0f085c62019-08-30 08:49:12 -07005356 result.append("Offscreen Layers:\n");
Dominik Laskowski756b7892021-08-04 12:53:59 -07005357 result.append(future.get());
Vishnu Nair0f085c62019-08-30 08:49:12 -07005358}
5359
Alec Mouri3b3e5912022-09-26 21:37:01 +00005360void SurfaceFlinger::dumpAllLocked(const DumpArgs& args, const std::string& compositionLayers,
5361 std::string& result) const {
Dominik Laskowskic2867142019-01-21 11:33:38 -08005362 const bool colorize = !args.empty() && args[0] == String16("--color");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005363 Colorizer colorizer(colorize);
5364
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005365 // figure out if we're stuck somewhere
5366 const nsecs_t now = systemTime();
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005367 const nsecs_t inTransaction(mDebugInTransaction);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005368 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
5369
5370 /*
Andy McFadden4803b742012-09-24 19:07:20 -07005371 * Dump library configuration.
5372 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005373
5374 colorizer.bold(result);
Andy McFadden4803b742012-09-24 19:07:20 -07005375 result.append("Build configuration:");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005376 colorizer.reset(result);
Andy McFadden4803b742012-09-24 19:07:20 -07005377 appendSfConfigString(result);
Andy McFadden4803b742012-09-24 19:07:20 -07005378 result.append("\n");
5379
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07005380 result.append("\nDisplay identification data:\n");
5381 dumpDisplayIdentificationData(result);
5382
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06005383 result.append("\nWide-Color information:\n");
5384 dumpWideColorInfo(result);
5385
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005386 colorizer.bold(result);
Mathias Agopianca088332013-03-28 17:44:13 -07005387 result.append("Sync configuration: ");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005388 colorizer.reset(result);
Mathias Agopianca088332013-03-28 17:44:13 -07005389 result.append(SyncFeatures::getInstance().toString());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08005390 result.append("\n\n");
Mathias Agopianca088332013-03-28 17:44:13 -07005391
Andy McFadden41d67d72014-04-25 16:58:34 -07005392 colorizer.bold(result);
Dominik Laskowski98041832019-08-01 18:35:59 -07005393 result.append("Scheduler:\n");
Andy McFadden41d67d72014-04-25 16:58:34 -07005394 colorizer.reset(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08005395 dumpVSync(result);
Dan Stozab90cf072015-03-05 11:05:59 -08005396 result.append("\n");
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08005397
Dan Stozab90cf072015-03-05 11:05:59 -08005398 dumpStaticScreenStats(result);
5399 result.append("\n");
5400
Alec Mouri40189b02019-03-05 15:07:54 -08005401 StringAppendF(&result, "Total missed frame count: %u\n", mFrameMissedCount.load());
5402 StringAppendF(&result, "HWC missed frame count: %u\n", mHwcFrameMissedCount.load());
5403 StringAppendF(&result, "GPU missed frame count: %u\n\n", mGpuFrameMissedCount.load());
Marissa Wallcfcdaa52018-05-21 15:45:59 -07005404
Andy McFadden4803b742012-09-24 19:07:20 -07005405 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005406 * Dump the visible layer list
5407 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005408 colorizer.bold(result);
chaviweadf0d42019-08-12 13:28:29 -07005409 StringAppendF(&result, "Visible layers (count = %zu)\n", mNumLayers.load());
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005410 colorizer.reset(result);
chaviw1d044282017-09-27 12:19:28 -07005411
Alec Mouri3b3e5912022-09-26 21:37:01 +00005412 result.append(compositionLayers);
Lloyd Pique207def92019-02-28 16:09:52 -08005413
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005414 colorizer.bold(result);
Yiwei Zhang5434a782018-12-05 18:06:32 -08005415 StringAppendF(&result, "Displays (%zu entries)\n", mDisplays.size());
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005416 colorizer.reset(result);
Dominik Laskowski0acc3842022-04-07 11:23:42 -07005417 dumpDisplays(result);
5418 dumpCompositionDisplays(result);
5419 result.push_back('\n');
Lloyd Piquec3cb7292019-05-17 15:25:14 -07005420
5421 mCompositionEngine->dump(result);
5422
5423 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005424 * Dump SurfaceFlinger global state
5425 */
5426
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005427 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02005428 result.append("SurfaceFlinger global state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005429 colorizer.reset(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005430
Lloyd Piqueb97e04f2018-10-18 17:07:05 -07005431 getRenderEngine().dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005432
Robert Carrbeba6f02021-02-10 21:06:27 -08005433 result.append("ClientCache state:\n");
5434 ClientCache::getInstance().dump(result);
Ady Abrahama3b08ef2019-07-15 18:43:10 -07005435 DebugEGLImageTracker::getInstance()->dump(result);
5436
Dominik Laskowski075d3172018-05-24 15:50:06 -07005437 if (const auto display = getDefaultDisplayDeviceLocked()) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07005438 display->getCompositionDisplay()->getState().undefinedRegion.dump(result,
5439 "undefinedRegion");
Dominik Laskowski718f9602019-11-09 20:01:35 -08005440 StringAppendF(&result, " orientation=%s, isPoweredOn=%d\n",
5441 toCString(display->getOrientation()), display->isPoweredOn());
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08005442 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08005443 StringAppendF(&result,
5444 " transaction-flags : %08x\n"
5445 " gpu_to_cpu_unsupported : %d\n",
5446 mTransactionFlags.load(), !mGpuToCpuSupported);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07005447
Marin Shalamanov045b7002021-01-07 16:56:24 +01005448 if (const auto display = getDefaultDisplayDeviceLocked()) {
Marin Shalamanov9afcbd82020-08-19 12:34:59 +02005449 std::string fps, xDpi, yDpi;
Marin Shalamanov045b7002021-01-07 16:56:24 +01005450 if (const auto activeMode = display->getActiveMode()) {
5451 fps = to_string(activeMode->getFps());
Dominik Laskowskib0054a22022-03-03 09:03:06 -08005452
5453 const auto dpi = activeMode->getDpi();
5454 xDpi = base::StringPrintf("%.2f", dpi.x);
5455 yDpi = base::StringPrintf("%.2f", dpi.y);
Marin Shalamanov9afcbd82020-08-19 12:34:59 +02005456 } else {
5457 fps = "unknown";
5458 xDpi = "unknown";
5459 yDpi = "unknown";
5460 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08005461 StringAppendF(&result,
Marin Shalamanov9afcbd82020-08-19 12:34:59 +02005462 " refresh-rate : %s\n"
5463 " x-dpi : %s\n"
5464 " y-dpi : %s\n",
5465 fps.c_str(), xDpi.c_str(), yDpi.c_str());
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07005466 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005467
Yiwei Zhang5434a782018-12-05 18:06:32 -08005468 StringAppendF(&result, " transaction time: %f us\n", inTransactionDuration / 1000.0);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005469
Dan Stozae22aec72016-08-01 13:20:59 -07005470 /*
Yichi Chenadc69612018-09-15 14:51:18 +08005471 * Tracing state
5472 */
Vishnu Nair00b90132021-11-05 14:03:40 -07005473 mLayerTracing.dump(result);
Dominik Laskowski46471e62022-01-14 15:34:03 -08005474
5475 result.append("\nTransaction tracing: ");
5476 if (mTransactionTracing) {
5477 result.append("enabled\n");
5478 mTransactionTracing->dump(result);
5479 } else {
5480 result.append("disabled\n");
5481 }
5482 result.push_back('\n');
Yichi Chenadc69612018-09-15 14:51:18 +08005483
5484 /*
Dan Stozae22aec72016-08-01 13:20:59 -07005485 * HWC layer minidump
5486 */
Dominik Laskowski9fae1022018-05-29 13:17:40 -07005487 for (const auto& [token, display] : mDisplays) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02005488 const auto displayId = HalDisplayId::tryCast(display->getId());
Dominik Laskowski075d3172018-05-24 15:50:06 -07005489 if (!displayId) {
Dan Stozae22aec72016-08-01 13:20:59 -07005490 continue;
5491 }
5492
Siddharth Kapoorecc45ae2021-09-06 19:03:06 +08005493 StringAppendF(&result, "Display %s (%s) HWC layers:\n", to_string(*displayId).c_str(),
5494 (isDisplayActiveLocked(display) ? "active" : "inactive"));
Dan Stozae22aec72016-08-01 13:20:59 -07005495 Layer::miniDumpHeader(result);
Dominik Laskowskib7251f42020-04-20 17:42:59 -07005496
5497 const DisplayDevice& ref = *display;
5498 mCurrentState.traverseInZOrder([&](Layer* layer) { layer->miniDump(result, ref); });
Dan Stozae22aec72016-08-01 13:20:59 -07005499 result.append("\n");
5500 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005501
Ady Abraham2790e9f2021-04-28 13:14:20 -07005502 {
5503 DumpArgs plannerArgs;
5504 plannerArgs.add(); // first argument is ignored
5505 plannerArgs.add(String16("--layers"));
5506 dumpPlannerInfo(plannerArgs, result);
5507 }
5508
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005509 /*
5510 * Dump HWComposer state
5511 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005512 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02005513 result.append("h/w composer state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005514 colorizer.reset(result);
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07005515 const bool hwcDisabled = mDebugDisableHWC || mDebugFlashDelay;
Yiwei Zhang5434a782018-12-05 18:06:32 -08005516 StringAppendF(&result, " h/w composer %s\n", hwcDisabled ? "disabled" : "enabled");
Ady Abrahamc4acf512022-02-18 17:11:59 -08005517 dumpHwc(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005518
5519 /*
5520 * Dump gralloc state
5521 */
5522 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
5523 alloc.dump(result);
Karthik Ravi Shankar171155a2017-06-28 15:40:24 -07005524
rnleea2ecd832021-07-29 13:58:30 -07005525 /*
5526 * Dump flag/property manager state
5527 */
Robert Carr9b623c32022-03-21 15:55:22 -07005528 mFlagManager.dump(result);
rnleea2ecd832021-07-29 13:58:30 -07005529
Yiwei Zhang7eb58b72019-04-22 19:00:02 -07005530 result.append(mTimeStats->miniDump());
5531 result.append("\n");
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005532}
5533
chaviw17ac24b2021-01-28 18:50:05 -08005534mat4 SurfaceFlinger::calculateColorMatrix(float saturation) {
5535 if (saturation == 1) {
5536 return mat4();
Chia-I Wu28f320b2018-05-03 11:02:56 -07005537 }
5538
chaviw17ac24b2021-01-28 18:50:05 -08005539 float3 luminance{0.213f, 0.715f, 0.072f};
5540 luminance *= 1.0f - saturation;
5541 mat4 saturationMatrix = mat4(vec4{luminance.r + saturation, luminance.r, luminance.r, 0.0f},
5542 vec4{luminance.g, luminance.g + saturation, luminance.g, 0.0f},
5543 vec4{luminance.b, luminance.b, luminance.b + saturation, 0.0f},
5544 vec4{0.0f, 0.0f, 0.0f, 1.0f});
5545 return saturationMatrix;
5546}
5547
5548void SurfaceFlinger::updateColorMatrixLocked() {
5549 mat4 colorMatrix =
5550 mClientColorMatrix * calculateColorMatrix(mGlobalSaturationFactor) * mDaltonizer();
5551
Chia-I Wu28f320b2018-05-03 11:02:56 -07005552 if (mCurrentState.colorMatrix != colorMatrix) {
5553 mCurrentState.colorMatrix = colorMatrix;
5554 mCurrentState.colorMatrixChanged = true;
5555 setTransactionFlags(eTransactionNeeded);
5556 }
5557}
5558
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07005559status_t SurfaceFlinger::CheckTransactCodeCredentials(uint32_t code) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00005560#pragma clang diagnostic push
5561#pragma clang diagnostic error "-Wswitch-enum"
5562 switch (static_cast<ISurfaceComposerTag>(code)) {
Dominik Laskowskif06d68e2021-03-24 19:40:03 -07005563 case ENABLE_VSYNC_INJECTIONS:
5564 case INJECT_VSYNC:
5565 if (!hasMockHwc()) return PERMISSION_DENIED;
5566 [[fallthrough]];
Ana Krulec13be8ad2018-08-21 02:43:56 +00005567 // These methods should at minimum make sure that the client requested
5568 // access to SF.
Dan Stozae3344402018-08-20 19:53:42 +00005569 case BOOT_FINISHED:
5570 case CLEAR_ANIMATION_FRAME_STATS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00005571 case GET_ANIMATION_FRAME_STATS:
Kriti Dang49ad4132021-01-08 11:49:56 +01005572 case OVERRIDE_HDR_TYPES:
Ana Krulec13be8ad2018-08-21 02:43:56 +00005573 case GET_HDR_CAPABILITIES:
Marin Shalamanova7fe3042021-01-29 21:02:08 +01005574 case SET_DESIRED_DISPLAY_MODE_SPECS:
5575 case GET_DESIRED_DISPLAY_MODE_SPECS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00005576 case SET_ACTIVE_COLOR_MODE:
Kriti Dang7defaf32021-11-15 11:55:43 +01005577 case SET_BOOT_DISPLAY_MODE:
Galia Peycheva5492cb52019-10-30 14:13:16 +01005578 case GET_AUTO_LOW_LATENCY_MODE_SUPPORT:
Galia Peycheva5492cb52019-10-30 14:13:16 +01005579 case GET_GAME_CONTENT_TYPE_SUPPORT:
Kevin DuBois74e53772018-11-19 10:52:38 -08005580 case GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES:
Kevin DuBois1d4249a2018-08-29 10:45:14 -07005581 case SET_DISPLAY_CONTENT_SAMPLING_ENABLED:
Ady Abraham8532d012019-05-08 14:50:56 -07005582 case GET_DISPLAYED_CONTENT_SAMPLE:
Galia Peycheva8f04b302021-04-27 13:25:38 +02005583 case ADD_TUNNEL_MODE_ENABLED_LISTENER:
5584 case REMOVE_TUNNEL_MODE_ENABLED_LISTENER:
Steven Thomasd4071902020-03-24 16:02:53 -07005585 case SET_GLOBAL_SHADOW_SETTINGS:
5586 case ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN: {
Marin Shalamanovfa39ee72021-11-01 14:04:27 +01005587 // OVERRIDE_HDR_TYPES is used by CTS tests, which acquire the necessary
5588 // permission dynamically. Don't use the permission cache for this check.
5589 bool usePermissionCache = code != OVERRIDE_HDR_TYPES;
Steven Thomasd4071902020-03-24 16:02:53 -07005590 if (!callingThreadHasUnscopedSurfaceFlingerAccess(usePermissionCache)) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07005591 IPCThreadState* ipc = IPCThreadState::self();
5592 ALOGE("Permission Denial: can't access SurfaceFlinger pid=%d, uid=%d",
5593 ipc->getCallingPid(), ipc->getCallingUid());
Mathias Agopian375f5632009-06-15 18:24:59 -07005594 return PERMISSION_DENIED;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005595 }
Robert Carr1db73f62016-12-21 12:58:51 -08005596 return OK;
5597 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00005598 case GET_LAYER_DEBUG_INFO: {
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07005599 IPCThreadState* ipc = IPCThreadState::self();
5600 const int pid = ipc->getCallingPid();
5601 const int uid = ipc->getCallingUid();
Ana Krulec13be8ad2018-08-21 02:43:56 +00005602 if ((uid != AID_SHELL) && !PermissionCache::checkPermission(sDump, pid, uid)) {
5603 ALOGE("Layer debug info permission denied for pid=%d, uid=%d", pid, uid);
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07005604 return PERMISSION_DENIED;
5605 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00005606 return OK;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005607 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00005608 // Used by apps to hook Choreographer to SurfaceFlinger.
5609 case CREATE_DISPLAY_EVENT_CONNECTION:
5610 // The following calls are currently used by clients that do not
5611 // request necessary permissions. However, they do not expose any secret
5612 // information, so it is OK to pass them.
5613 case AUTHENTICATE_SURFACE:
Peiyong Lind1fedb42019-03-11 17:48:41 -07005614 case GET_ACTIVE_COLOR_MODE:
Marin Shalamanova7fe3042021-01-29 21:02:08 +01005615 case GET_ACTIVE_DISPLAY_MODE:
Ana Krulec13be8ad2018-08-21 02:43:56 +00005616 case GET_DISPLAY_COLOR_MODES:
Daniel Solomon42d04562019-01-20 21:03:19 -08005617 case GET_DISPLAY_NATIVE_PRIMARIES:
Marin Shalamanov228f46b2021-01-28 21:11:45 +01005618 case GET_STATIC_DISPLAY_INFO:
5619 case GET_DYNAMIC_DISPLAY_INFO:
Marin Shalamanova7fe3042021-01-29 21:02:08 +01005620 case GET_DISPLAY_MODES:
Ana Krulec13be8ad2018-08-21 02:43:56 +00005621 case GET_SUPPORTED_FRAME_TIMESTAMPS:
5622 // Calling setTransactionState is safe, because you need to have been
5623 // granted a reference to Client* and Handle* to do anything with it.
5624 case SET_TRANSACTION_STATE:
Robert Carrb89ea9d2018-12-10 13:01:14 -08005625 case CREATE_CONNECTION:
Ady Abraham37965d42018-11-01 13:43:32 -07005626 case GET_COLOR_MANAGEMENT:
Peiyong Lin3c2791e2019-01-14 17:05:18 -08005627 case GET_COMPOSITION_PREFERENCE:
Marissa Wallebc2c052019-01-16 19:16:55 -08005628 case GET_PROTECTED_CONTENT_SUPPORT:
Steven Thomas62a4cf82020-01-31 12:04:03 -08005629 // setFrameRate() is deliberately available for apps to call without any
5630 // special permissions.
5631 case SET_FRAME_RATE:
Leon Scroggins IIIe5cff632021-12-29 11:53:36 -05005632 case GET_DISPLAY_DECORATION_SUPPORT:
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10005633 case SET_FRAME_TIMELINE_INFO:
Ady Abraham564f9de2021-02-03 18:34:33 -08005634 case GET_GPU_CONTEXT_PRIORITY:
Ady Abraham899dcdb2021-06-15 16:56:21 -07005635 case GET_MAX_ACQUIRED_BUFFER_COUNT: {
Ady Abraham564f9de2021-02-03 18:34:33 -08005636 // This is not sensitive information, so should not require permission control.
Ana Krulec13be8ad2018-08-21 02:43:56 +00005637 return OK;
5638 }
Alec Mouric8957ee2021-03-01 14:33:19 -08005639 case ADD_FPS_LISTENER:
5640 case REMOVE_FPS_LISTENER:
Dan Stoza84ab9372018-12-17 15:27:57 -08005641 case ADD_REGION_SAMPLING_LISTENER:
5642 case REMOVE_REGION_SAMPLING_LISTENER: {
Ana Krulec13be8ad2018-08-21 02:43:56 +00005643 // codes that require permission check
chaviwa76b2712017-09-20 12:02:26 -07005644 IPCThreadState* ipc = IPCThreadState::self();
5645 const int pid = ipc->getCallingPid();
5646 const int uid = ipc->getCallingUid();
5647 if ((uid != AID_GRAPHICS) &&
5648 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
5649 ALOGE("Permission Denial: can't read framebuffer pid=%d, uid=%d", pid, uid);
5650 return PERMISSION_DENIED;
5651 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00005652 return OK;
5653 }
Huihong Luo9e84f332021-12-16 14:33:46 -08005654 case ADD_TRANSACTION_TRACE_LISTENER: {
chaviw93df2ea2019-04-30 16:45:12 -07005655 IPCThreadState* ipc = IPCThreadState::self();
5656 const int uid = ipc->getCallingUid();
Peiyong Lin96cfebc2019-05-15 11:36:13 -07005657 if (uid == AID_ROOT || uid == AID_GRAPHICS || uid == AID_SYSTEM || uid == AID_SHELL) {
chaviw93df2ea2019-04-30 16:45:12 -07005658 return OK;
5659 }
5660 return PERMISSION_DENIED;
5661 }
Andy Yu8c38b252022-01-15 01:13:19 -08005662 case SET_OVERRIDE_FRAME_RATE: {
5663 const int uid = IPCThreadState::self()->getCallingUid();
5664 if (uid == AID_ROOT || uid == AID_SYSTEM) {
5665 return OK;
5666 }
5667 return PERMISSION_DENIED;
5668 }
Tej Singhe2751772021-04-06 22:05:29 -07005669 case ON_PULL_ATOM: {
5670 const int uid = IPCThreadState::self()->getCallingUid();
5671 if (uid == AID_SYSTEM) {
5672 return OK;
5673 }
5674 return PERMISSION_DENIED;
5675 }
chaviw60c9d3e2021-06-04 12:52:17 -05005676 case ADD_WINDOW_INFOS_LISTENER:
5677 case REMOVE_WINDOW_INFOS_LISTENER: {
5678 const int uid = IPCThreadState::self()->getCallingUid();
5679 if (uid == AID_SYSTEM || uid == AID_GRAPHICS) {
5680 return OK;
5681 }
5682 return PERMISSION_DENIED;
5683 }
Huihong Luob5cb7c12022-02-14 14:26:04 -08005684 case CREATE_DISPLAY:
5685 case DESTROY_DISPLAY:
5686 case GET_PRIMARY_PHYSICAL_DISPLAY_ID:
5687 case GET_PHYSICAL_DISPLAY_IDS:
5688 case GET_PHYSICAL_DISPLAY_TOKEN:
Huihong Luo694aeff2022-02-15 10:43:00 -08005689 case SET_POWER_MODE:
Huihong Luo0fd1af92022-02-15 10:43:00 -08005690 case GET_DISPLAY_STATE:
5691 case GET_DISPLAY_STATS:
Huihong Luo694aeff2022-02-15 10:43:00 -08005692 case CLEAR_BOOT_DISPLAY_MODE:
5693 case GET_BOOT_DISPLAY_MODE_SUPPORT:
5694 case SET_AUTO_LOW_LATENCY_MODE:
5695 case SET_GAME_CONTENT_TYPE:
Huihong Luo9e84f332021-12-16 14:33:46 -08005696 case CAPTURE_LAYERS:
5697 case CAPTURE_DISPLAY:
5698 case CAPTURE_DISPLAY_BY_ID:
Huihong Luo694aeff2022-02-15 10:43:00 -08005699 case IS_WIDE_COLOR_DISPLAY:
5700 case GET_DISPLAY_BRIGHTNESS_SUPPORT:
5701 case SET_DISPLAY_BRIGHTNESS:
5702 case ADD_HDR_LAYER_INFO_LISTENER:
5703 case REMOVE_HDR_LAYER_INFO_LISTENER:
5704 case NOTIFY_POWER_BOOST:
Huihong Luob5cb7c12022-02-14 14:26:04 -08005705 LOG_FATAL("Deprecated opcode: %d, migrated to AIDL", code);
Huihong Luo9e84f332021-12-16 14:33:46 -08005706 return PERMISSION_DENIED;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005707 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00005708
5709 // These codes are used for the IBinder protocol to either interrogate the recipient
5710 // side of the transaction for its canonical interface descriptor or to dump its state.
5711 // We let them pass by default.
5712 if (code == IBinder::INTERFACE_TRANSACTION || code == IBinder::DUMP_TRANSACTION ||
5713 code == IBinder::PING_TRANSACTION || code == IBinder::SHELL_COMMAND_TRANSACTION ||
5714 code == IBinder::SYSPROPS_TRANSACTION) {
5715 return OK;
5716 }
Nataniel Borges533c2f82022-01-21 12:07:02 +01005717 // Numbers from 1000 to 1042 are currently used for backdoors. The code
Ana Krulec13be8ad2018-08-21 02:43:56 +00005718 // in onTransact verifies that the user is root, and has access to use SF.
Nataniel Borges533c2f82022-01-21 12:07:02 +01005719 if (code >= 1000 && code <= 1042) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00005720 ALOGV("Accessing SurfaceFlinger through backdoor code: %u", code);
5721 return OK;
5722 }
5723 ALOGE("Permission Denial: SurfaceFlinger did not recognize request code: %u", code);
5724 return PERMISSION_DENIED;
5725#pragma clang diagnostic pop
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07005726}
5727
Ana Krulec13be8ad2018-08-21 02:43:56 +00005728status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
5729 uint32_t flags) {
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07005730 if (const status_t error = CheckTransactCodeCredentials(code); error != OK) {
5731 return error;
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07005732 }
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07005733
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005734 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
5735 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
Mathias Agopianb8a55602009-06-26 19:06:36 -07005736 CHECK_INTERFACE(ISurfaceComposer, data, reply);
Romain Guy8c6bbd62017-06-05 13:51:43 -07005737 IPCThreadState* ipc = IPCThreadState::self();
5738 const int uid = ipc->getCallingUid();
5739 if (CC_UNLIKELY(uid != AID_SYSTEM
5740 && !PermissionCache::checkCallingPermission(sHardwareTest))) {
Mathias Agopian375f5632009-06-15 18:24:59 -07005741 const int pid = ipc->getCallingPid();
Steve Blocke6f43dd2012-01-06 19:20:56 +00005742 ALOGE("Permission Denial: "
Mathias Agopian375f5632009-06-15 18:24:59 -07005743 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005744 return PERMISSION_DENIED;
5745 }
5746 int n;
5747 switch (code) {
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07005748 case 1000: // Unused.
5749 case 1001:
5750 return NAME_NOT_FOUND;
5751 case 1002: // Toggle flashing on surface damage.
5752 if (const int delay = data.readInt32(); delay > 0) {
5753 mDebugFlashDelay = delay;
5754 } else {
5755 mDebugFlashDelay = mDebugFlashDelay ? 0 : 1;
5756 }
5757 scheduleRepaint();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005758 return NO_ERROR;
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07005759 case 1004: // Force composite ahead of next VSYNC.
Dominik Laskowski46f3e3b2021-08-10 11:44:24 -07005760 case 1006:
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07005761 scheduleComposite(FrameHint::kActive);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005762 return NO_ERROR;
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07005763 case 1005: { // Force commit ahead of next VSYNC.
5764 Mutex::Autolock lock(mStateLock);
5765 setTransactionFlags(eTransactionNeeded | eDisplayTransactionNeeded |
5766 eTraversalNeeded);
Mathias Agopiancbb288b2009-09-07 16:32:45 -07005767 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005768 }
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07005769 case 1007: // Unused.
5770 return NAME_NOT_FOUND;
5771 case 1008: // Toggle forced GPU composition.
5772 mDebugDisableHWC = data.readInt32() != 0;
5773 scheduleRepaint();
Mathias Agopian53331da2011-08-22 21:44:41 -07005774 return NO_ERROR;
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07005775 case 1009: // Toggle use of transform hint.
5776 mDebugDisableTransformHint = data.readInt32() != 0;
5777 scheduleRepaint();
Mathias Agopiana4583642011-08-23 18:03:18 -07005778 return NO_ERROR;
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07005779 case 1010: // Interrogate.
Mathias Agopian01b76682009-04-16 20:04:08 -07005780 reply->writeInt32(0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005781 reply->writeInt32(0);
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07005782 reply->writeInt32(mDebugFlashDelay);
Mathias Agopianb9494d52012-04-18 02:28:45 -07005783 reply->writeInt32(0);
Dianne Hackborn12839be2012-02-06 21:21:05 -08005784 reply->writeInt32(mDebugDisableHWC);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005785 return NO_ERROR;
5786 case 1013: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005787 const auto display = getDefaultDisplayDevice();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07005788 if (!display) {
5789 return NAME_NOT_FOUND;
5790 }
5791
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005792 reply->writeInt32(display->getPageFlipCount());
Mathias Agopianff2ed702013-09-01 21:36:12 -07005793 return NO_ERROR;
5794 }
5795 case 1014: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005796 Mutex::Autolock _l(mStateLock);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005797 // daltonize
5798 n = data.readInt32();
5799 switch (n % 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005800 case 1:
5801 mDaltonizer.setType(ColorBlindnessType::Protanomaly);
5802 break;
5803 case 2:
5804 mDaltonizer.setType(ColorBlindnessType::Deuteranomaly);
5805 break;
5806 case 3:
5807 mDaltonizer.setType(ColorBlindnessType::Tritanomaly);
5808 break;
5809 default:
5810 mDaltonizer.setType(ColorBlindnessType::None);
5811 break;
Mathias Agopianff2ed702013-09-01 21:36:12 -07005812 }
5813 if (n >= 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005814 mDaltonizer.setMode(ColorBlindnessMode::Correction);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005815 } else {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005816 mDaltonizer.setMode(ColorBlindnessMode::Simulation);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005817 }
Chia-I Wu28f320b2018-05-03 11:02:56 -07005818
5819 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005820 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005821 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005822 case 1015: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005823 Mutex::Autolock _l(mStateLock);
Alan Viverette9c5a3332013-09-12 20:04:35 -07005824 // apply a color matrix
5825 n = data.readInt32();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005826 if (n) {
Romain Guy0147a172017-06-01 13:53:56 -07005827 // color matrix is sent as a column-major mat4 matrix
Alan Viverette794c5ba2013-10-03 16:40:52 -07005828 for (size_t i = 0 ; i < 4; i++) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005829 for (size_t j = 0; j < 4; j++) {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005830 mClientColorMatrix[i][j] = data.readFloat();
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005831 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005832 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005833 } else {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005834 mClientColorMatrix = mat4();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005835 }
Romain Guy88d37dd2017-05-26 17:57:05 -07005836
5837 // Check that supplied matrix's last row is {0,0,0,1} so we can avoid
5838 // the division by w in the fragment shader
Chia-I Wu28f320b2018-05-03 11:02:56 -07005839 float4 lastRow(transpose(mClientColorMatrix)[3]);
Romain Guy88d37dd2017-05-26 17:57:05 -07005840 if (any(greaterThan(abs(lastRow - float4{0, 0, 0, 1}), float4{1e-4f}))) {
5841 ALOGE("The color transform's last row must be (0, 0, 0, 1)");
5842 }
5843
Chia-I Wu28f320b2018-05-03 11:02:56 -07005844 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005845 return NO_ERROR;
5846 }
Dominik Laskowski8d32ddc2019-08-07 11:25:35 -07005847 case 1016: { // Unused.
5848 return NAME_NOT_FOUND;
Ruchi Kandoif52b3c82014-04-24 16:42:35 -07005849 }
Dan Stozaee44edd2015-03-23 15:50:23 -07005850 case 1017: {
5851 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005852 mForceFullDamage = n != 0;
Dan Stozaee44edd2015-03-23 15:50:23 -07005853 return NO_ERROR;
5854 }
Ady Abraham9c53ee72020-07-22 21:16:18 -07005855 case 1018: { // Modify Choreographer's duration
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005856 n = data.readInt32();
Ady Abraham9c53ee72020-07-22 21:16:18 -07005857 mScheduler->setDuration(mAppConnectionHandle, std::chrono::nanoseconds(n), 0ns);
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005858 return NO_ERROR;
5859 }
Ady Abraham9c53ee72020-07-22 21:16:18 -07005860 case 1019: { // Modify SurfaceFlinger's duration
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005861 n = data.readInt32();
Ady Abraham9c53ee72020-07-22 21:16:18 -07005862 mScheduler->setDuration(mSfConnectionHandle, std::chrono::nanoseconds(n), 0ns);
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005863 return NO_ERROR;
5864 }
Irvel468051e2016-06-13 16:44:44 -07005865 case 1020: { // Layer updates interceptor
5866 n = data.readInt32();
5867 if (n) {
5868 ALOGV("Interceptor enabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08005869 mInterceptor->enable(mDrawingState.layersSortedByZ, mDrawingState.displays);
Irvel468051e2016-06-13 16:44:44 -07005870 }
5871 else{
5872 ALOGV("Interceptor disabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08005873 mInterceptor->disable();
Irvel468051e2016-06-13 16:44:44 -07005874 }
5875 return NO_ERROR;
5876 }
Dan Stoza8cf150a2016-08-02 10:27:31 -07005877 case 1021: { // Disable HWC virtual displays
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08005878 const bool enable = data.readInt32() != 0;
Dominik Laskowski756b7892021-08-04 12:53:59 -07005879 static_cast<void>(
5880 mScheduler->schedule([this, enable] { enableHalVirtualDisplays(enable); }));
Dan Stoza8cf150a2016-08-02 10:27:31 -07005881 return NO_ERROR;
5882 }
Romain Guy0147a172017-06-01 13:53:56 -07005883 case 1022: { // Set saturation boost
Chia-I Wu28f320b2018-05-03 11:02:56 -07005884 Mutex::Autolock _l(mStateLock);
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005885 mGlobalSaturationFactor = std::max(0.0f, std::min(data.readFloat(), 2.0f));
Romain Guy0147a172017-06-01 13:53:56 -07005886
Chia-I Wu28f320b2018-05-03 11:02:56 -07005887 updateColorMatrixLocked();
Romain Guy0147a172017-06-01 13:53:56 -07005888 return NO_ERROR;
5889 }
Romain Guy54f154a2017-10-24 21:40:32 +01005890 case 1023: { // Set native mode
Daniel Solomon7c7ede22019-07-11 16:35:40 -07005891 int32_t colorMode;
5892
Chia-I Wu0d711262018-05-21 15:19:35 -07005893 mDisplayColorSetting = static_cast<DisplayColorSetting>(data.readInt32());
Daniel Solomon7c7ede22019-07-11 16:35:40 -07005894 if (data.readInt32(&colorMode) == NO_ERROR) {
5895 mForceColorMode = static_cast<ColorMode>(colorMode);
5896 }
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07005897 scheduleRepaint();
Romain Guy54f154a2017-10-24 21:40:32 +01005898 return NO_ERROR;
5899 }
Peiyong Lin4bac91c2018-10-25 09:48:33 -07005900 // Deprecate, use 1030 to check whether the device is color managed.
5901 case 1024: {
5902 return NAME_NOT_FOUND;
Romain Guy54f154a2017-10-24 21:40:32 +01005903 }
Vishnu Nair87704c92018-01-08 15:32:57 -08005904 case 1025: { // Set layer tracing
Adrian Roos1e1a1282017-11-01 19:05:31 +01005905 n = data.readInt32();
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07005906 bool tracingEnabledChanged;
Vishnu Naird8f5e9f2022-02-03 10:23:28 -08005907 if (n == 1) {
5908 int64_t fixedStartingTime = data.readInt64();
Yichi Chenadc69612018-09-15 14:51:18 +08005909 ALOGD("LayerTracing enabled");
Vishnu Nair00b90132021-11-05 14:03:40 -07005910 tracingEnabledChanged = mLayerTracing.enable();
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07005911 if (tracingEnabledChanged) {
Vishnu Nairb64a3b42022-01-13 15:29:32 -08005912 int64_t startingTime =
5913 (fixedStartingTime) ? fixedStartingTime : systemTime();
5914 mScheduler
Dominik Laskowski298b08e2022-02-15 13:45:02 -08005915 ->schedule([&]() FTL_FAKE_GUARD(mStateLock) {
Vishnu Nairb64a3b42022-01-13 15:29:32 -08005916 mLayerTracing.notify("start", startingTime);
5917 })
Dominik Laskowski756b7892021-08-04 12:53:59 -07005918 .wait();
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07005919 }
Vishnu Naird8f5e9f2022-02-03 10:23:28 -08005920 } else if (n == 2) {
5921 std::string filename = std::string(data.readCString());
5922 ALOGD("LayerTracing disabled. Trace wrote to %s", filename.c_str());
5923 tracingEnabledChanged = mLayerTracing.disable(filename.c_str());
Adrian Roos1e1a1282017-11-01 19:05:31 +01005924 } else {
Yichi Chenadc69612018-09-15 14:51:18 +08005925 ALOGD("LayerTracing disabled");
Vishnu Nair00b90132021-11-05 14:03:40 -07005926 tracingEnabledChanged = mLayerTracing.disable();
Adrian Roos1e1a1282017-11-01 19:05:31 +01005927 }
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07005928 mTracingEnabledChanged = tracingEnabledChanged;
5929 reply->writeInt32(NO_ERROR);
Adrian Roos1e1a1282017-11-01 19:05:31 +01005930 return NO_ERROR;
5931 }
Vishnu Nair87704c92018-01-08 15:32:57 -08005932 case 1026: { // Get layer tracing status
Vishnu Nair00b90132021-11-05 14:03:40 -07005933 reply->writeBool(mLayerTracing.isEnabled());
Vishnu Nair87704c92018-01-08 15:32:57 -08005934 return NO_ERROR;
5935 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005936 // Is a DisplayColorSetting supported?
5937 case 1027: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005938 const auto display = getDefaultDisplayDevice();
5939 if (!display) {
Chia-I Wu0d711262018-05-21 15:19:35 -07005940 return NAME_NOT_FOUND;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005941 }
Chia-I Wu0d711262018-05-21 15:19:35 -07005942
5943 DisplayColorSetting setting = static_cast<DisplayColorSetting>(data.readInt32());
5944 switch (setting) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -08005945 case DisplayColorSetting::kManaged:
Peiyong Lin13effd12018-07-24 17:01:47 -07005946 reply->writeBool(useColorManagement);
Chia-I Wu0d711262018-05-21 15:19:35 -07005947 break;
Lloyd Pique6a3b4462019-03-07 20:58:12 -08005948 case DisplayColorSetting::kUnmanaged:
Chia-I Wu0d711262018-05-21 15:19:35 -07005949 reply->writeBool(true);
5950 break;
Lloyd Pique6a3b4462019-03-07 20:58:12 -08005951 case DisplayColorSetting::kEnhanced:
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005952 reply->writeBool(display->hasRenderIntent(RenderIntent::ENHANCE));
Chia-I Wu0d711262018-05-21 15:19:35 -07005953 break;
5954 default: // vendor display color setting
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005955 reply->writeBool(
5956 display->hasRenderIntent(static_cast<RenderIntent>(setting)));
Chia-I Wu0d711262018-05-21 15:19:35 -07005957 break;
5958 }
5959 return NO_ERROR;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005960 }
Alec Mouri9c58bcd2020-09-09 18:57:07 -07005961 case 1028: { // Unused.
5962 return NAME_NOT_FOUND;
Steven Thomas97f1f4c2018-06-01 12:04:16 -07005963 }
Nataniel Borges2b796da2019-02-15 13:32:18 -08005964 // Set buffer size for SF tracing (value in KB)
5965 case 1029: {
5966 n = data.readInt32();
5967 if (n <= 0 || n > MAX_TRACING_MEMORY) {
5968 ALOGW("Invalid buffer size: %d KB", n);
5969 reply->writeInt32(BAD_VALUE);
5970 return BAD_VALUE;
5971 }
5972
5973 ALOGD("Updating trace buffer to %d KB", n);
Vishnu Nair00b90132021-11-05 14:03:40 -07005974 mLayerTracing.setBufferSize(n * 1024);
Nataniel Borges2b796da2019-02-15 13:32:18 -08005975 reply->writeInt32(NO_ERROR);
5976 return NO_ERROR;
5977 }
Peiyong Lin13effd12018-07-24 17:01:47 -07005978 // Is device color managed?
5979 case 1030: {
5980 reply->writeBool(useColorManagement);
5981 return NO_ERROR;
5982 }
Peiyong Lin9d846a52018-11-05 13:18:20 -08005983 // Override default composition data space
5984 // adb shell service call SurfaceFlinger 1031 i32 1 DATASPACE_NUMBER DATASPACE_NUMBER \
5985 // && adb shell stop zygote && adb shell start zygote
5986 // to restore: adb shell service call SurfaceFlinger 1031 i32 0 && \
5987 // adb shell stop zygote && adb shell start zygote
5988 case 1031: {
5989 Mutex::Autolock _l(mStateLock);
5990 n = data.readInt32();
5991 if (n) {
5992 n = data.readInt32();
5993 if (n) {
5994 Dataspace dataspace = static_cast<Dataspace>(n);
5995 if (!validateCompositionDataspace(dataspace)) {
5996 return BAD_VALUE;
5997 }
5998 mDefaultCompositionDataspace = dataspace;
5999 }
6000 n = data.readInt32();
6001 if (n) {
6002 Dataspace dataspace = static_cast<Dataspace>(n);
6003 if (!validateCompositionDataspace(dataspace)) {
6004 return BAD_VALUE;
6005 }
6006 mWideColorGamutCompositionDataspace = dataspace;
6007 }
6008 } else {
6009 // restore composition data space.
6010 mDefaultCompositionDataspace = defaultCompositionDataspace;
6011 mWideColorGamutCompositionDataspace = wideColorGamutCompositionDataspace;
6012 }
6013 return NO_ERROR;
6014 }
Vishnu Nair9245d3b2019-03-22 13:38:56 -07006015 // Set trace flags
6016 case 1033: {
6017 n = data.readUint32();
6018 ALOGD("Updating trace flags to 0x%x", n);
Vishnu Nair00b90132021-11-05 14:03:40 -07006019 mLayerTracing.setTraceFlags(n);
Vishnu Nair9245d3b2019-03-22 13:38:56 -07006020 reply->writeInt32(NO_ERROR);
6021 return NO_ERROR;
6022 }
Ady Abraham03b02dd2019-03-21 15:40:11 -07006023 case 1034: {
Dominik Laskowski756b7892021-08-04 12:53:59 -07006024 auto future = mScheduler->schedule([&] {
Ady Abraham1b11bc62021-06-03 19:51:19 -07006025 switch (n = data.readInt32()) {
6026 case 0:
6027 case 1:
Dominik Laskowski298b08e2022-02-15 13:45:02 -08006028 FTL_FAKE_GUARD(mStateLock,
6029 enableRefreshRateOverlay(static_cast<bool>(n)));
Ady Abraham1b11bc62021-06-03 19:51:19 -07006030 break;
6031 default: {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08006032 reply->writeBool(
6033 FTL_FAKE_GUARD(mStateLock, isRefreshRateOverlayEnabled()));
Ady Abraham1b11bc62021-06-03 19:51:19 -07006034 }
Dominik Laskowski20134642020-04-20 22:36:44 -07006035 }
Dominik Laskowski756b7892021-08-04 12:53:59 -07006036 });
6037
6038 future.wait();
Ady Abraham03b02dd2019-03-21 15:40:11 -07006039 return NO_ERROR;
6040 }
Ady Abraham34392f72019-04-10 11:29:27 -07006041 case 1035: {
Marin Shalamanov5801c942020-12-17 17:00:13 +01006042 const int modeId = data.readInt32();
Marin Shalamanov5801c942020-12-17 17:00:13 +01006043
Dominik Laskowskif1833852021-03-23 15:06:50 -07006044 const auto display = [&]() -> sp<IBinder> {
6045 uint64_t value;
6046 if (data.readUint64(&value) != NO_ERROR) {
Ady Abrahamed3290f2021-05-17 15:12:14 -07006047 return getDefaultDisplayDevice()->getDisplayToken().promote();
Ady Abrahamfb853662021-04-09 11:46:40 -07006048 }
6049
Dominik Laskowskif1833852021-03-23 15:06:50 -07006050 if (const auto id = DisplayId::fromValue<PhysicalDisplayId>(value)) {
6051 return getPhysicalDisplayToken(*id);
6052 }
6053
6054 ALOGE("Invalid physical display ID");
6055 return nullptr;
Ady Abrahamfb853662021-04-09 11:46:40 -07006056 }();
6057
Shiyong Li2bcece92021-08-30 20:38:50 +00006058 mDebugDisplayModeSetByBackdoor = false;
Marin Shalamanov85b2bdf2021-11-03 14:31:21 +01006059 const status_t result = setActiveModeFromBackdoor(display, modeId);
Dominik Laskowskif1833852021-03-23 15:06:50 -07006060 mDebugDisplayModeSetByBackdoor = result == NO_ERROR;
6061 return result;
Ady Abraham34392f72019-04-10 11:29:27 -07006062 }
Marin Shalamanovfa39ee72021-11-01 14:04:27 +01006063 // Turn on/off frame rate flexibility mode. When turned on it overrides the display
6064 // manager frame rate policy a new policy which allows switching between all refresh
6065 // rates.
Ady Abraham07e54702020-04-16 15:05:37 -07006066 case 1036: {
Marin Shalamanovfa39ee72021-11-01 14:04:27 +01006067 if (data.readInt32() > 0) { // turn on
Dominik Laskowski756b7892021-08-04 12:53:59 -07006068 return mScheduler
6069 ->schedule([this] {
6070 const auto display =
Dominik Laskowski298b08e2022-02-15 13:45:02 -08006071 FTL_FAKE_GUARD(mStateLock, getDefaultDisplayDeviceLocked());
Marin Shalamanovfa39ee72021-11-01 14:04:27 +01006072
Dominik Laskowski756b7892021-08-04 12:53:59 -07006073 // This is a little racy, but not in a way that hurts anything. As
6074 // we grab the defaultMode from the display manager policy, we could
6075 // be setting a new display manager policy, leaving us using a stale
6076 // defaultMode. The defaultMode doesn't matter for the override
6077 // policy though, since we set allowGroupSwitching to true, so it's
6078 // not a problem.
6079 scheduler::RefreshRateConfigs::Policy overridePolicy;
6080 overridePolicy.defaultMode = display->refreshRateConfigs()
6081 .getDisplayManagerPolicy()
6082 .defaultMode;
6083 overridePolicy.allowGroupSwitching = true;
6084 constexpr bool kOverridePolicy = true;
6085 return setDesiredDisplayModeSpecsInternal(display, overridePolicy,
6086 kOverridePolicy);
6087 })
Marin Shalamanovfa39ee72021-11-01 14:04:27 +01006088 .get();
6089 } else { // turn off
Dominik Laskowski756b7892021-08-04 12:53:59 -07006090 return mScheduler
6091 ->schedule([this] {
6092 const auto display =
Dominik Laskowski298b08e2022-02-15 13:45:02 -08006093 FTL_FAKE_GUARD(mStateLock, getDefaultDisplayDeviceLocked());
Dominik Laskowski756b7892021-08-04 12:53:59 -07006094 constexpr bool kOverridePolicy = true;
6095 return setDesiredDisplayModeSpecsInternal(display, {},
6096 kOverridePolicy);
6097 })
Marin Shalamanovfa39ee72021-11-01 14:04:27 +01006098 .get();
Ady Abraham07e54702020-04-16 15:05:37 -07006099 }
Ady Abraham07e54702020-04-16 15:05:37 -07006100 }
Marin Shalamanove6332b02020-09-03 11:30:37 +02006101 // Inject a hotplug connected event for the primary display. This will deallocate and
6102 // reallocate the display state including framebuffers.
6103 case 1037: {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07006104 const hal::HWDisplayId hwcId =
6105 (Mutex::Autolock(mStateLock), getHwComposer().getPrimaryHwcDisplayId());
6106
6107 onComposerHalHotplug(hwcId, hal::Connection::CONNECTED);
Marin Shalamanove6332b02020-09-03 11:30:37 +02006108 return NO_ERROR;
6109 }
Adithya Srinivasan2d736322020-10-01 16:53:48 -07006110 // Modify the max number of display frames stored within FrameTimeline
6111 case 1038: {
6112 n = data.readInt32();
6113 if (n < 0 || n > MAX_ALLOWED_DISPLAY_FRAMES) {
6114 ALOGW("Invalid max size. Maximum allowed is %d", MAX_ALLOWED_DISPLAY_FRAMES);
6115 return BAD_VALUE;
6116 }
6117 if (n == 0) {
6118 // restore to default
6119 mFrameTimeline->reset();
6120 return NO_ERROR;
6121 }
6122 mFrameTimeline->setMaxDisplayFrames(n);
6123 return NO_ERROR;
6124 }
Ady Abraham0bb6a472020-10-12 10:22:13 -07006125 case 1039: {
Ady Abraham62f216c2020-10-13 19:07:23 -07006126 PhysicalDisplayId displayId = [&]() {
6127 Mutex::Autolock lock(mStateLock);
6128 return getDefaultDisplayDeviceLocked()->getPhysicalId();
6129 }();
6130
6131 auto inUid = static_cast<uid_t>(data.readInt32());
6132 const auto refreshRate = data.readFloat();
Ady Abraham62a0be22020-12-08 16:54:10 -08006133 mScheduler->setPreferredRefreshRateForUid(FrameRateOverride{inUid, refreshRate});
6134 mScheduler->onFrameRateOverridesChanged(mAppConnectionHandle, displayId);
Ady Abraham0bb6a472020-10-12 10:22:13 -07006135 return NO_ERROR;
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08006136 }
Alec Mouridd8bf2d2021-05-08 16:36:33 -07006137 // Toggle caching feature
6138 // First argument is an int32 - nonzero enables caching and zero disables caching
6139 // Second argument is an optional uint64 - if present, then limits enabling/disabling
6140 // caching to a particular physical display
6141 case 1040: {
Dominik Laskowski756b7892021-08-04 12:53:59 -07006142 auto future = mScheduler->schedule([&] {
6143 n = data.readInt32();
6144 std::optional<PhysicalDisplayId> inputId = std::nullopt;
6145 if (uint64_t inputDisplayId; data.readUint64(&inputDisplayId) == NO_ERROR) {
6146 inputId = DisplayId::fromValue<PhysicalDisplayId>(inputDisplayId);
6147 if (!inputId || getPhysicalDisplayToken(*inputId)) {
6148 ALOGE("No display with id: %" PRIu64, inputDisplayId);
6149 return NAME_NOT_FOUND;
6150 }
6151 }
6152 {
6153 Mutex::Autolock lock(mStateLock);
6154 mLayerCachingEnabled = n != 0;
6155 for (const auto& [_, display] : mDisplays) {
6156 if (!inputId || *inputId == display->getPhysicalId()) {
6157 display->enableLayerCaching(mLayerCachingEnabled);
Alec Mouricdd722b2021-05-19 14:29:05 -07006158 }
Dominik Laskowski756b7892021-08-04 12:53:59 -07006159 }
6160 }
6161 return OK;
6162 });
Alec Mouricdd722b2021-05-19 14:29:05 -07006163
Dominik Laskowski756b7892021-08-04 12:53:59 -07006164 if (const status_t error = future.get(); error != OK) {
Alec Mouricdd722b2021-05-19 14:29:05 -07006165 return error;
Alec Mouridd8bf2d2021-05-08 16:36:33 -07006166 }
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07006167 scheduleRepaint();
Alec Mouridd8bf2d2021-05-08 16:36:33 -07006168 return NO_ERROR;
6169 }
Vishnu Nair7891e962021-11-11 12:07:21 -08006170 case 1041: { // Transaction tracing
Dominik Laskowski46471e62022-01-14 15:34:03 -08006171 if (mTransactionTracing) {
6172 if (data.readInt32()) {
6173 // Transaction tracing is always running but allow the user to temporarily
6174 // increase the buffer when actively debugging.
6175 mTransactionTracing->setBufferSize(
6176 TransactionTracing::ACTIVE_TRACING_BUFFER_SIZE);
6177 } else {
Vishnu Naird8f5e9f2022-02-03 10:23:28 -08006178 mTransactionTracing->writeToFile();
Dominik Laskowski46471e62022-01-14 15:34:03 -08006179 mTransactionTracing->setBufferSize(
6180 TransactionTracing::CONTINUOUS_TRACING_BUFFER_SIZE);
Dominik Laskowski46471e62022-01-14 15:34:03 -08006181 }
Vishnu Nair7891e962021-11-11 12:07:21 -08006182 }
6183 reply->writeInt32(NO_ERROR);
6184 return NO_ERROR;
6185 }
Nataniel Borges533c2f82022-01-21 12:07:02 +01006186 case 1042: { // Write layers trace or transaction trace to file
6187 if (mTransactionTracing) {
6188 mTransactionTracing->writeToFile();
6189 }
6190 if (mLayerTracingEnabled) {
6191 mLayerTracing.writeToFile();
6192 }
6193 reply->writeInt32(NO_ERROR);
6194 return NO_ERROR;
6195 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08006196 }
6197 }
6198 return err;
6199}
6200
Ady Abrahama09852a2020-02-20 14:23:42 -08006201void SurfaceFlinger::kernelTimerChanged(bool expired) {
6202 static bool updateOverlay =
6203 property_get_bool("debug.sf.kernel_idle_timer_update_overlay", true);
Dominik Laskowski20134642020-04-20 22:36:44 -07006204 if (!updateOverlay) return;
Ady Abrahama09852a2020-02-20 14:23:42 -08006205
6206 // Update the overlay on the main thread to avoid race conditions with
Dominik Laskowskib0054a22022-03-03 09:03:06 -08006207 // mRefreshRateConfigs->getActiveMode()
Dominik Laskowski756b7892021-08-04 12:53:59 -07006208 static_cast<void>(mScheduler->schedule([=] {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08006209 const auto display = FTL_FAKE_GUARD(mStateLock, getDefaultDisplayDeviceLocked());
Ady Abraham3efa3942021-06-24 19:01:25 -07006210 if (!display) {
6211 ALOGW("%s: default display is null", __func__);
6212 return;
6213 }
Adrian Salidoa942af82022-02-17 19:22:31 -08006214 if (!display->isRefreshRateOverlayEnabled()) return;
Ady Abraham690f4612021-07-01 23:24:03 -07006215
6216 const auto desiredActiveMode = display->getDesiredActiveMode();
6217 const std::optional<DisplayModeId> desiredModeId = desiredActiveMode
6218 ? std::make_optional(desiredActiveMode->mode->getId())
6219 : std::nullopt;
6220
6221 const bool timerExpired = mKernelIdleTimerEnabled && expired;
6222
Ady Abraham1b11bc62021-06-03 19:51:19 -07006223 if (display->onKernelTimerChanged(desiredModeId, timerExpired)) {
Dominik Laskowski46f3e3b2021-08-10 11:44:24 -07006224 mScheduler->scheduleFrame();
Ady Abrahama09852a2020-02-20 14:23:42 -08006225 }
6226 }));
6227}
6228
ramindani32cf0602022-03-02 02:30:29 +00006229std::pair<std::optional<KernelIdleTimerController>, std::chrono::milliseconds>
6230SurfaceFlinger::getKernelIdleTimerProperties(DisplayId displayId) {
6231 const bool isKernelIdleTimerHwcSupported = getHwComposer().getComposer()->isSupported(
6232 android::Hwc2::Composer::OptionalFeature::KernelIdleTimer);
6233 const auto timeout = getIdleTimerTimeout(displayId);
6234 if (isKernelIdleTimerHwcSupported) {
6235 if (const auto id = PhysicalDisplayId::tryCast(displayId);
6236 getHwComposer().hasDisplayIdleTimerCapability(*id)) {
6237 // In order to decide if we can use the HWC api for idle timer
6238 // we query DisplayCapability::DISPLAY_IDLE_TIMER directly on the composer
6239 // without relying on hasDisplayCapability.
6240 // hasDisplayCapability relies on DisplayCapabilities
6241 // which are updated after we set the PowerMode::ON.
6242 // DISPLAY_IDLE_TIMER is a display driver property
6243 // and is available before the PowerMode::ON
6244 return {KernelIdleTimerController::HwcApi, timeout};
6245 }
6246 return {std::nullopt, timeout};
6247 }
6248 if (getKernelIdleTimerSyspropConfig(displayId)) {
6249 return {KernelIdleTimerController::Sysprop, timeout};
6250 }
6251
6252 return {std::nullopt, timeout};
6253}
6254
6255void SurfaceFlinger::updateKernelIdleTimer(std::chrono::milliseconds timeout,
6256 KernelIdleTimerController controller,
6257 PhysicalDisplayId displayId) {
6258 switch (controller) {
6259 case KernelIdleTimerController::HwcApi: {
6260 getHwComposer().setIdleTimerEnabled(displayId, timeout);
6261 break;
6262 }
6263 case KernelIdleTimerController::Sysprop: {
6264 base::SetProperty(KERNEL_IDLE_TIMER_PROP, timeout > 0ms ? "true" : "false");
6265 break;
6266 }
6267 }
6268}
6269
Ana Krulecb9afd792020-06-11 13:16:15 -07006270void SurfaceFlinger::toggleKernelIdleTimer() {
6271 using KernelIdleTimerAction = scheduler::RefreshRateConfigs::KernelIdleTimerAction;
6272
Ady Abraham3efa3942021-06-24 19:01:25 -07006273 const auto display = getDefaultDisplayDeviceLocked();
6274 if (!display) {
6275 ALOGW("%s: default display is null", __func__);
6276 return;
6277 }
Ana Krulecb9afd792020-06-11 13:16:15 -07006278
Ady Abrahame9316b72021-09-24 17:04:36 -07006279 // If the support for kernel idle timer is disabled for the active display,
6280 // don't do anything.
ramindani32cf0602022-03-02 02:30:29 +00006281 const std::optional<KernelIdleTimerController> kernelIdleTimerController =
6282 display->refreshRateConfigs().kernelIdleTimerController();
6283 if (!kernelIdleTimerController.has_value()) {
Ady Abrahame9316b72021-09-24 17:04:36 -07006284 return;
6285 }
6286
Ady Abraham3efa3942021-06-24 19:01:25 -07006287 const KernelIdleTimerAction action = display->refreshRateConfigs().getIdleTimerAction();
ramindani32cf0602022-03-02 02:30:29 +00006288
Ana Krulecb9afd792020-06-11 13:16:15 -07006289 switch (action) {
6290 case KernelIdleTimerAction::TurnOff:
6291 if (mKernelIdleTimerEnabled) {
6292 ATRACE_INT("KernelIdleTimer", 0);
ramindani32cf0602022-03-02 02:30:29 +00006293 std::chrono::milliseconds constexpr kTimerDisabledTimeout = 0ms;
6294 updateKernelIdleTimer(kTimerDisabledTimeout, kernelIdleTimerController.value(),
6295 display->getPhysicalId());
Ana Krulecb9afd792020-06-11 13:16:15 -07006296 mKernelIdleTimerEnabled = false;
6297 }
6298 break;
6299 case KernelIdleTimerAction::TurnOn:
6300 if (!mKernelIdleTimerEnabled) {
6301 ATRACE_INT("KernelIdleTimer", 1);
ramindani32cf0602022-03-02 02:30:29 +00006302 const std::chrono::milliseconds timeout =
6303 display->refreshRateConfigs().getIdleTimerTimeout();
6304 updateKernelIdleTimer(timeout, kernelIdleTimerController.value(),
6305 display->getPhysicalId());
Ana Krulecb9afd792020-06-11 13:16:15 -07006306 mKernelIdleTimerEnabled = true;
6307 }
6308 break;
Ana Krulecb9afd792020-06-11 13:16:15 -07006309 }
6310}
6311
Dan Stoza2b6d38e2017-06-01 16:40:30 -07006312// A simple RAII class to disconnect from an ANativeWindow* when it goes out of scope
6313class WindowDisconnector {
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07006314public:
Dan Stoza2b6d38e2017-06-01 16:40:30 -07006315 WindowDisconnector(ANativeWindow* window, int api) : mWindow(window), mApi(api) {}
6316 ~WindowDisconnector() {
6317 native_window_api_disconnect(mWindow, mApi);
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07006318 }
6319
Dan Stoza2b6d38e2017-06-01 16:40:30 -07006320private:
6321 ANativeWindow* mWindow;
6322 const int mApi;
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07006323};
6324
chaviw93df2ea2019-04-30 16:45:12 -07006325static Dataspace pickDataspaceFromColorMode(const ColorMode colorMode) {
6326 switch (colorMode) {
6327 case ColorMode::DISPLAY_P3:
6328 case ColorMode::BT2100_PQ:
6329 case ColorMode::BT2100_HLG:
6330 case ColorMode::DISPLAY_BT2020:
6331 return Dataspace::DISPLAY_P3;
6332 default:
6333 return Dataspace::V0_SRGB;
6334 }
6335}
6336
chaviwf5bb97b2021-04-28 15:35:37 -05006337static bool hasCaptureBlackoutContentPermission() {
6338 IPCThreadState* ipc = IPCThreadState::self();
6339 const int pid = ipc->getCallingPid();
6340 const int uid = ipc->getCallingUid();
6341 return uid == AID_GRAPHICS || uid == AID_SYSTEM ||
6342 PermissionCache::checkPermission(sCaptureBlackoutContent, pid, uid);
6343}
6344
chaviw4b9d5e12020-08-04 18:30:35 -07006345static status_t validateScreenshotPermissions(const CaptureArgs& captureArgs) {
6346 IPCThreadState* ipc = IPCThreadState::self();
6347 const int pid = ipc->getCallingPid();
6348 const int uid = ipc->getCallingUid();
6349 if (uid == AID_GRAPHICS || PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
6350 return OK;
6351 }
6352
6353 // If the caller doesn't have the correct permissions but is only attempting to screenshot
6354 // itself, we allow it to continue.
6355 if (captureArgs.uid == uid) {
6356 return OK;
6357 }
6358
6359 ALOGE("Permission Denial: can't take screenshot pid=%d, uid=%d", pid, uid);
6360 return PERMISSION_DENIED;
6361}
6362
Peiyong Lin05cc0112020-10-14 16:16:37 -07006363status_t SurfaceFlinger::setSchedFifo(bool enabled) {
6364 static constexpr int kFifoPriority = 2;
6365 static constexpr int kOtherPriority = 0;
6366
6367 struct sched_param param = {0};
6368 int sched_policy;
6369 if (enabled) {
6370 sched_policy = SCHED_FIFO;
6371 param.sched_priority = kFifoPriority;
6372 } else {
6373 sched_policy = SCHED_OTHER;
6374 param.sched_priority = kOtherPriority;
6375 }
6376
6377 if (sched_setscheduler(0, sched_policy, &param) != 0) {
6378 return -errno;
6379 }
Wei Wang23aa5a62021-06-04 15:56:57 -07006380
6381 return NO_ERROR;
6382}
6383
6384status_t SurfaceFlinger::setSchedAttr(bool enabled) {
6385 static const unsigned int kUclampMin =
6386 base::GetUintProperty<unsigned int>("ro.surface_flinger.uclamp.min", 0U);
6387
6388 if (!kUclampMin) {
6389 // uclamp.min set to 0 (default), skip setting
6390 return NO_ERROR;
6391 }
6392
6393 // Currently, there is no wrapper in bionic: b/183240349.
6394 struct sched_attr {
6395 uint32_t size;
6396 uint32_t sched_policy;
6397 uint64_t sched_flags;
6398 int32_t sched_nice;
6399 uint32_t sched_priority;
6400 uint64_t sched_runtime;
6401 uint64_t sched_deadline;
6402 uint64_t sched_period;
6403 uint32_t sched_util_min;
6404 uint32_t sched_util_max;
6405 };
6406
6407 sched_attr attr = {};
6408 attr.size = sizeof(attr);
6409
6410 attr.sched_flags = (SCHED_FLAG_KEEP_ALL | SCHED_FLAG_UTIL_CLAMP);
6411 attr.sched_util_min = enabled ? kUclampMin : 0;
6412 attr.sched_util_max = 1024;
6413
6414 if (syscall(__NR_sched_setattr, 0, &attr, 0)) {
6415 return -errno;
6416 }
6417
Peiyong Lin05cc0112020-10-14 16:16:37 -07006418 return NO_ERROR;
6419}
6420
chaviwd2432892020-07-24 17:42:39 -07006421status_t SurfaceFlinger::captureDisplay(const DisplayCaptureArgs& args,
chaviw8ffc7b82020-08-18 11:25:37 -07006422 const sp<IScreenCaptureListener>& captureListener) {
chaviwd2432892020-07-24 17:42:39 -07006423 ATRACE_CALL();
6424
chaviw4b9d5e12020-08-04 18:30:35 -07006425 status_t validate = validateScreenshotPermissions(args);
6426 if (validate != OK) {
6427 return validate;
6428 }
6429
chaviwd2432892020-07-24 17:42:39 -07006430 if (!args.displayToken) return BAD_VALUE;
6431
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -07006432 wp<const DisplayDevice> displayWeak;
chaviwd2432892020-07-24 17:42:39 -07006433 ui::LayerStack layerStack;
6434 ui::Size reqSize(args.width, args.height);
6435 ui::Dataspace dataspace;
6436 {
6437 Mutex::Autolock lock(mStateLock);
6438 sp<DisplayDevice> display = getDisplayDeviceLocked(args.displayToken);
6439 if (!display) return NAME_NOT_FOUND;
6440 displayWeak = display;
6441 layerStack = display->getLayerStack();
6442
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02006443 // set the requested width/height to the logical display layer stack rect size by default
chaviwd2432892020-07-24 17:42:39 -07006444 if (args.width == 0 || args.height == 0) {
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02006445 reqSize = display->getLayerStackSpaceRect().getSize();
chaviwd2432892020-07-24 17:42:39 -07006446 }
6447
arthurhung79e81aa2020-08-28 00:09:19 +08006448 // The dataspace is depended on the color mode of display, that could use non-native mode
6449 // (ex. displayP3) to enhance the content, but some cases are checking native RGB in bytes,
6450 // and failed if display is not in native mode. This provide a way to force using native
6451 // colors when capture.
Peiyong Lincd261472020-10-06 18:05:25 -07006452 dataspace = args.dataspace;
6453 if (dataspace == ui::Dataspace::UNKNOWN) {
arthurhung79e81aa2020-08-28 00:09:19 +08006454 const ui::ColorMode colorMode = display->getCompositionDisplay()->getState().colorMode;
6455 dataspace = pickDataspaceFromColorMode(colorMode);
6456 }
chaviwd2432892020-07-24 17:42:39 -07006457 }
6458
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -08006459 RenderAreaFuture renderAreaFuture = ftl::defer([=] {
chaviwd2432892020-07-24 17:42:39 -07006460 return DisplayRenderArea::create(displayWeak, args.sourceCrop, reqSize, dataspace,
chaviwc6ad8af2020-08-03 11:33:30 -07006461 args.useIdentityTransform, args.captureSecureLayers);
chaviwd2432892020-07-24 17:42:39 -07006462 });
6463
chaviw4b9d5e12020-08-04 18:30:35 -07006464 auto traverseLayers = [this, args, layerStack](const LayerVector::Visitor& visitor) {
6465 traverseLayersInLayerStack(layerStack, args.uid, visitor);
chaviwd2432892020-07-24 17:42:39 -07006466 };
chaviw03900772020-08-18 12:34:51 -07006467
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07006468 auto future = captureScreenCommon(std::move(renderAreaFuture), traverseLayers, reqSize,
6469 args.pixelFormat, args.allowProtected, args.grayscale,
6470 captureListener);
6471 return fenceStatus(future.get());
chaviw93df2ea2019-04-30 16:45:12 -07006472}
6473
Dominik Laskowskif1833852021-03-23 15:06:50 -07006474status_t SurfaceFlinger::captureDisplay(DisplayId displayId,
chaviw8ffc7b82020-08-18 11:25:37 -07006475 const sp<IScreenCaptureListener>& captureListener) {
Marin Shalamanov1c434292020-06-12 01:47:29 +02006476 ui::LayerStack layerStack;
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -07006477 wp<const DisplayDevice> displayWeak;
Marin Shalamanov1c434292020-06-12 01:47:29 +02006478 ui::Size size;
chaviw426b5c02020-07-27 11:20:15 -07006479 ui::Dataspace dataspace;
chaviw93df2ea2019-04-30 16:45:12 -07006480 {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07006481 Mutex::Autolock lock(mStateLock);
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -07006482
Dominik Laskowskif1833852021-03-23 15:06:50 -07006483 const auto display = getDisplayDeviceLocked(displayId);
chaviw93df2ea2019-04-30 16:45:12 -07006484 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07006485 return NAME_NOT_FOUND;
chaviw93df2ea2019-04-30 16:45:12 -07006486 }
6487
chaviw93df2ea2019-04-30 16:45:12 -07006488 displayWeak = display;
Dominik Laskowskif1833852021-03-23 15:06:50 -07006489 layerStack = display->getLayerStack();
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02006490 size = display->getLayerStackSpaceRect().getSize();
chaviw93df2ea2019-04-30 16:45:12 -07006491
chaviw426b5c02020-07-27 11:20:15 -07006492 dataspace =
chaviw93df2ea2019-04-30 16:45:12 -07006493 pickDataspaceFromColorMode(display->getCompositionDisplay()->getState().colorMode);
6494 }
6495
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -08006496 RenderAreaFuture renderAreaFuture = ftl::defer([=] {
chaviw8ffc7b82020-08-18 11:25:37 -07006497 return DisplayRenderArea::create(displayWeak, Rect(), size, dataspace,
chaviwc6ad8af2020-08-03 11:33:30 -07006498 false /* useIdentityTransform */,
chaviwd2432892020-07-24 17:42:39 -07006499 false /* captureSecureLayers */);
Marin Shalamanov1c434292020-06-12 01:47:29 +02006500 });
chaviw93df2ea2019-04-30 16:45:12 -07006501
Marin Shalamanov1c434292020-06-12 01:47:29 +02006502 auto traverseLayers = [this, layerStack](const LayerVector::Visitor& visitor) {
chaviw4b9d5e12020-08-04 18:30:35 -07006503 traverseLayersInLayerStack(layerStack, CaptureArgs::UNSET_UID, visitor);
Marin Shalamanov1c434292020-06-12 01:47:29 +02006504 };
6505
Sally Qi59a9f502021-10-12 18:53:23 +00006506 if (captureListener == nullptr) {
6507 ALOGE("capture screen must provide a capture listener callback");
6508 return BAD_VALUE;
6509 }
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07006510
6511 constexpr bool kAllowProtected = false;
6512 constexpr bool kGrayscale = false;
6513
6514 auto future = captureScreenCommon(std::move(renderAreaFuture), traverseLayers, size,
6515 ui::PixelFormat::RGBA_8888, kAllowProtected, kGrayscale,
6516 captureListener);
6517 return fenceStatus(future.get());
chaviw93df2ea2019-04-30 16:45:12 -07006518}
6519
chaviw3efadb12020-07-27 10:07:15 -07006520status_t SurfaceFlinger::captureLayers(const LayerCaptureArgs& args,
chaviw8ffc7b82020-08-18 11:25:37 -07006521 const sp<IScreenCaptureListener>& captureListener) {
chaviwa76b2712017-09-20 12:02:26 -07006522 ATRACE_CALL();
6523
chaviw4b9d5e12020-08-04 18:30:35 -07006524 status_t validate = validateScreenshotPermissions(args);
6525 if (validate != OK) {
6526 return validate;
6527 }
6528
Marin Shalamanov1c434292020-06-12 01:47:29 +02006529 ui::Size reqSize;
Robert Carrc0df3122019-04-11 13:18:21 -07006530 sp<Layer> parent;
chaviw3efadb12020-07-27 10:07:15 -07006531 Rect crop(args.sourceCrop);
Huihong Luoa339d0a2022-02-05 09:42:42 -08006532 std::unordered_set<sp<Layer>, SpHash<Layer>> excludeLayers;
chaviw3efadb12020-07-27 10:07:15 -07006533 ui::Dataspace dataspace;
chaviwf5bb97b2021-04-28 15:35:37 -05006534
6535 // Call this before holding mStateLock to avoid any deadlocking.
6536 bool canCaptureBlackoutContent = hasCaptureBlackoutContentPermission();
6537
Robert Carrc0df3122019-04-11 13:18:21 -07006538 {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07006539 Mutex::Autolock lock(mStateLock);
chaviw7206d492017-11-10 16:16:12 -08006540
Vishnu Nairf9096652021-07-20 18:49:42 -07006541 parent = fromHandle(args.layerHandle).promote();
chaviw79468ab2021-10-27 11:11:24 -05006542 if (parent == nullptr) {
Robert Carrc0df3122019-04-11 13:18:21 -07006543 ALOGE("captureLayers called with an invalid or removed parent");
6544 return NAME_NOT_FOUND;
6545 }
6546
chaviwf5bb97b2021-04-28 15:35:37 -05006547 if (!canCaptureBlackoutContent &&
Robert Carr6a160312021-05-17 12:08:20 -07006548 parent->getDrawingState().flags & layer_state_t::eLayerSecure) {
Robert Carrc0df3122019-04-11 13:18:21 -07006549 ALOGW("Attempting to capture secure layer: PERMISSION_DENIED");
6550 return PERMISSION_DENIED;
6551 }
6552
Robert Carr6a160312021-05-17 12:08:20 -07006553 Rect parentSourceBounds = parent->getCroppedBufferSize(parent->getDrawingState());
chaviw3efadb12020-07-27 10:07:15 -07006554 if (args.sourceCrop.width() <= 0) {
Robert Carrc0df3122019-04-11 13:18:21 -07006555 crop.left = 0;
Vishnu Nairefc42e22019-12-03 17:36:12 -08006556 crop.right = parentSourceBounds.getWidth();
Robert Carrc0df3122019-04-11 13:18:21 -07006557 }
6558
chaviw3efadb12020-07-27 10:07:15 -07006559 if (args.sourceCrop.height() <= 0) {
Robert Carrc0df3122019-04-11 13:18:21 -07006560 crop.top = 0;
Vishnu Nairefc42e22019-12-03 17:36:12 -08006561 crop.bottom = parentSourceBounds.getHeight();
6562 }
6563
chaviw17ac24b2021-01-28 18:50:05 -08006564 if (crop.isEmpty() || args.frameScaleX <= 0.0f || args.frameScaleY <= 0.0f) {
Vishnu Nairefc42e22019-12-03 17:36:12 -08006565 // Error out if the layer has no source bounds (i.e. they are boundless) and a source
6566 // crop was not specified, or an invalid frame scale was provided.
6567 return BAD_VALUE;
Robert Carrc0df3122019-04-11 13:18:21 -07006568 }
chaviw17ac24b2021-01-28 18:50:05 -08006569 reqSize = ui::Size(crop.width() * args.frameScaleX, crop.height() * args.frameScaleY);
Robert Carrc0df3122019-04-11 13:18:21 -07006570
chaviw3efadb12020-07-27 10:07:15 -07006571 for (const auto& handle : args.excludeHandles) {
Vishnu Nairf9096652021-07-20 18:49:42 -07006572 sp<Layer> excludeLayer = fromHandle(handle).promote();
Robert Carrc0df3122019-04-11 13:18:21 -07006573 if (excludeLayer != nullptr) {
6574 excludeLayers.emplace(excludeLayer);
6575 } else {
6576 ALOGW("Invalid layer handle passed as excludeLayer to captureLayers");
6577 return NAME_NOT_FOUND;
6578 }
6579 }
Vishnu Nair3a7346c2019-12-04 08:09:09 -08006580
arthurhung79e81aa2020-08-28 00:09:19 +08006581 // The dataspace is depended on the color mode of display, that could use non-native mode
6582 // (ex. displayP3) to enhance the content, but some cases are checking native RGB in bytes,
6583 // and failed if display is not in native mode. This provide a way to force using native
6584 // colors when capture.
Peiyong Lincd261472020-10-06 18:05:25 -07006585 dataspace = args.dataspace;
Robert Carrc0df3122019-04-11 13:18:21 -07006586 } // mStateLock
chaviw7206d492017-11-10 16:16:12 -08006587
Chia-I Wu20261cb2018-08-23 12:55:44 -07006588 // really small crop or frameScale
chaviw79468ab2021-10-27 11:11:24 -05006589 if (reqSize.width <= 0 || reqSize.height <= 0) {
6590 ALOGW("Failed to captureLayes: crop or scale too small");
6591 return BAD_VALUE;
Chia-I Wu20261cb2018-08-23 12:55:44 -07006592 }
6593
chaviw79468ab2021-10-27 11:11:24 -05006594 Rect layerStackSpaceRect(0, 0, reqSize.width, reqSize.height);
chaviw3efadb12020-07-27 10:07:15 -07006595 bool childrenOnly = args.childrenOnly;
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -08006596 RenderAreaFuture renderAreaFuture = ftl::defer([=]() -> std::unique_ptr<RenderArea> {
chaviw3efadb12020-07-27 10:07:15 -07006597 return std::make_unique<LayerRenderArea>(*this, parent, crop, reqSize, dataspace,
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02006598 childrenOnly, layerStackSpaceRect,
chaviw79468ab2021-10-27 11:11:24 -05006599 args.captureSecureLayers);
Marin Shalamanov1c434292020-06-12 01:47:29 +02006600 });
6601
chaviw03900772020-08-18 12:34:51 -07006602 auto traverseLayers = [parent, args, excludeLayers](const LayerVector::Visitor& visitor) {
chaviwa76b2712017-09-20 12:02:26 -07006603 parent->traverseChildrenInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
6604 if (!layer->isVisible()) {
6605 return;
chaviw4b9d5e12020-08-04 18:30:35 -07006606 } else if (args.childrenOnly && layer == parent.get()) {
6607 return;
6608 } else if (args.uid != CaptureArgs::UNSET_UID && args.uid != layer->getOwnerUid()) {
Robert Carr578038f2018-03-09 12:25:24 -08006609 return;
chaviwa76b2712017-09-20 12:02:26 -07006610 }
Robert Carr866455f2019-04-02 16:28:26 -07006611
Rob Carrc6d2d2b2021-10-25 16:51:49 +00006612 sp<Layer> p = layer;
Robert Carr866455f2019-04-02 16:28:26 -07006613 while (p != nullptr) {
6614 if (excludeLayers.count(p) != 0) {
6615 return;
6616 }
6617 p = p->getParent();
6618 }
6619
chaviwa76b2712017-09-20 12:02:26 -07006620 visitor(layer);
6621 });
6622 };
Robert Carr108b2c72019-04-02 16:32:58 -07006623
Sally Qi59a9f502021-10-12 18:53:23 +00006624 if (captureListener == nullptr) {
6625 ALOGE("capture screen must provide a capture listener callback");
6626 return BAD_VALUE;
6627 }
6628
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07006629 auto future = captureScreenCommon(std::move(renderAreaFuture), traverseLayers, reqSize,
6630 args.pixelFormat, args.allowProtected, args.grayscale,
6631 captureListener);
6632 return fenceStatus(future.get());
chaviwa76b2712017-09-20 12:02:26 -07006633}
6634
Dominik Laskowskib17c6212022-05-09 09:36:19 -07006635ftl::SharedFuture<FenceResult> SurfaceFlinger::captureScreenCommon(
Sally Qi59a9f502021-10-12 18:53:23 +00006636 RenderAreaFuture renderAreaFuture, TraverseLayersFunction traverseLayers,
6637 ui::Size bufferSize, ui::PixelFormat reqPixelFormat, bool allowProtected, bool grayscale,
6638 const sp<IScreenCaptureListener>& captureListener) {
chaviwa76b2712017-09-20 12:02:26 -07006639 ATRACE_CALL();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08006640
Garfield Tan9c9c1912021-07-19 12:02:16 -07006641 if (exceedsMaxRenderTargetSize(bufferSize.getWidth(), bufferSize.getHeight())) {
6642 ALOGE("Attempted to capture screen with size (%" PRId32 ", %" PRId32
6643 ") that exceeds render target size limit.",
6644 bufferSize.getWidth(), bufferSize.getHeight());
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07006645 return ftl::yield<FenceResult>(base::unexpected(BAD_VALUE)).share();
Garfield Tan9c9c1912021-07-19 12:02:16 -07006646 }
6647
Peiyong Lin05cc0112020-10-14 16:16:37 -07006648 // Loop over all visible layers to see whether there's any protected layer. A protected layer is
6649 // typically a layer with DRM contents, or have the GRALLOC_USAGE_PROTECTED set on the buffer.
6650 // A protected layer has no implication on whether it's secure, which is explicitly set by
6651 // application to avoid being screenshot or drawn via unsecure display.
6652 const bool supportsProtected = getRenderEngine().supportsProtectedContent();
6653 bool hasProtectedLayer = false;
6654 if (allowProtected && supportsProtected) {
Dominik Laskowski756b7892021-08-04 12:53:59 -07006655 auto future = mScheduler->schedule([=]() {
6656 bool protectedLayerFound = false;
6657 traverseLayers([&](Layer* layer) {
6658 protectedLayerFound =
6659 protectedLayerFound || (layer->isVisible() && layer->isProtected());
6660 });
6661 return protectedLayerFound;
6662 });
6663 hasProtectedLayer = future.get();
Peiyong Lin05cc0112020-10-14 16:16:37 -07006664 }
6665
Richard Liucbcb8952020-04-08 10:51:55 +00006666 const uint32_t usage = GRALLOC_USAGE_HW_COMPOSER | GRALLOC_USAGE_HW_RENDER |
6667 GRALLOC_USAGE_HW_TEXTURE |
Peiyong Lin05cc0112020-10-14 16:16:37 -07006668 (hasProtectedLayer && allowProtected && supportsProtected
6669 ? GRALLOC_USAGE_PROTECTED
6670 : GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);
chaviw426b5c02020-07-27 11:20:15 -07006671 sp<GraphicBuffer> buffer =
6672 getFactory().createGraphicBuffer(bufferSize.getWidth(), bufferSize.getHeight(),
6673 static_cast<android_pixel_format>(reqPixelFormat),
6674 1 /* layerCount */, usage, "screenshot");
Alec Mouri7013b6f2021-02-12 11:16:54 -08006675
6676 const status_t bufferStatus = buffer->initCheck();
Alec Mourid8f17c52022-07-21 18:43:10 +00006677 if (bufferStatus != OK) {
6678 // Animations may end up being really janky, but don't crash here.
6679 // Otherwise an irreponsible process may cause an SF crash by allocating
6680 // too much.
6681 ALOGE("%s: Buffer failed to allocate: %d", __func__, bufferStatus);
6682 return ftl::yield<FenceResult>(base::unexpected(bufferStatus)).share();
6683 }
Vishnu Nairdbbe3852022-01-12 20:22:11 -08006684 const std::shared_ptr<renderengine::ExternalTexture> texture = std::make_shared<
6685 renderengine::impl::ExternalTexture>(buffer, getRenderEngine(),
6686 renderengine::impl::ExternalTexture::Usage::
6687 WRITEABLE);
Alec Mouria90a5702021-04-16 16:36:21 +00006688 return captureScreenCommon(std::move(renderAreaFuture), traverseLayers, texture,
Derek Sollenberger34257882021-04-06 18:32:34 +00006689 false /* regionSampling */, grayscale, captureListener);
Dan Stozaec460082018-12-17 15:35:09 -08006690}
6691
Dominik Laskowskib17c6212022-05-09 09:36:19 -07006692ftl::SharedFuture<FenceResult> SurfaceFlinger::captureScreenCommon(
Alec Mouria90a5702021-04-16 16:36:21 +00006693 RenderAreaFuture renderAreaFuture, TraverseLayersFunction traverseLayers,
6694 const std::shared_ptr<renderengine::ExternalTexture>& buffer, bool regionSampling,
6695 bool grayscale, const sp<IScreenCaptureListener>& captureListener) {
chaviw03900772020-08-18 12:34:51 -07006696 ATRACE_CALL();
6697
chaviwf5bb97b2021-04-28 15:35:37 -05006698 bool canCaptureBlackoutContent = hasCaptureBlackoutContentPermission();
Robert Carr03480e22018-01-04 16:02:06 -08006699
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07006700 auto future = mScheduler->schedule([=, renderAreaFuture = std::move(renderAreaFuture)]() mutable
Dominik Laskowskib17c6212022-05-09 09:36:19 -07006701 -> ftl::SharedFuture<FenceResult> {
chaviw03900772020-08-18 12:34:51 -07006702 ScreenCaptureResults captureResults;
6703 std::unique_ptr<RenderArea> renderArea = renderAreaFuture.get();
6704 if (!renderArea) {
6705 ALOGW("Skipping screen capture because of invalid render area.");
Nolan Scobied2e42642022-11-18 12:10:42 -05006706 if (captureListener) {
6707 captureResults.result = NO_MEMORY;
6708 captureListener->onScreenCaptureCompleted(captureResults);
6709 }
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07006710 return ftl::yield<FenceResult>(base::unexpected(NO_ERROR)).share();
chaviw03900772020-08-18 12:34:51 -07006711 }
Dan Stoza2b6d38e2017-06-01 16:40:30 -07006712
Dominik Laskowskib17c6212022-05-09 09:36:19 -07006713 ftl::SharedFuture<FenceResult> renderFuture;
chaviw03900772020-08-18 12:34:51 -07006714 renderArea->render([&] {
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07006715 renderFuture =
6716 renderScreenImpl(*renderArea, traverseLayers, buffer, canCaptureBlackoutContent,
6717 regionSampling, grayscale, captureResults);
chaviw03900772020-08-18 12:34:51 -07006718 });
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07006719
6720 if (captureListener) {
6721 // TODO: The future returned by std::async blocks the main thread. Return a chain of
6722 // futures to the Binder thread instead.
Sally Qi59a9f502021-10-12 18:53:23 +00006723 std::async([=]() mutable {
6724 ATRACE_NAME("captureListener is nonnull!");
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07006725 auto fenceResult = renderFuture.get();
6726 // TODO(b/232535621): Change ScreenCaptureResults to store a FenceResult.
6727 captureResults.result = fenceStatus(fenceResult);
6728 captureResults.fence = std::move(fenceResult).value_or(Fence::NO_FENCE);
Sally Qi59a9f502021-10-12 18:53:23 +00006729 captureListener->onScreenCaptureCompleted(captureResults);
6730 });
6731 }
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07006732 return renderFuture;
Sally Qi59a9f502021-10-12 18:53:23 +00006733 });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07006734
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07006735 if (captureListener) {
6736 return ftl::yield<FenceResult>(base::unexpected(NO_ERROR)).share();
Sally Qi59a9f502021-10-12 18:53:23 +00006737 }
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07006738
6739 // Flatten nested futures.
Dominik Laskowskib17c6212022-05-09 09:36:19 -07006740 auto chain = ftl::Future(std::move(future)).then([](ftl::SharedFuture<FenceResult> future) {
6741 return future;
6742 });
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07006743
6744 return chain.share();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08006745}
6746
Dominik Laskowskib17c6212022-05-09 09:36:19 -07006747ftl::SharedFuture<FenceResult> SurfaceFlinger::renderScreenImpl(
Alec Mouria90a5702021-04-16 16:36:21 +00006748 const RenderArea& renderArea, TraverseLayersFunction traverseLayers,
chaviwf5bb97b2021-04-28 15:35:37 -05006749 const std::shared_ptr<renderengine::ExternalTexture>& buffer,
6750 bool canCaptureBlackoutContent, bool regionSampling, bool grayscale,
6751 ScreenCaptureResults& captureResults) {
Mathias Agopian180f10d2013-04-10 22:55:41 -07006752 ATRACE_CALL();
chaviwa76b2712017-09-20 12:02:26 -07006753
chaviw426b5c02020-07-27 11:20:15 -07006754 traverseLayers([&](Layer* layer) {
6755 captureResults.capturedSecureLayers =
6756 captureResults.capturedSecureLayers || (layer->isVisible() && layer->isSecure());
6757 });
6758
Vishnu Nairdbbe3852022-01-12 20:22:11 -08006759 const bool useProtected = buffer->getUsage() & GRALLOC_USAGE_PROTECTED;
Peiyong Lin05cc0112020-10-14 16:16:37 -07006760
chaviw426b5c02020-07-27 11:20:15 -07006761 // We allow the system server to take screenshots of secure layers for
6762 // use in situations like the Screen-rotation animation and place
6763 // the impetus on WindowManager to not persist them.
chaviwf5bb97b2021-04-28 15:35:37 -05006764 if (captureResults.capturedSecureLayers && !canCaptureBlackoutContent) {
chaviw426b5c02020-07-27 11:20:15 -07006765 ALOGW("FB is protected: PERMISSION_DENIED");
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07006766 return ftl::yield<FenceResult>(base::unexpected(PERMISSION_DENIED)).share();
chaviw426b5c02020-07-27 11:20:15 -07006767 }
6768
Alec Mouria90a5702021-04-16 16:36:21 +00006769 captureResults.buffer = buffer->getBuffer();
Robert Carr12a3b9b2022-03-10 09:55:29 -08006770 auto dataspace = renderArea.getReqDataSpace();
6771 auto parent = renderArea.getParentLayer();
Alec Mourifcedb9c2022-04-11 20:02:17 +00006772 auto renderIntent = RenderIntent::TONE_MAP_COLORIMETRIC;
Sally Qi6c903ca2022-04-25 11:24:20 -07006773 auto sdrWhitePointNits = DisplayDevice::sDefaultMaxLumiance;
6774 auto displayBrightnessNits = DisplayDevice::sDefaultMaxLumiance;
6775
Robert Carr12a3b9b2022-03-10 09:55:29 -08006776 if ((dataspace == ui::Dataspace::UNKNOWN) && (parent != nullptr)) {
6777 Mutex::Autolock lock(mStateLock);
6778 auto display = findDisplay([layerStack = parent->getLayerStack()](const auto& display) {
6779 return display.getLayerStack() == layerStack;
6780 });
6781 if (!display) {
6782 // If the layer is not on a display, use the dataspace for the default display.
6783 display = getDefaultDisplayDeviceLocked();
6784 }
6785
6786 const ui::ColorMode colorMode = display->getCompositionDisplay()->getState().colorMode;
6787 dataspace = pickDataspaceFromColorMode(colorMode);
Alec Mourifcedb9c2022-04-11 20:02:17 +00006788 renderIntent = display->getCompositionDisplay()->getState().renderIntent;
Sally Qi6c903ca2022-04-25 11:24:20 -07006789 sdrWhitePointNits = display->getCompositionDisplay()->getState().sdrWhitePointNits;
6790 displayBrightnessNits = display->getCompositionDisplay()->getState().displayBrightnessNits;
Robert Carr12a3b9b2022-03-10 09:55:29 -08006791 }
6792 captureResults.capturedDataspace = dataspace;
chaviw426b5c02020-07-27 11:20:15 -07006793
chaviwa76b2712017-09-20 12:02:26 -07006794 const auto reqWidth = renderArea.getReqWidth();
6795 const auto reqHeight = renderArea.getReqHeight();
Alec Mouriadb75f42019-03-28 21:42:24 -07006796 const auto sourceCrop = renderArea.getSourceCrop();
Alec Mouri5a6d8572020-03-23 23:56:15 -07006797 const auto transform = renderArea.getTransform();
6798 const auto rotation = renderArea.getRotationFlags();
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02006799 const auto& layerStackSpaceRect = renderArea.getLayerStackSpaceRect();
Dan Stozac1879002014-05-22 15:59:05 -07006800
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006801 renderengine::DisplaySettings clientCompositionDisplay;
Vishnu Nair9b079a22020-01-21 14:36:08 -08006802 std::vector<compositionengine::LayerFE::LayerSettings> clientCompositionLayers;
Romain Guy88d37dd2017-05-26 17:57:05 -07006803
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006804 // assume that bounds are never offset, and that they are the same as the
6805 // buffer bounds.
6806 clientCompositionDisplay.physicalDisplay = Rect(reqWidth, reqHeight);
Alec Mouriadb75f42019-03-28 21:42:24 -07006807 clientCompositionDisplay.clip = sourceCrop;
Alec Mouri5a6d8572020-03-23 23:56:15 -07006808 clientCompositionDisplay.orientation = rotation;
Alec Mouriadb75f42019-03-28 21:42:24 -07006809
Robert Carr12a3b9b2022-03-10 09:55:29 -08006810 clientCompositionDisplay.outputDataspace = dataspace;
Sally Qie258f092022-05-19 15:24:12 -07006811 clientCompositionDisplay.currentLuminanceNits = displayBrightnessNits;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006812 clientCompositionDisplay.maxLuminance = DisplayDevice::sDefaultMaxLumiance;
Alec Mourifcedb9c2022-04-11 20:02:17 +00006813 clientCompositionDisplay.renderIntent =
6814 static_cast<aidl::android::hardware::graphics::composer3::RenderIntent>(renderIntent);
Mathias Agopian180f10d2013-04-10 22:55:41 -07006815
chaviw17ac24b2021-01-28 18:50:05 -08006816 const float colorSaturation = grayscale ? 0 : 1;
6817 clientCompositionDisplay.colorTransform = calculateColorMatrix(colorSaturation);
6818
chaviw50da5042018-04-09 13:49:37 -07006819 const float alpha = RenderArea::getCaptureFillValue(renderArea.getCaptureFill());
Mathias Agopian180f10d2013-04-10 22:55:41 -07006820
Vishnu Nair9b079a22020-01-21 14:36:08 -08006821 compositionengine::LayerFE::LayerSettings fillLayer;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006822 fillLayer.source.buffer.buffer = nullptr;
6823 fillLayer.source.solidColor = half3(0.0, 0.0, 0.0);
Alec Mouri5a6d8572020-03-23 23:56:15 -07006824 fillLayer.geometry.boundaries =
6825 FloatRect(sourceCrop.left, sourceCrop.top, sourceCrop.right, sourceCrop.bottom);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006826 fillLayer.alpha = half(alpha);
6827 clientCompositionLayers.push_back(fillLayer);
6828
Dominik Laskowskib7251f42020-04-20 17:42:59 -07006829 const auto display = renderArea.getDisplayDevice();
Yichi Chen40773d92020-04-01 10:10:18 +08006830 std::vector<Layer*> renderedLayers;
Galia Peycheva66eaf4a2020-11-09 13:17:57 +01006831 bool disableBlurs = false;
chaviwa76b2712017-09-20 12:02:26 -07006832 traverseLayers([&](Layer* layer) {
Robert Carr6a160312021-05-17 12:08:20 -07006833 disableBlurs |= layer->getDrawingState().sidebandStream != nullptr;
Galia Peycheva66eaf4a2020-11-09 13:17:57 +01006834
Lloyd Piquef16688f2019-02-19 17:47:57 -08006835 Region clip(renderArea.getBounds());
6836 compositionengine::LayerFE::ClientCompositionTargetSettings targetSettings{
6837 clip,
Dominik Laskowskib7251f42020-04-20 17:42:59 -07006838 layer->needsFilteringForScreenshots(display.get(), transform) ||
Alec Mouri5a6d8572020-03-23 23:56:15 -07006839 renderArea.needsFiltering(),
Lloyd Piquef16688f2019-02-19 17:47:57 -08006840 renderArea.isSecure(),
Peiyong Lin05cc0112020-10-14 16:16:37 -07006841 useProtected,
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02006842 layerStackSpaceRect,
Vishnu Nairb87d94f2020-02-13 09:17:36 -08006843 clientCompositionDisplay.outputDataspace,
Alec Mourif54453c2021-05-13 16:28:28 -07006844 true, /* realContentIsVisible */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08006845 false, /* clearContent */
Alec Mourif54453c2021-05-13 16:28:28 -07006846 disableBlurs ? compositionengine::LayerFE::ClientCompositionTargetSettings::
6847 BlurSetting::Disabled
6848 : compositionengine::LayerFE::ClientCompositionTargetSettings::
6849 BlurSetting::Enabled,
Sally Qidb653012022-05-04 13:12:22 -07006850 isHdrLayer(layer) ? displayBrightnessNits : sdrWhitePointNits,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07006851
Lloyd Piquef16688f2019-02-19 17:47:57 -08006852 };
Vishnu Nairb87d94f2020-02-13 09:17:36 -08006853 std::vector<compositionengine::LayerFE::LayerSettings> results =
6854 layer->prepareClientCompositionList(targetSettings);
Yichi Chen40773d92020-04-01 10:10:18 +08006855 if (results.size() > 0) {
Alec Mouri5a6d8572020-03-23 23:56:15 -07006856 for (auto& settings : results) {
6857 settings.geometry.positionTransform =
6858 transform.asMatrix4() * settings.geometry.positionTransform;
Lucas Dupin9d763b72020-04-20 18:42:31 -07006859 // There's no need to process blurs when we're executing region sampling,
6860 // we're just trying to understand what we're drawing, and doing so without
6861 // blurs is already a pretty good approximation.
6862 if (regionSampling) {
6863 settings.backgroundBlurRadius = 0;
6864 }
Sally Qidb653012022-05-04 13:12:22 -07006865 captureResults.capturedHdrLayers |= isHdrLayer(layer);
Alec Mouri5a6d8572020-03-23 23:56:15 -07006866 }
Galia Peycheva66eaf4a2020-11-09 13:17:57 +01006867
Yichi Chen40773d92020-04-01 10:10:18 +08006868 clientCompositionLayers.insert(clientCompositionLayers.end(),
6869 std::make_move_iterator(results.begin()),
6870 std::make_move_iterator(results.end()));
6871 renderedLayers.push_back(layer);
6872 }
Galia Peycheva66eaf4a2020-11-09 13:17:57 +01006873
chaviwa76b2712017-09-20 12:02:26 -07006874 });
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006875
Sally Qi59a9f502021-10-12 18:53:23 +00006876 std::vector<renderengine::LayerSettings> clientRenderEngineLayers;
6877 clientRenderEngineLayers.reserve(clientCompositionLayers.size());
Vishnu Nair9b079a22020-01-21 14:36:08 -08006878 std::transform(clientCompositionLayers.begin(), clientCompositionLayers.end(),
Sally Qi59a9f502021-10-12 18:53:23 +00006879 std::back_inserter(clientRenderEngineLayers),
6880 [](compositionengine::LayerFE::LayerSettings& settings)
6881 -> renderengine::LayerSettings { return settings; });
Vishnu Nair9b079a22020-01-21 14:36:08 -08006882
Alec Mouri6338c9d2019-02-07 16:57:51 -08006883 // Use an empty fence for the buffer fence, since we just created the buffer so
6884 // there is no need for synchronization with the GPU.
6885 base::unique_fd bufferFence;
Peiyong Lin05cc0112020-10-14 16:16:37 -07006886 getRenderEngine().useProtectedContext(useProtected);
Alec Mouri0d995102021-02-24 16:53:38 -08006887
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07006888 constexpr bool kUseFramebufferCache = false;
Dominik Laskowskib17c6212022-05-09 09:36:19 -07006889 auto chain =
6890 ftl::Future(getRenderEngine().drawLayers(clientCompositionDisplay,
6891 clientRenderEngineLayers, buffer,
6892 kUseFramebufferCache, std::move(bufferFence)))
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07006893 .then(&toFenceResult);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006894
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07006895 const auto future = chain.share();
Sally Qi59a9f502021-10-12 18:53:23 +00006896 for (auto* layer : renderedLayers) {
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07006897 layer->onLayerDisplayed(future);
Yichi Chen40773d92020-04-01 10:10:18 +08006898 }
Ady Abraham99599942021-01-27 20:27:23 -08006899
Peiyong Lin05cc0112020-10-14 16:16:37 -07006900 // Always switch back to unprotected context.
6901 getRenderEngine().useProtectedContext(false);
Mathias Agopian180f10d2013-04-10 22:55:41 -07006902
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07006903 return future;
Mathias Agopian74c40c02010-09-29 13:02:36 -07006904}
6905
chaviwbf023a62021-06-07 16:00:06 -05006906void SurfaceFlinger::windowInfosReported() {
chaviw95ef3c42019-02-14 10:55:09 -08006907 Mutex::Autolock _l(mStateLock);
Arthur Hung2274a312021-04-28 15:13:06 +00006908 signalSynchronousTransactions(CountDownLatch::eSyncInputWindows);
chaviw95ef3c42019-02-14 10:55:09 -08006909}
chaviw5f21a5e2019-02-14 10:00:34 -08006910
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07006911// ---------------------------------------------------------------------------
6912
Edgar Arriaga844fa672020-01-16 14:21:42 -08006913void SurfaceFlinger::State::traverse(const LayerVector::Visitor& visitor) const {
6914 layersSortedByZ.traverse(visitor);
6915}
6916
Dan Stoza412903f2017-04-27 13:42:17 -07006917void SurfaceFlinger::State::traverseInZOrder(const LayerVector::Visitor& visitor) const {
6918 layersSortedByZ.traverseInZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07006919}
6920
Dan Stoza412903f2017-04-27 13:42:17 -07006921void SurfaceFlinger::State::traverseInReverseZOrder(const LayerVector::Visitor& visitor) const {
6922 layersSortedByZ.traverseInReverseZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07006923}
6924
chaviw4b9d5e12020-08-04 18:30:35 -07006925void SurfaceFlinger::traverseLayersInLayerStack(ui::LayerStack layerStack, const int32_t uid,
Marin Shalamanov1c434292020-06-12 01:47:29 +02006926 const LayerVector::Visitor& visitor) {
chaviwa76b2712017-09-20 12:02:26 -07006927 // We loop through the first level of layers without traversing,
chaviw0e3479f2018-09-10 16:49:30 -07006928 // as we need to determine which layers belong to the requested display.
chaviwa76b2712017-09-20 12:02:26 -07006929 for (const auto& layer : mDrawingState.layersSortedByZ) {
Dominik Laskowski29fa1462021-04-27 15:51:50 -07006930 if (layer->getLayerStack() != layerStack) {
chaviwa76b2712017-09-20 12:02:26 -07006931 continue;
6932 }
Chia-I Wuec2d9852017-11-21 09:21:01 -08006933 // relative layers are traversed in Layer::traverseInZOrder
chaviwa76b2712017-09-20 12:02:26 -07006934 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
Dominik Laskowski29fa1462021-04-27 15:51:50 -07006935 if (layer->isInternalDisplayOverlay()) {
Adrian Roos8acf5a02018-01-17 21:28:19 +01006936 return;
6937 }
chaviwa76b2712017-09-20 12:02:26 -07006938 if (!layer->isVisible()) {
6939 return;
6940 }
chaviw4b9d5e12020-08-04 18:30:35 -07006941 if (uid != CaptureArgs::UNSET_UID && layer->getOwnerUid() != uid) {
6942 return;
6943 }
chaviwa76b2712017-09-20 12:02:26 -07006944 visitor(layer);
6945 });
6946 }
6947}
6948
Marin Shalamanova7fe3042021-01-29 21:02:08 +01006949status_t SurfaceFlinger::setDesiredDisplayModeSpecsInternal(
Steven Thomasd4071902020-03-24 16:02:53 -07006950 const sp<DisplayDevice>& display,
6951 const std::optional<scheduler::RefreshRateConfigs::Policy>& policy, bool overridePolicy) {
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006952 Mutex::Autolock lock(mStateLock);
6953
Ady Abrahamfb853662021-04-09 11:46:40 -07006954 if (mDebugDisplayModeSetByBackdoor) {
6955 // ignore this request as mode is overridden by backdoor
6956 return NO_ERROR;
6957 }
6958
Ady Abrahama92a5682022-06-07 23:35:38 +00006959 const status_t setPolicyResult = display->setRefreshRatePolicy(policy, overridePolicy);
Ady Abraham3efa3942021-06-24 19:01:25 -07006960 if (setPolicyResult < 0) {
6961 return BAD_VALUE;
6962 }
6963 if (setPolicyResult == scheduler::RefreshRateConfigs::CURRENT_POLICY_UNCHANGED) {
6964 return NO_ERROR;
6965 }
6966
Dominik Laskowski76742842022-12-02 14:56:05 -05006967 if (display->isInternal() && !isDisplayActiveLocked(display)) {
6968 // The policy will be be applied when the display becomes active.
6969 ALOGV("%s(%s): Inactive display", __func__, to_string(display->getId()).c_str());
6970 return NO_ERROR;
6971 }
6972
Dominik Laskowskiaf148a22022-11-23 15:45:17 -05006973 return applyRefreshRateConfigsPolicy(display);
6974}
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006975
Dominik Laskowski76742842022-12-02 14:56:05 -05006976status_t SurfaceFlinger::applyRefreshRateConfigsPolicy(const sp<DisplayDevice>& display,
6977 bool force) {
Dominik Laskowskiaf148a22022-11-23 15:45:17 -05006978 const scheduler::RefreshRateConfigs::Policy currentPolicy =
6979 display->refreshRateConfigs().getCurrentPolicy();
Marin Shalamanova7fe3042021-01-29 21:02:08 +01006980 ALOGV("Setting desired display mode specs: %s", currentPolicy.toString().c_str());
Adrian Salidoab6ef6c2019-08-28 10:02:49 -07006981
Ana Krulecb9afd792020-06-11 13:16:15 -07006982 // TODO(b/140204874): Leave the event in until we do proper testing with all apps that might
6983 // be depending in this callback.
Marin Shalamanova7fe3042021-01-29 21:02:08 +01006984 const auto activeMode = display->getActiveMode();
Ady Abraham690f4612021-07-01 23:24:03 -07006985 if (isDisplayActiveLocked(display)) {
6986 mScheduler->onPrimaryDisplayModeChanged(mAppConnectionHandle, activeMode);
6987 toggleKernelIdleTimer();
6988 } else {
6989 mScheduler->onNonPrimaryDisplayModeChanged(mAppConnectionHandle, activeMode);
6990 }
Ady Abraham838de062019-02-04 10:24:03 -08006991
Ady Abraham690f4612021-07-01 23:24:03 -07006992 const DisplayModePtr preferredDisplayMode = [&] {
6993 const auto schedulerMode = mScheduler->getPreferredDisplayMode();
6994 if (schedulerMode && schedulerMode->getPhysicalDisplayId() == display->getPhysicalId()) {
6995 return schedulerMode;
6996 }
6997
6998 return display->getMode(currentPolicy.defaultMode);
6999 }();
7000
Marin Shalamanov228f46b2021-01-28 21:11:45 +01007001 ALOGV("trying to switch to Scheduler preferred mode %d (%s)",
Ady Abraham690f4612021-07-01 23:24:03 -07007002 preferredDisplayMode->getId().value(), to_string(preferredDisplayMode->getFps()).c_str());
Ana Krulec3f6a2062020-01-23 15:48:01 -08007003
Ady Abraham690f4612021-07-01 23:24:03 -07007004 if (display->refreshRateConfigs().isModeAllowed(preferredDisplayMode->getId())) {
Marin Shalamanov228f46b2021-01-28 21:11:45 +01007005 ALOGV("switching to Scheduler preferred display mode %d",
Ady Abraham690f4612021-07-01 23:24:03 -07007006 preferredDisplayMode->getId().value());
Dominik Laskowski76742842022-12-02 14:56:05 -05007007 setDesiredActiveMode({preferredDisplayMode, DisplayModeEvent::Changed}, force);
Ady Abraham2139f732019-11-13 18:56:40 -08007008 } else {
Marin Shalamanov228f46b2021-01-28 21:11:45 +01007009 LOG_ALWAYS_FATAL("Desired display mode not allowed: %d",
Ady Abraham690f4612021-07-01 23:24:03 -07007010 preferredDisplayMode->getId().value());
Dominik Laskowski4f1dd8c2019-04-17 15:54:30 -07007011 }
7012
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08007013 return NO_ERROR;
7014}
7015
Marin Shalamanov228f46b2021-01-28 21:11:45 +01007016status_t SurfaceFlinger::setDesiredDisplayModeSpecs(
7017 const sp<IBinder>& displayToken, ui::DisplayModeId defaultMode, bool allowGroupSwitching,
7018 float primaryRefreshRateMin, float primaryRefreshRateMax, float appRequestRefreshRateMin,
7019 float appRequestRefreshRateMax) {
Ana Krulec0782b882019-10-15 17:34:54 -07007020 ATRACE_CALL();
7021
7022 if (!displayToken) {
7023 return BAD_VALUE;
7024 }
7025
Dominik Laskowski756b7892021-08-04 12:53:59 -07007026 auto future = mScheduler->schedule([=]() -> status_t {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08007027 const auto display = FTL_FAKE_GUARD(mStateLock, getDisplayDeviceLocked(displayToken));
Ana Krulec234bb162019-11-10 22:55:55 +01007028 if (!display) {
Marin Shalamanova7fe3042021-01-29 21:02:08 +01007029 ALOGE("Attempt to set desired display modes for invalid display token %p",
Ana Krulec234bb162019-11-10 22:55:55 +01007030 displayToken.get());
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07007031 return NAME_NOT_FOUND;
Ana Krulec234bb162019-11-10 22:55:55 +01007032 } else if (display->isVirtual()) {
Marin Shalamanova7fe3042021-01-29 21:02:08 +01007033 ALOGW("Attempt to set desired display modes for virtual display");
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07007034 return INVALID_OPERATION;
Ana Krulec234bb162019-11-10 22:55:55 +01007035 } else {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07007036 using Policy = scheduler::RefreshRateConfigs::Policy;
Marin Shalamanova7fe3042021-01-29 21:02:08 +01007037 const Policy policy{DisplayModeId(defaultMode),
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +02007038 allowGroupSwitching,
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07007039 {Fps::fromValue(primaryRefreshRateMin),
7040 Fps::fromValue(primaryRefreshRateMax)},
7041 {Fps::fromValue(appRequestRefreshRateMin),
7042 Fps::fromValue(appRequestRefreshRateMax)}};
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07007043 constexpr bool kOverridePolicy = false;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01007044
Marin Shalamanova7fe3042021-01-29 21:02:08 +01007045 return setDesiredDisplayModeSpecsInternal(display, policy, kOverridePolicy);
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07007046 }
7047 });
7048
7049 return future.get();
Ana Krulec234bb162019-11-10 22:55:55 +01007050}
7051
Marin Shalamanov228f46b2021-01-28 21:11:45 +01007052status_t SurfaceFlinger::getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
7053 ui::DisplayModeId* outDefaultMode,
7054 bool* outAllowGroupSwitching,
7055 float* outPrimaryRefreshRateMin,
7056 float* outPrimaryRefreshRateMax,
7057 float* outAppRequestRefreshRateMin,
7058 float* outAppRequestRefreshRateMax) {
Ana Krulec234bb162019-11-10 22:55:55 +01007059 ATRACE_CALL();
7060
Marin Shalamanova7fe3042021-01-29 21:02:08 +01007061 if (!displayToken || !outDefaultMode || !outPrimaryRefreshRateMin ||
Steven Thomasf734df42020-04-13 21:09:28 -07007062 !outPrimaryRefreshRateMax || !outAppRequestRefreshRateMin || !outAppRequestRefreshRateMax) {
Ana Krulec234bb162019-11-10 22:55:55 +01007063 return BAD_VALUE;
7064 }
7065
7066 Mutex::Autolock lock(mStateLock);
7067 const auto display = getDisplayDeviceLocked(displayToken);
7068 if (!display) {
7069 return NAME_NOT_FOUND;
7070 }
7071
Ady Abraham3efa3942021-06-24 19:01:25 -07007072 if (display->isVirtual()) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07007073 return INVALID_OPERATION;
Ana Krulec234bb162019-11-10 22:55:55 +01007074 }
Ady Abraham3efa3942021-06-24 19:01:25 -07007075
7076 scheduler::RefreshRateConfigs::Policy policy =
7077 display->refreshRateConfigs().getDisplayManagerPolicy();
7078 *outDefaultMode = policy.defaultMode.value();
7079 *outAllowGroupSwitching = policy.allowGroupSwitching;
7080 *outPrimaryRefreshRateMin = policy.primaryRange.min.getValue();
7081 *outPrimaryRefreshRateMax = policy.primaryRange.max.getValue();
7082 *outAppRequestRefreshRateMin = policy.appRequestRange.min.getValue();
7083 *outAppRequestRefreshRateMax = policy.appRequestRange.max.getValue();
7084 return NO_ERROR;
Ana Krulec0782b882019-10-15 17:34:54 -07007085}
7086
Vishnu Nairf9096652021-07-20 18:49:42 -07007087wp<Layer> SurfaceFlinger::fromHandle(const sp<IBinder>& handle) const {
7088 return Layer::fromHandle(handle);
Robert Carrc0df3122019-04-11 13:18:21 -07007089}
7090
Dominik Laskowski75848362019-11-11 17:57:20 -08007091void SurfaceFlinger::onLayerFirstRef(Layer* layer) {
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -07007092 mNumLayers++;
Ady Abrahambe09aad2021-05-03 18:59:38 -07007093 if (!layer->isRemovedFromCurrentState()) {
7094 mScheduler->registerLayer(layer);
7095 }
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -07007096}
7097
7098void SurfaceFlinger::onLayerDestroyed(Layer* layer) {
7099 mNumLayers--;
Robert Carr867be372021-06-29 17:36:02 -07007100 removeHierarchyFromOffscreenLayers(layer);
Ady Abrahambe09aad2021-05-03 18:59:38 -07007101 if (!layer->isRemovedFromCurrentState()) {
7102 mScheduler->deregisterLayer(layer);
7103 }
Dominik Laskowski46471e62022-01-14 15:34:03 -08007104 if (mTransactionTracing) {
7105 mTransactionTracing->onLayerRemoved(layer->getSequence());
Vishnu Nair84125ac2021-12-02 08:47:48 -08007106 }
Valerie Hauc5686802019-11-22 14:18:09 -08007107}
7108
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07007109void SurfaceFlinger::onLayerUpdate() {
7110 scheduleCommit(FrameHint::kActive);
7111}
7112
Valerie Hauc5686802019-11-22 14:18:09 -08007113// WARNING: ONLY CALL THIS FROM LAYER DTOR
7114// Here we add children in the current state to offscreen layers and remove the
7115// layer itself from the offscreen layer list. Since
7116// this is the dtor, it is safe to access the current state. This keeps us
7117// from dangling children layers such that they are not reachable from the
7118// Drawing state nor the offscreen layer list
7119// See b/141111965
Robert Carr867be372021-06-29 17:36:02 -07007120void SurfaceFlinger::removeHierarchyFromOffscreenLayers(Layer* layer) {
Valerie Hauc5686802019-11-22 14:18:09 -08007121 for (auto& child : layer->getCurrentChildren()) {
7122 mOffscreenLayers.emplace(child.get());
7123 }
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -07007124 mOffscreenLayers.erase(layer);
7125}
7126
Robert Carr867be372021-06-29 17:36:02 -07007127void SurfaceFlinger::removeFromOffscreenLayers(Layer* layer) {
7128 mOffscreenLayers.erase(layer);
7129}
7130
Vishnu Nair08f6eae2019-11-26 14:01:39 -08007131status_t SurfaceFlinger::setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
7132 float lightPosY, float lightPosZ,
7133 float lightRadius) {
7134 Mutex::Autolock _l(mStateLock);
7135 mCurrentState.globalShadowSettings.ambientColor = vec4(ambientColor);
7136 mCurrentState.globalShadowSettings.spotColor = vec4(spotColor);
7137 mCurrentState.globalShadowSettings.lightPos.y = lightPosY;
7138 mCurrentState.globalShadowSettings.lightPos.z = lightPosZ;
7139 mCurrentState.globalShadowSettings.lightRadius = lightRadius;
7140
7141 // these values are overridden when calculating the shadow settings for a layer.
7142 mCurrentState.globalShadowSettings.lightPos.x = 0.f;
7143 mCurrentState.globalShadowSettings.length = 0.f;
Vishnu Nairb13bb952019-11-15 10:24:08 -08007144 return NO_ERROR;
7145}
7146
Lloyd Pique8d9f8362020-02-11 19:13:09 -08007147const std::unordered_map<std::string, uint32_t>& SurfaceFlinger::getGenericLayerMetadataKeyMap()
7148 const {
7149 // TODO(b/149500060): Remove this fixed/static mapping. Please prefer taking
7150 // on the work to remove the table in that bug rather than adding more to
7151 // it.
7152 static const std::unordered_map<std::string, uint32_t> genericLayerMetadataKeyMap{
Lloyd Pique8d9f8362020-02-11 19:13:09 -08007153 {"org.chromium.arc.V1_0.TaskId", METADATA_TASK_ID},
7154 {"org.chromium.arc.V1_0.CursorInfo", METADATA_MOUSE_CURSOR},
7155 };
7156 return genericLayerMetadataKeyMap;
7157}
7158
Steven Thomas62a4cf82020-01-31 12:04:03 -08007159status_t SurfaceFlinger::setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,
Marin Shalamanovc5986772021-03-16 16:09:49 +01007160 int8_t compatibility, int8_t changeFrameRateStrategy) {
7161 if (!ValidateFrameRate(frameRate, compatibility, changeFrameRateStrategy,
7162 "SurfaceFlinger::setFrameRate")) {
Steven Thomas62a4cf82020-01-31 12:04:03 -08007163 return BAD_VALUE;
7164 }
7165
Dominik Laskowski756b7892021-08-04 12:53:59 -07007166 static_cast<void>(mScheduler->schedule([=] {
Ady Abraham60e42ea2020-03-09 19:17:31 -07007167 Mutex::Autolock lock(mStateLock);
7168 if (authenticateSurfaceTextureLocked(surface)) {
7169 sp<Layer> layer = (static_cast<MonitoredProducer*>(surface.get()))->getLayer();
Ady Abraham162f6432020-10-08 18:40:47 +00007170 if (layer == nullptr) {
7171 ALOGE("Attempt to set frame rate on a layer that no longer exists");
7172 return BAD_VALUE;
7173 }
Marin Shalamanovc5986772021-03-16 16:09:49 +01007174 const auto strategy =
7175 Layer::FrameRate::convertChangeFrameRateStrategy(changeFrameRateStrategy);
Ady Abraham60e42ea2020-03-09 19:17:31 -07007176 if (layer->setFrameRate(
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07007177 Layer::FrameRate(Fps::fromValue(frameRate),
Marin Shalamanov46084422020-10-13 12:33:42 +02007178 Layer::FrameRate::convertCompatibility(compatibility),
Marin Shalamanovc5986772021-03-16 16:09:49 +01007179 strategy))) {
Ady Abraham60e42ea2020-03-09 19:17:31 -07007180 setTransactionFlags(eTraversalNeeded);
7181 }
7182 } else {
7183 ALOGE("Attempt to set frame rate on an unrecognized IGraphicBufferProducer");
7184 return BAD_VALUE;
Steven Thomas62a4cf82020-01-31 12:04:03 -08007185 }
Ady Abraham60e42ea2020-03-09 19:17:31 -07007186 return NO_ERROR;
7187 }));
7188
Steven Thomas62a4cf82020-01-31 12:04:03 -08007189 return NO_ERROR;
7190}
7191
Andy Yu2ae6b6b2021-11-18 14:51:06 -08007192status_t SurfaceFlinger::setOverrideFrameRate(uid_t uid, float frameRate) {
7193 PhysicalDisplayId displayId = [&]() {
7194 Mutex::Autolock lock(mStateLock);
7195 return getDefaultDisplayDeviceLocked()->getPhysicalId();
7196 }();
7197
7198 mScheduler->setGameModeRefreshRateForUid(FrameRateOverride{static_cast<uid_t>(uid), frameRate});
7199 mScheduler->onFrameRateOverridesChanged(mAppConnectionHandle, displayId);
7200 return NO_ERROR;
7201}
7202
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10007203status_t SurfaceFlinger::setFrameTimelineInfo(const sp<IGraphicBufferProducer>& surface,
7204 const FrameTimelineInfo& frameTimelineInfo) {
Ady Abraham74e17562020-08-24 18:18:19 -07007205 Mutex::Autolock lock(mStateLock);
7206 if (!authenticateSurfaceTextureLocked(surface)) {
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10007207 ALOGE("Attempt to set frame timeline info on an unrecognized IGraphicBufferProducer");
Ady Abraham74e17562020-08-24 18:18:19 -07007208 return BAD_VALUE;
7209 }
7210
7211 sp<Layer> layer = (static_cast<MonitoredProducer*>(surface.get()))->getLayer();
Ady Abrahamfdf1bff2020-09-28 11:27:30 -07007212 if (layer == nullptr) {
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10007213 ALOGE("Attempt to set frame timeline info on a layer that no longer exists");
Ady Abrahamfdf1bff2020-09-28 11:27:30 -07007214 return BAD_VALUE;
7215 }
7216
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10007217 layer->setFrameTimelineInfoForBuffer(frameTimelineInfo);
Ady Abraham74e17562020-08-24 18:18:19 -07007218 return NO_ERROR;
7219}
7220
Dominik Laskowski20134642020-04-20 22:36:44 -07007221void SurfaceFlinger::enableRefreshRateOverlay(bool enable) {
Ady Abraham1b11bc62021-06-03 19:51:19 -07007222 for (const auto& [ignored, display] : mDisplays) {
7223 if (display->isInternal()) {
7224 display->enableRefreshRateOverlay(enable, mRefreshRateOverlaySpinner);
Dominik Laskowski20134642020-04-20 22:36:44 -07007225 }
Ady Abraham1b11bc62021-06-03 19:51:19 -07007226 }
Dominik Laskowski20134642020-04-20 22:36:44 -07007227}
7228
Pablo Gamito6ee484d2020-07-30 14:26:28 +00007229status_t SurfaceFlinger::addTransactionTraceListener(
7230 const sp<gui::ITransactionTraceListener>& listener) {
7231 if (!listener) {
7232 return BAD_VALUE;
7233 }
7234
7235 mInterceptor->addTransactionTraceListener(listener);
7236
7237 return NO_ERROR;
7238}
7239
Ana Krulec31f2b3c2020-12-14 14:30:09 -08007240int SurfaceFlinger::getGPUContextPriority() {
Alec Mourid6f09462020-12-07 11:18:17 -08007241 return getRenderEngine().getContextPriority();
Ana Krulec31f2b3c2020-12-14 14:30:09 -08007242}
7243
Ady Abraham899dcdb2021-06-15 16:56:21 -07007244int SurfaceFlinger::calculateMaxAcquiredBufferCount(Fps refreshRate,
7245 std::chrono::nanoseconds presentLatency) {
7246 auto pipelineDepth = presentLatency.count() / refreshRate.getPeriodNsecs();
7247 if (presentLatency.count() % refreshRate.getPeriodNsecs()) {
Ady Abraham564f9de2021-02-03 18:34:33 -08007248 pipelineDepth++;
7249 }
Ady Abraham899dcdb2021-06-15 16:56:21 -07007250 return std::max(1ll, pipelineDepth - 1);
Ady Abraham564f9de2021-02-03 18:34:33 -08007251}
7252
Ady Abraham899dcdb2021-06-15 16:56:21 -07007253status_t SurfaceFlinger::getMaxAcquiredBufferCount(int* buffers) const {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07007254 Fps maxRefreshRate = 60_Hz;
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07007255
7256 if (!getHwComposer().isHeadless()) {
7257 if (const auto display = getDefaultDisplayDevice()) {
7258 maxRefreshRate = display->refreshRateConfigs().getSupportedRefreshRateRange().max;
Ady Abraham3efa3942021-06-24 19:01:25 -07007259 }
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07007260 }
7261
7262 *buffers = getMaxAcquiredBufferCountForRefreshRate(maxRefreshRate);
Ady Abraham564f9de2021-02-03 18:34:33 -08007263 return NO_ERROR;
7264}
7265
rnleeed20fa42021-08-10 18:00:03 -07007266uint32_t SurfaceFlinger::getMaxAcquiredBufferCountForCurrentRefreshRate(uid_t uid) const {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07007267 Fps refreshRate = 60_Hz;
Ady Abraham3efa3942021-06-24 19:01:25 -07007268
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07007269 if (const auto frameRateOverride = mScheduler->getFrameRateOverride(uid)) {
7270 refreshRate = *frameRateOverride;
7271 } else if (!getHwComposer().isHeadless()) {
Dominik Laskowski298b08e2022-02-15 13:45:02 -08007272 if (const auto display = FTL_FAKE_GUARD(mStateLock, getDefaultDisplayDeviceLocked())) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08007273 refreshRate = display->refreshRateConfigs().getActiveMode()->getFps();
Ady Abraham3efa3942021-06-24 19:01:25 -07007274 }
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07007275 }
Ady Abraham3efa3942021-06-24 19:01:25 -07007276
Ady Abraham899dcdb2021-06-15 16:56:21 -07007277 return getMaxAcquiredBufferCountForRefreshRate(refreshRate);
7278}
7279
7280int SurfaceFlinger::getMaxAcquiredBufferCountForRefreshRate(Fps refreshRate) const {
7281 const auto vsyncConfig = mVsyncConfiguration->getConfigsForRefreshRate(refreshRate).late;
7282 const auto presentLatency = vsyncConfig.appWorkDuration + vsyncConfig.sfWorkDuration;
7283 return calculateMaxAcquiredBufferCount(refreshRate, presentLatency);
7284}
7285
Vishnu Nair0fc7af52022-01-13 08:11:34 -08007286void SurfaceFlinger::handleLayerCreatedLocked(const LayerCreatedState& state) {
7287 sp<Layer> layer = state.layer.promote();
arthurhungdba591c2021-02-08 17:28:49 +08007288 if (!layer) {
Vishnu Nair0fc7af52022-01-13 08:11:34 -08007289 ALOGD("Layer was destroyed soon after creation %p", state.layer.unsafe_get());
7290 return;
arthurhungdba591c2021-02-08 17:28:49 +08007291 }
7292
7293 sp<Layer> parent;
Vishnu Nair0fc7af52022-01-13 08:11:34 -08007294 bool addToRoot = state.addToRoot;
7295 if (state.initialParent != nullptr) {
7296 parent = state.initialParent.promote();
arthurhungdba591c2021-02-08 17:28:49 +08007297 if (parent == nullptr) {
Vishnu Nair0fc7af52022-01-13 08:11:34 -08007298 ALOGD("Parent was destroyed soon after creation %p", state.initialParent.unsafe_get());
Garfield Tand712ad32021-10-27 13:44:22 -07007299 addToRoot = false;
arthurhungdba591c2021-02-08 17:28:49 +08007300 }
arthurhungdba591c2021-02-08 17:28:49 +08007301 }
7302
Garfield Tand712ad32021-10-27 13:44:22 -07007303 if (parent == nullptr && addToRoot) {
Vishnu Nair14d218b2021-07-13 13:57:39 -07007304 layer->setIsAtRoot(true);
arthurhungdba591c2021-02-08 17:28:49 +08007305 mCurrentState.layersSortedByZ.add(layer);
7306 } else if (parent == nullptr) {
7307 layer->onRemovedFromCurrentState();
7308 } else if (parent->isRemovedFromCurrentState()) {
7309 parent->addChild(layer);
7310 layer->onRemovedFromCurrentState();
7311 } else {
7312 parent->addChild(layer);
7313 }
7314
Ady Abraham1273ac12021-08-26 17:31:53 -07007315 layer->updateTransformHint(mActiveDisplayTransformHint);
Arthur Hungb6aa9a02021-06-09 14:23:01 +08007316
Arthur Hung23e07502021-10-15 11:58:19 +00007317 mInterceptor->saveSurfaceCreation(layer);
arthurhungdba591c2021-02-08 17:28:49 +08007318}
Ady Abraham562c2712021-05-07 15:10:42 -07007319
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07007320void SurfaceFlinger::sample() {
Ady Abraham562c2712021-05-07 15:10:42 -07007321 if (!mLumaSampling || !mRegionSamplingThread) {
7322 return;
7323 }
7324
Dominik Laskowski756b7892021-08-04 12:53:59 -07007325 mRegionSamplingThread->onCompositionComplete(mScheduler->getScheduledFrameTime());
Ady Abraham562c2712021-05-07 15:10:42 -07007326}
7327
Ady Abrahamed3290f2021-05-17 15:12:14 -07007328void SurfaceFlinger::onActiveDisplaySizeChanged(const sp<DisplayDevice>& activeDisplay) {
7329 mScheduler->onActiveDisplayAreaChanged(activeDisplay->getWidth() * activeDisplay->getHeight());
7330 getRenderEngine().onActiveDisplaySizeChanged(activeDisplay->getSize());
7331}
7332
7333void SurfaceFlinger::onActiveDisplayChangedLocked(const sp<DisplayDevice>& activeDisplay) {
7334 ATRACE_CALL();
7335
Dominik Laskowski76742842022-12-02 14:56:05 -05007336 // During boot, SF powers on the primary display, which is the first display to be active. In
7337 // that case, there is no need to force setDesiredActiveMode, because DM is about to send its
7338 // policy via setDesiredDisplayModeSpecs.
7339 bool forceApplyPolicy = false;
7340
Ady Abrahamdb036a82021-07-16 14:18:34 -07007341 if (const auto display = getDisplayDeviceLocked(mActiveDisplayToken)) {
7342 display->getCompositionDisplay()->setLayerCachingTexturePoolEnabled(false);
Dominik Laskowski76742842022-12-02 14:56:05 -05007343 forceApplyPolicy = true;
Ady Abrahamdb036a82021-07-16 14:18:34 -07007344 }
7345
Ady Abrahamed3290f2021-05-17 15:12:14 -07007346 if (!activeDisplay) {
7347 ALOGE("%s: activeDisplay is null", __func__);
7348 return;
7349 }
Dominik Laskowski76742842022-12-02 14:56:05 -05007350
7351 ALOGI("Active display is %s", to_string(activeDisplay->getPhysicalId()).c_str());
7352
Ady Abrahamdb036a82021-07-16 14:18:34 -07007353 mActiveDisplayToken = activeDisplay->getDisplayToken();
Ady Abrahamdb036a82021-07-16 14:18:34 -07007354 activeDisplay->getCompositionDisplay()->setLayerCachingTexturePoolEnabled(true);
Ady Abraham3efa3942021-06-24 19:01:25 -07007355 updateInternalDisplayVsyncLocked(activeDisplay);
Ady Abraham690f4612021-07-01 23:24:03 -07007356 mScheduler->setModeChangePending(false);
Ady Abraham3efa3942021-06-24 19:01:25 -07007357 mScheduler->setRefreshRateConfigs(activeDisplay->holdRefreshRateConfigs());
Ady Abrahamed3290f2021-05-17 15:12:14 -07007358 onActiveDisplaySizeChanged(activeDisplay);
Ady Abraham1273ac12021-08-26 17:31:53 -07007359 mActiveDisplayTransformHint = activeDisplay->getTransformHint();
Ady Abraham85d692d2021-09-28 14:08:54 -07007360
Dominik Laskowskiaf148a22022-11-23 15:45:17 -05007361 // The policy of the new active/leader display may have changed while it was inactive. In that
7362 // case, its preferred mode has not been propagated to HWC (via setDesiredActiveMode). In either
7363 // case, the Scheduler's cachedModeChangedParams must be initialized to the newly active mode,
7364 // and the kernel idle timer of the newly active display must be toggled.
Dominik Laskowski76742842022-12-02 14:56:05 -05007365 applyRefreshRateConfigsPolicy(activeDisplay, forceApplyPolicy);
Ady Abrahamed3290f2021-05-17 15:12:14 -07007366}
7367
chaviw60c9d3e2021-06-04 12:52:17 -05007368status_t SurfaceFlinger::addWindowInfosListener(
7369 const sp<IWindowInfosListener>& windowInfosListener) const {
7370 mWindowInfosListenerInvoker->addWindowInfosListener(windowInfosListener);
7371 return NO_ERROR;
7372}
7373
7374status_t SurfaceFlinger::removeWindowInfosListener(
7375 const sp<IWindowInfosListener>& windowInfosListener) const {
7376 mWindowInfosListenerInvoker->removeWindowInfosListener(windowInfosListener);
7377 return NO_ERROR;
7378}
7379
Vishnu Nairdbbe3852022-01-12 20:22:11 -08007380std::shared_ptr<renderengine::ExternalTexture> SurfaceFlinger::getExternalTextureFromBufferData(
7381 const BufferData& bufferData, const char* layerName) const {
7382 bool cacheIdChanged = bufferData.flags.test(BufferData::BufferDataChange::cachedBufferChanged);
7383 bool bufferSizeExceedsLimit = false;
7384 std::shared_ptr<renderengine::ExternalTexture> buffer = nullptr;
7385 if (cacheIdChanged && bufferData.buffer != nullptr) {
7386 bufferSizeExceedsLimit = exceedsMaxRenderTargetSize(bufferData.buffer->getWidth(),
7387 bufferData.buffer->getHeight());
7388 if (!bufferSizeExceedsLimit) {
7389 ClientCache::getInstance().add(bufferData.cachedBuffer, bufferData.buffer);
7390 buffer = ClientCache::getInstance().get(bufferData.cachedBuffer);
7391 }
7392 } else if (cacheIdChanged) {
7393 buffer = ClientCache::getInstance().get(bufferData.cachedBuffer);
7394 } else if (bufferData.buffer != nullptr) {
7395 bufferSizeExceedsLimit = exceedsMaxRenderTargetSize(bufferData.buffer->getWidth(),
7396 bufferData.buffer->getHeight());
7397 if (!bufferSizeExceedsLimit) {
7398 buffer = std::make_shared<
7399 renderengine::impl::ExternalTexture>(bufferData.buffer, getRenderEngine(),
7400 renderengine::impl::ExternalTexture::
7401 Usage::READABLE);
7402 }
7403 }
7404 ALOGE_IF(bufferSizeExceedsLimit,
7405 "Attempted to create an ExternalTexture for layer %s that exceeds render target size "
7406 "limit.",
7407 layerName);
7408 return buffer;
7409}
Vishnu Nair0fc7af52022-01-13 08:11:34 -08007410
7411bool SurfaceFlinger::commitCreatedLayers() {
7412 std::vector<LayerCreatedState> createdLayers;
7413 {
7414 std::scoped_lock<std::mutex> lock(mCreatedLayersLock);
7415 createdLayers = std::move(mCreatedLayers);
7416 mCreatedLayers.clear();
7417 if (createdLayers.size() == 0) {
7418 return false;
7419 }
7420 }
7421
7422 Mutex::Autolock _l(mStateLock);
7423 for (const auto& createdLayer : createdLayers) {
7424 handleLayerCreatedLocked(createdLayer);
7425 }
7426 createdLayers.clear();
7427 mLayersAdded = true;
7428 return true;
7429}
Huihong Luo9e84f332021-12-16 14:33:46 -08007430
7431// gui::ISurfaceComposer
Huihong Luob5cb7c12022-02-14 14:26:04 -08007432
7433binder::Status SurfaceComposerAIDL::createDisplay(const std::string& displayName, bool secure,
7434 sp<IBinder>* outDisplay) {
7435 status_t status = checkAccessPermission();
7436 if (status == OK) {
7437 String8 displayName8 = String8::format("%s", displayName.c_str());
7438 *outDisplay = mFlinger->createDisplay(displayName8, secure);
7439 return binder::Status::ok();
7440 }
7441 return binder::Status::fromStatusT(status);
7442}
7443
7444binder::Status SurfaceComposerAIDL::destroyDisplay(const sp<IBinder>& display) {
7445 status_t status = checkAccessPermission();
7446 if (status == OK) {
7447 mFlinger->destroyDisplay(display);
7448 return binder::Status::ok();
7449 }
7450 return binder::Status::fromStatusT(status);
7451}
7452
7453binder::Status SurfaceComposerAIDL::getPhysicalDisplayIds(std::vector<int64_t>* outDisplayIds) {
7454 std::vector<PhysicalDisplayId> physicalDisplayIds = mFlinger->getPhysicalDisplayIds();
7455 std::vector<int64_t> displayIds;
7456 displayIds.reserve(physicalDisplayIds.size());
7457 for (auto item : physicalDisplayIds) {
7458 displayIds.push_back(static_cast<int64_t>(item.value));
7459 }
7460 *outDisplayIds = displayIds;
7461 return binder::Status::ok();
7462}
7463
7464binder::Status SurfaceComposerAIDL::getPrimaryPhysicalDisplayId(int64_t* outDisplayId) {
7465 status_t status = checkAccessPermission();
7466 if (status != OK) {
7467 return binder::Status::fromStatusT(status);
7468 }
7469
7470 PhysicalDisplayId id;
7471 status = mFlinger->getPrimaryPhysicalDisplayId(&id);
7472 if (status == NO_ERROR) {
7473 *outDisplayId = id.value;
7474 }
7475 return binder::Status::fromStatusT(status);
7476}
7477
7478binder::Status SurfaceComposerAIDL::getPhysicalDisplayToken(int64_t displayId,
7479 sp<IBinder>* outDisplay) {
7480 const auto id = DisplayId::fromValue<PhysicalDisplayId>(static_cast<uint64_t>(displayId));
7481 *outDisplay = mFlinger->getPhysicalDisplayToken(*id);
7482 return binder::Status::ok();
7483}
7484
Huihong Luo694aeff2022-02-15 10:43:00 -08007485binder::Status SurfaceComposerAIDL::setPowerMode(const sp<IBinder>& display, int mode) {
7486 status_t status = checkAccessPermission();
7487 if (status != OK) return binder::Status::fromStatusT(status);
7488
7489 mFlinger->setPowerMode(display, mode);
7490 return binder::Status::ok();
7491}
7492
Huihong Luo0fd1af92022-02-15 10:43:00 -08007493binder::Status SurfaceComposerAIDL::getDisplayStats(const sp<IBinder>& display,
7494 gui::DisplayStatInfo* outStatInfo) {
7495 DisplayStatInfo statInfo;
7496 status_t status = mFlinger->getDisplayStats(display, &statInfo);
7497 if (status == NO_ERROR) {
7498 outStatInfo->vsyncTime = static_cast<long>(statInfo.vsyncTime);
7499 outStatInfo->vsyncPeriod = static_cast<long>(statInfo.vsyncPeriod);
7500 }
7501 return binder::Status::fromStatusT(status);
7502}
7503
7504binder::Status SurfaceComposerAIDL::getDisplayState(const sp<IBinder>& display,
7505 gui::DisplayState* outState) {
7506 ui::DisplayState state;
7507 status_t status = mFlinger->getDisplayState(display, &state);
7508 if (status == NO_ERROR) {
7509 outState->layerStack = state.layerStack.id;
7510 outState->orientation = static_cast<gui::Rotation>(state.orientation);
7511 outState->layerStackSpaceRect.width = state.layerStackSpaceRect.width;
7512 outState->layerStackSpaceRect.height = state.layerStackSpaceRect.height;
7513 }
7514 return binder::Status::fromStatusT(status);
7515}
7516
Huihong Luo694aeff2022-02-15 10:43:00 -08007517binder::Status SurfaceComposerAIDL::clearBootDisplayMode(const sp<IBinder>& display) {
7518 status_t status = checkAccessPermission();
7519 if (status != OK) return binder::Status::fromStatusT(status);
7520
7521 status = mFlinger->clearBootDisplayMode(display);
7522 return binder::Status::fromStatusT(status);
7523}
7524
7525binder::Status SurfaceComposerAIDL::getBootDisplayModeSupport(bool* outMode) {
7526 status_t status = checkAccessPermission();
7527 if (status != OK) return binder::Status::fromStatusT(status);
7528
7529 status = mFlinger->getBootDisplayModeSupport(outMode);
7530 return binder::Status::fromStatusT(status);
7531}
7532
7533binder::Status SurfaceComposerAIDL::setAutoLowLatencyMode(const sp<IBinder>& display, bool on) {
7534 status_t status = checkAccessPermission();
7535 if (status != OK) return binder::Status::fromStatusT(status);
7536
7537 mFlinger->setAutoLowLatencyMode(display, on);
7538 return binder::Status::ok();
7539}
7540
7541binder::Status SurfaceComposerAIDL::setGameContentType(const sp<IBinder>& display, bool on) {
7542 status_t status = checkAccessPermission();
7543 if (status != OK) return binder::Status::fromStatusT(status);
7544
7545 mFlinger->setGameContentType(display, on);
7546 return binder::Status::ok();
7547}
7548
Huihong Luo9e84f332021-12-16 14:33:46 -08007549binder::Status SurfaceComposerAIDL::captureDisplay(
7550 const DisplayCaptureArgs& args, const sp<IScreenCaptureListener>& captureListener) {
7551 status_t status = mFlinger->captureDisplay(args, captureListener);
7552 return binder::Status::fromStatusT(status);
7553}
7554
7555binder::Status SurfaceComposerAIDL::captureDisplayById(
7556 int64_t displayId, const sp<IScreenCaptureListener>& captureListener) {
7557 status_t status;
7558 IPCThreadState* ipc = IPCThreadState::self();
7559 const int uid = ipc->getCallingUid();
7560 if (uid == AID_ROOT || uid == AID_GRAPHICS || uid == AID_SYSTEM || uid == AID_SHELL) {
7561 std::optional<DisplayId> id = DisplayId::fromValue(static_cast<uint64_t>(displayId));
7562 status = mFlinger->captureDisplay(*id, captureListener);
7563 } else {
7564 status = PERMISSION_DENIED;
7565 }
7566 return binder::Status::fromStatusT(status);
7567}
7568
7569binder::Status SurfaceComposerAIDL::captureLayers(
7570 const LayerCaptureArgs& args, const sp<IScreenCaptureListener>& captureListener) {
7571 status_t status = mFlinger->captureLayers(args, captureListener);
7572 return binder::Status::fromStatusT(status);
7573}
7574
Huihong Luo694aeff2022-02-15 10:43:00 -08007575binder::Status SurfaceComposerAIDL::isWideColorDisplay(const sp<IBinder>& token,
7576 bool* outIsWideColorDisplay) {
7577 status_t status = mFlinger->isWideColorDisplay(token, outIsWideColorDisplay);
7578 return binder::Status::fromStatusT(status);
7579}
7580
7581binder::Status SurfaceComposerAIDL::getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
7582 bool* outSupport) {
7583 status_t status = mFlinger->getDisplayBrightnessSupport(displayToken, outSupport);
7584 return binder::Status::fromStatusT(status);
7585}
7586
7587binder::Status SurfaceComposerAIDL::setDisplayBrightness(const sp<IBinder>& displayToken,
7588 const gui::DisplayBrightness& brightness) {
7589 status_t status = checkControlDisplayBrightnessPermission();
7590 if (status != OK) return binder::Status::fromStatusT(status);
7591
7592 status = mFlinger->setDisplayBrightness(displayToken, brightness);
7593 return binder::Status::fromStatusT(status);
7594}
7595
7596binder::Status SurfaceComposerAIDL::addHdrLayerInfoListener(
7597 const sp<IBinder>& displayToken, const sp<gui::IHdrLayerInfoListener>& listener) {
7598 status_t status = checkControlDisplayBrightnessPermission();
7599 if (status != OK) return binder::Status::fromStatusT(status);
7600
7601 status = mFlinger->addHdrLayerInfoListener(displayToken, listener);
7602 return binder::Status::fromStatusT(status);
7603}
7604
7605binder::Status SurfaceComposerAIDL::removeHdrLayerInfoListener(
7606 const sp<IBinder>& displayToken, const sp<gui::IHdrLayerInfoListener>& listener) {
7607 status_t status = checkControlDisplayBrightnessPermission();
7608 if (status != OK) return binder::Status::fromStatusT(status);
7609
7610 status = mFlinger->removeHdrLayerInfoListener(displayToken, listener);
7611 return binder::Status::fromStatusT(status);
7612}
7613
7614binder::Status SurfaceComposerAIDL::notifyPowerBoost(int boostId) {
7615 status_t status = checkAccessPermission();
7616 if (status != OK) return binder::Status::fromStatusT(status);
7617
7618 status = mFlinger->notifyPowerBoost(boostId);
7619 return binder::Status::fromStatusT(status);
7620}
7621
Huihong Luob5cb7c12022-02-14 14:26:04 -08007622status_t SurfaceComposerAIDL::checkAccessPermission(bool usePermissionCache) {
7623 if (!mFlinger->callingThreadHasUnscopedSurfaceFlingerAccess(usePermissionCache)) {
7624 IPCThreadState* ipc = IPCThreadState::self();
7625 ALOGE("Permission Denial: can't access SurfaceFlinger pid=%d, uid=%d", ipc->getCallingPid(),
7626 ipc->getCallingUid());
7627 return PERMISSION_DENIED;
7628 }
7629 return OK;
7630}
7631
Huihong Luo694aeff2022-02-15 10:43:00 -08007632status_t SurfaceComposerAIDL::checkControlDisplayBrightnessPermission() {
7633 IPCThreadState* ipc = IPCThreadState::self();
7634 const int pid = ipc->getCallingPid();
7635 const int uid = ipc->getCallingUid();
Rheygine Medel9e9281e2022-09-22 10:13:56 -07007636 if ((uid != AID_GRAPHICS) && (uid != AID_SYSTEM) &&
Huihong Luo694aeff2022-02-15 10:43:00 -08007637 !PermissionCache::checkPermission(sControlDisplayBrightness, pid, uid)) {
7638 ALOGE("Permission Denial: can't control brightness pid=%d, uid=%d", pid, uid);
7639 return PERMISSION_DENIED;
7640 }
7641 return OK;
7642}
7643
Dominik Laskowski9dab3432019-03-27 13:21:10 -07007644} // namespace android
Lloyd Pique074e8122018-07-26 12:57:23 -07007645
Mathias Agopian3f844832013-08-07 21:24:32 -07007646#if defined(__gl_h_)
7647#error "don't include gl/gl.h in this file"
7648#endif
7649
7650#if defined(__gl2_h_)
7651#error "don't include gl2/gl2.h in this file"
Chia-I Wu767fcf72017-11-30 22:07:38 -08007652#endif
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08007653
7654// TODO(b/129481165): remove the #pragma below and fix conversion issues
Marin Shalamanovbed7fd32020-12-21 20:02:20 +01007655#pragma clang diagnostic pop // ignored "-Wconversion -Wextra"