blob: a2e7ccb465fc2ae440c9930f0856a357de43d0b7 [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
Ana Krulecb9afd792020-06-11 13:16:15 -070027#include <android-base/properties.h>
Alec Mouri5f487d42020-02-06 09:26:19 -080028#include <android/configuration.h>
29#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
30#include <android/hardware/configstore/1.1/ISurfaceFlingerConfigs.h>
31#include <android/hardware/configstore/1.1/types.h>
Lais Andrade3a6e47d2020-04-02 11:20:16 +010032#include <android/hardware/power/Boost.h>
Steven Thomas62a4cf82020-01-31 12:04:03 -080033#include <android/native_window.h>
Chris Ye0783e992020-06-02 21:34:49 -070034#include <android/os/BnSetInputWindowsListener.h>
35#include <android/os/IInputFlinger.h>
Mathias Agopianc5b2c0b2009-05-19 19:08:10 -070036#include <binder/IPCThreadState.h>
37#include <binder/IServiceManager.h>
Mathias Agopian99b49842011-06-27 16:05:52 -070038#include <binder/PermissionCache.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070039#include <compositionengine/CompositionEngine.h>
Lloyd Piqueab039b52019-02-13 14:22:42 -080040#include <compositionengine/CompositionRefreshArgs.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070041#include <compositionengine/Display.h>
Lloyd Pique3d0c02e2018-10-19 18:38:12 -070042#include <compositionengine/DisplayColorProfile.h>
Lloyd Pique9370a482019-10-03 17:58:30 -070043#include <compositionengine/DisplayCreationArgs.h>
Lloyd Piquede196652020-01-22 17:29:58 -080044#include <compositionengine/LayerFECompositionState.h>
Lloyd Piquecc01a452018-12-04 17:24:00 -080045#include <compositionengine/OutputLayer.h>
Lloyd Pique31cb2942018-10-19 17:23:03 -070046#include <compositionengine/RenderSurface.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070047#include <compositionengine/impl/OutputCompositionState.h>
John Reckdb1a16b2021-07-09 13:05:52 -040048#include <compositionengine/impl/OutputLayerCompositionState.h>
Alec Mouri5f487d42020-02-06 09:26:19 -080049#include <configstore/Utils.h>
50#include <cutils/compiler.h>
51#include <cutils/properties.h>
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -080052#include <ftl/future.h>
Jamie Gennis1a4d8832012-08-02 20:11:05 -070053#include <gui/BufferQueue.h>
Ady Abrahama3b08ef2019-07-15 18:43:10 -070054#include <gui/DebugEGLImageTracker.h>
Jamie Gennis1a4d8832012-08-02 20:11:05 -070055#include <gui/IDisplayEventConnection.h>
Alec Mouri0a9c7b82018-11-16 13:05:25 -080056#include <gui/IProducerListener.h>
Kalle Raitaa099a242017-01-11 11:17:29 -080057#include <gui/LayerDebugInfo.h>
Lloyd Pique4603f3c2020-02-11 12:06:56 -080058#include <gui/LayerMetadata.h>
Steven Thomas62a4cf82020-01-31 12:04:03 -080059#include <gui/LayerState.h>
Mathias Agopiane3c697f2013-02-14 17:11:02 -080060#include <gui/Surface.h>
rnlee60f46b52021-05-21 15:14:07 -070061#include <gui/TraceUtils.h>
Steven Moreland7c8af942020-07-08 18:35:51 +000062#include <hidl/ServiceManagement.h>
Alec Mouri5f487d42020-02-06 09:26:19 -080063#include <layerproto/LayerProtoParser.h>
64#include <log/log.h>
65#include <private/android_filesystem_config.h>
66#include <private/gui/SyncFeatures.h>
Wei Wang976a6452021-06-11 15:26:00 -070067#include <processgroup/processgroup.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070068#include <renderengine/RenderEngine.h>
Alec Mouri5f487d42020-02-06 09:26:19 -080069#include <sys/types.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070070#include <ui/ColorSpace.h>
71#include <ui/DebugUtils.h>
Marin Shalamanov045b7002021-01-07 16:56:24 +010072#include <ui/DisplayId.h>
Marin Shalamanova7fe3042021-01-29 21:02:08 +010073#include <ui/DisplayMode.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070074#include <ui/DisplayStatInfo.h>
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -080075#include <ui/DisplayState.h>
Marin Shalamanov228f46b2021-01-28 21:11:45 +010076#include <ui/DynamicDisplayInfo.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070077#include <ui/GraphicBufferAllocator.h>
78#include <ui/PixelFormat.h>
Marin Shalamanov228f46b2021-01-28 21:11:45 +010079#include <ui/StaticDisplayInfo.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080080#include <utils/StopWatch.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070081#include <utils/String16.h>
82#include <utils/String8.h>
Yusuke Sato0a688f52015-07-30 23:05:39 -070083#include <utils/Timers.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070084#include <utils/misc.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080085
Alec Mouri5f487d42020-02-06 09:26:19 -080086#include <algorithm>
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -080087#include <cerrno>
Alec Mouri5f487d42020-02-06 09:26:19 -080088#include <cinttypes>
89#include <cmath>
90#include <cstdint>
91#include <functional>
92#include <mutex>
93#include <optional>
Michael Wright44753b12020-07-08 13:48:11 +010094#include <type_traits>
Alec Mouri5f487d42020-02-06 09:26:19 -080095#include <unordered_map>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080096
Robert Carr578038f2018-03-09 12:25:24 -080097#include "BufferLayer.h"
Marissa Wallfd668622018-05-10 10:21:13 -070098#include "BufferQueueLayer.h"
Marissa Wall61c58622018-07-18 10:12:20 -070099#include "BufferStateLayer.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +0200100#include "Client.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +0200101#include "Colorizer.h"
Robert Carr578038f2018-03-09 12:25:24 -0800102#include "ContainerLayer.h"
Robert Carr578038f2018-03-09 12:25:24 -0800103#include "DisplayDevice.h"
Steven Thomasb02664d2017-07-26 18:48:28 -0700104#include "DisplayHardware/ComposerHal.h"
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700105#include "DisplayHardware/DisplayIdentification.h"
Mathias Agopiana4912602012-07-12 14:25:33 -0700106#include "DisplayHardware/FramebufferSurface.h"
Mathias Agopiana350ff92010-08-10 17:14:02 -0700107#include "DisplayHardware/HWComposer.h"
Marin Shalamanovd3b5c5d2021-02-11 18:26:14 +0100108#include "DisplayHardware/Hal.h"
Jesse Hall99c7dbb2013-03-14 14:29:29 -0700109#include "DisplayHardware/VirtualDisplaySurface.h"
Marin Shalamanovf6b5d182020-06-12 02:08:51 +0200110#include "DisplayRenderArea.h"
Alec Mouri5f487d42020-02-06 09:26:19 -0800111#include "EffectLayer.h"
Mathias Agopianff2ed702013-09-01 21:36:12 -0700112#include "Effects/Daltonizer.h"
Alec Mouriadebf5c2021-01-05 12:57:36 -0800113#include "FpsReporter.h"
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700114#include "FrameTimeline/FrameTimeline.h"
Mikael Pessa90092f42019-08-26 17:22:04 -0700115#include "FrameTracer/FrameTracer.h"
John Reck88270902021-03-18 11:27:35 -0400116#include "HdrLayerInfoReporter.h"
Alec Mouri5f487d42020-02-06 09:26:19 -0800117#include "Layer.h"
Marin Shalamanovf6b5d182020-06-12 02:08:51 +0200118#include "LayerRenderArea.h"
Alec Mouri5f487d42020-02-06 09:26:19 -0800119#include "LayerVector.h"
120#include "MonitoredProducer.h"
121#include "NativeWindowSurface.h"
122#include "RefreshRateOverlay.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700123#include "RegionSamplingThread.h"
Ana Krulec241cf832018-08-10 15:03:23 -0700124#include "Scheduler/DispSyncSource.h"
Ana Krulecfefcb582018-08-07 14:22:37 -0700125#include "Scheduler/EventThread.h"
Ady Abraham5def7332020-05-29 16:13:47 -0700126#include "Scheduler/LayerHistory.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -0700127#include "Scheduler/MessageQueue.h"
Ana Krulec98b5b242018-08-10 15:03:23 -0700128#include "Scheduler/Scheduler.h"
Ady Abrahamc581d3c2020-08-06 17:34:27 -0700129#include "Scheduler/VsyncConfiguration.h"
Ady Abraham8cb21882020-08-26 18:22:05 -0700130#include "Scheduler/VsyncController.h"
Alec Mouri5f487d42020-02-06 09:26:19 -0800131#include "StartPropertySetThread.h"
132#include "SurfaceFlingerProperties.h"
133#include "SurfaceInterceptor.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800134#include "TimeStats/TimeStats.h"
Galia Peycheva8f04b302021-04-27 13:25:38 +0200135#include "TunnelModeEnabledReporter.h"
chaviw60c9d3e2021-06-04 12:52:17 -0500136#include "WindowInfosListenerInvoker.h"
Dominik Laskowskib6e54372019-09-04 14:06:28 -0700137#include "android-base/parseint.h"
David Sodman7e4ae112018-02-09 15:02:28 -0800138#include "android-base/stringprintf.h"
Marin Shalamanovd3b5c5d2021-02-11 18:26:14 +0100139#include "android-base/strings.h"
David Sodman7e4ae112018-02-09 15:02:28 -0800140
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700141#define MAIN_THREAD ACQUIRE(mStateLock) RELEASE(mStateLock)
142
143#define ON_MAIN_THREAD(expr) \
144 [&] { \
145 LOG_FATAL_IF(std::this_thread::get_id() != mMainThreadId); \
146 UnnecessaryLock lock(mStateLock); \
147 return (expr); \
148 }()
149
Ady Abrahamb4937392021-06-23 18:05:03 -0700150#define MAIN_THREAD_GUARD(expr) \
151 [&] { \
152 LOG_FATAL_IF(std::this_thread::get_id() != mMainThreadId); \
153 MainThreadScopedGuard lock(SF_MAIN_THREAD); \
154 return (expr); \
155 }()
156
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700157#undef NO_THREAD_SAFETY_ANALYSIS
158#define NO_THREAD_SAFETY_ANALYSIS \
159 _Pragma("GCC error \"Prefer MAIN_THREAD macros or {Conditional,Timed,Unnecessary}Lock.\"")
160
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800161namespace android {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700162
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700163using namespace std::string_literals;
164
Jaesoo Lee43518572017-01-23 19:03:16 +0900165using namespace android::hardware::configstore;
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900166using namespace android::hardware::configstore::V1_0;
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900167using namespace android::sysprop;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -0800168
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100169using android::hardware::power::Boost;
Yiwei Zhang5434a782018-12-05 18:06:32 -0800170using base::StringAppendF;
chaviw60c9d3e2021-06-04 12:52:17 -0500171using gui::IWindowInfosListener;
chaviw3277faf2021-05-19 16:45:23 -0500172using gui::WindowInfo;
Peiyong Lin9f034472018-03-28 15:29:00 -0700173using ui::ColorMode;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700174using ui::Dataspace;
Daniel Solomon42d04562019-01-20 21:03:19 -0800175using ui::DisplayPrimaries;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700176using ui::RenderIntent;
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900177
Peiyong Line9d809e2020-04-14 13:10:48 -0700178namespace hal = android::hardware::graphics::composer::hal;
179
Steven Thomasb02664d2017-07-26 18:48:28 -0700180namespace {
Peiyong Linfca547f2018-07-09 13:03:33 -0700181
182#pragma clang diagnostic push
183#pragma clang diagnostic error "-Wswitch-enum"
184
185bool isWideColorMode(const ColorMode colorMode) {
186 switch (colorMode) {
187 case ColorMode::DISPLAY_P3:
188 case ColorMode::ADOBE_RGB:
189 case ColorMode::DCI_P3:
190 case ColorMode::BT2020:
Valerie Hau9758ae02018-10-09 16:05:09 -0700191 case ColorMode::DISPLAY_BT2020:
Peiyong Linfca547f2018-07-09 13:03:33 -0700192 case ColorMode::BT2100_PQ:
193 case ColorMode::BT2100_HLG:
194 return true;
195 case ColorMode::NATIVE:
196 case ColorMode::STANDARD_BT601_625:
197 case ColorMode::STANDARD_BT601_625_UNADJUSTED:
198 case ColorMode::STANDARD_BT601_525:
199 case ColorMode::STANDARD_BT601_525_UNADJUSTED:
200 case ColorMode::STANDARD_BT709:
201 case ColorMode::SRGB:
202 return false;
203 }
204 return false;
205}
206
207#pragma clang diagnostic pop
208
Dominik Laskowski542c9dc2020-04-10 12:42:02 -0700209template <typename Mutex>
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700210struct SCOPED_CAPABILITY ConditionalLockGuard {
211 ConditionalLockGuard(Mutex& mutex, bool lock) ACQUIRE(mutex) : mutex(mutex), lock(lock) {
Dominik Laskowski542c9dc2020-04-10 12:42:02 -0700212 if (lock) mutex.lock();
Steven Thomasb02664d2017-07-26 18:48:28 -0700213 }
Dominik Laskowski542c9dc2020-04-10 12:42:02 -0700214
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700215 ~ConditionalLockGuard() RELEASE() {
Dominik Laskowski542c9dc2020-04-10 12:42:02 -0700216 if (lock) mutex.unlock();
217 }
218
219 Mutex& mutex;
220 const bool lock;
Steven Thomasb02664d2017-07-26 18:48:28 -0700221};
Peiyong Linfca547f2018-07-09 13:03:33 -0700222
Dominik Laskowski542c9dc2020-04-10 12:42:02 -0700223using ConditionalLock = ConditionalLockGuard<Mutex>;
224
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700225struct SCOPED_CAPABILITY TimedLock {
226 TimedLock(Mutex& mutex, nsecs_t timeout, const char* whence) ACQUIRE(mutex)
227 : mutex(mutex), status(mutex.timedLock(timeout)) {
228 ALOGE_IF(!locked(), "%s timed out locking: %s (%d)", whence, strerror(-status), status);
229 }
230
231 ~TimedLock() RELEASE() {
232 if (locked()) mutex.unlock();
233 }
234
235 bool locked() const { return status == NO_ERROR; }
236
237 Mutex& mutex;
238 const status_t status;
239};
240
241struct SCOPED_CAPABILITY UnnecessaryLock {
242 explicit UnnecessaryLock(Mutex& mutex) ACQUIRE(mutex) {}
243 ~UnnecessaryLock() RELEASE() {}
244};
245
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100246// TODO(b/141333600): Consolidate with DisplayMode::Builder::getDefaultDensity.
Dominik Laskowskid125d0e2020-05-08 12:36:39 -0700247constexpr float FALLBACK_DENSITY = ACONFIGURATION_DENSITY_TV;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800248
249float getDensityFromProperty(const char* property, bool required) {
250 char value[PROPERTY_VALUE_MAX];
251 const float density = property_get(property, value, nullptr) > 0 ? std::atof(value) : 0.f;
252 if (!density && required) {
253 ALOGE("%s must be defined as a build property", property);
254 return FALLBACK_DENSITY;
255 }
Dominik Laskowskid125d0e2020-05-08 12:36:39 -0700256 return density;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800257}
258
Peiyong Lin9d846a52018-11-05 13:18:20 -0800259// Currently we only support V0_SRGB and DISPLAY_P3 as composition preference.
260bool validateCompositionDataspace(Dataspace dataspace) {
261 return dataspace == Dataspace::V0_SRGB || dataspace == Dataspace::DISPLAY_P3;
262}
263
Steven Thomasd4071902020-03-24 16:02:53 -0700264class FrameRateFlexibilityToken : public BBinder {
265public:
266 FrameRateFlexibilityToken(std::function<void()> callback) : mCallback(callback) {}
267 virtual ~FrameRateFlexibilityToken() { mCallback(); }
268
269private:
270 std::function<void()> mCallback;
271};
272
Vishnu Nair24e3bba2021-02-23 14:19:36 -0800273enum Permission {
274 ACCESS_SURFACE_FLINGER = 0x1,
275 ROTATE_SURFACE_FLINGER = 0x2,
276};
277
Steven Thomasb02664d2017-07-26 18:48:28 -0700278} // namespace anonymous
279
Chris Ye0783e992020-06-02 21:34:49 -0700280struct SetInputWindowsListener : os::BnSetInputWindowsListener {
281 explicit SetInputWindowsListener(std::function<void()> listenerCb) : mListenerCb(listenerCb) {}
282
283 binder::Status onSetInputWindowsFinished() override;
284
285 std::function<void()> mListenerCb;
286};
287
288binder::Status SetInputWindowsListener::onSetInputWindowsFinished() {
289 if (mListenerCb != nullptr) {
290 mListenerCb();
291 }
292 return binder::Status::ok();
293}
294
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800295// ---------------------------------------------------------------------------
296
Mathias Agopian99b49842011-06-27 16:05:52 -0700297const String16 sHardwareTest("android.permission.HARDWARE_TEST");
298const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER");
Hongwei Wang46213ea2020-12-04 17:17:31 -0800299const String16 sRotateSurfaceFlinger("android.permission.ROTATE_SURFACE_FLINGER");
Mathias Agopian99b49842011-06-27 16:05:52 -0700300const String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER");
John Reck88270902021-03-18 11:27:35 -0400301const String16 sControlDisplayBrightness("android.permission.CONTROL_DISPLAY_BRIGHTNESS");
Mathias Agopian99b49842011-06-27 16:05:52 -0700302const String16 sDump("android.permission.DUMP");
chaviwf5bb97b2021-04-28 15:35:37 -0500303const String16 sCaptureBlackoutContent("android.permission.CAPTURE_BLACKOUT_CONTENT");
304
Amy Hsuc8cdfef2020-05-07 13:06:25 +0800305const char* KERNEL_IDLE_TIMER_PROP = "graphics.display.kernel_idle_timer.enabled";
Mathias Agopian99b49842011-06-27 16:05:52 -0700306
307// ---------------------------------------------------------------------------
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700308int64_t SurfaceFlinger::dispSyncPresentTimeOffset;
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700309bool SurfaceFlinger::useHwcForRgbToYuv;
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800310bool SurfaceFlinger::hasSyncFramework;
Fabien Sanglard1971b632017-03-10 14:50:03 -0800311int64_t SurfaceFlinger::maxFrameBufferAcquiredBuffers;
Brian Lindahla13f2d52020-03-05 11:54:17 +0100312uint32_t SurfaceFlinger::maxGraphicsWidth;
313uint32_t SurfaceFlinger::maxGraphicsHeight;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600314bool SurfaceFlinger::hasWideColorDisplay;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800315ui::Rotation SurfaceFlinger::internalDisplayOrientation = ui::ROTATION_0;
Peiyong Lin13effd12018-07-24 17:01:47 -0700316bool SurfaceFlinger::useColorManagement;
Peiyong Linb3839ad2018-09-05 15:37:19 -0700317bool SurfaceFlinger::useContextPriority;
Peiyong Linc6780972018-10-28 15:24:08 -0700318Dataspace SurfaceFlinger::defaultCompositionDataspace = Dataspace::V0_SRGB;
319ui::PixelFormat SurfaceFlinger::defaultCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
320Dataspace SurfaceFlinger::wideColorGamutCompositionDataspace = Dataspace::V0_SRGB;
321ui::PixelFormat SurfaceFlinger::wideColorGamutCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
Ana Krulec3803b8d2020-02-03 16:35:46 -0800322bool SurfaceFlinger::useFrameRateApi;
John Reckac09e452021-04-07 16:35:37 -0400323bool SurfaceFlinger::enableSdrDimming;
Huihong Luo86c80e32021-06-16 15:41:07 -0700324bool SurfaceFlinger::enableLatchUnsignaled;
Mathias Agopian99b49842011-06-27 16:05:52 -0700325
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800326std::string decodeDisplayColorSetting(DisplayColorSetting displayColorSetting) {
327 switch(displayColorSetting) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800328 case DisplayColorSetting::kManaged:
Chia-I Wu0d711262018-05-21 15:19:35 -0700329 return std::string("Managed");
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800330 case DisplayColorSetting::kUnmanaged:
Chia-I Wu0d711262018-05-21 15:19:35 -0700331 return std::string("Unmanaged");
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800332 case DisplayColorSetting::kEnhanced:
Chia-I Wu0d711262018-05-21 15:19:35 -0700333 return std::string("Enhanced");
334 default:
335 return std::string("Unknown ") +
336 std::to_string(static_cast<int>(displayColorSetting));
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800337 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800338}
339
Hongwei Wang46213ea2020-12-04 17:17:31 -0800340bool callingThreadHasRotateSurfaceFlingerAccess() {
341 IPCThreadState* ipc = IPCThreadState::self();
342 const int pid = ipc->getCallingPid();
343 const int uid = ipc->getCallingUid();
344 return uid == AID_GRAPHICS || uid == AID_SYSTEM ||
345 PermissionCache::checkPermission(sRotateSurfaceFlinger, pid, uid);
346}
347
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700348SurfaceFlinger::SurfaceFlinger(Factory& factory, SkipInitializationTag)
349 : mFactory(factory),
Pablo Gamitoc351d6f2020-09-17 15:34:26 +0000350 mInterceptor(mFactory.createSurfaceInterceptor()),
Yiwei Zhangf0229a72019-09-09 19:28:02 -0700351 mTimeStats(std::make_shared<impl::TimeStats>()),
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -0800352 mFrameTracer(mFactory.createFrameTracer()),
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800353 mFrameTimeline(mFactory.createFrameTimeline(mTimeStats, getpid())),
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700354 mEventQueue(mFactory.createMessageQueue()),
Dominik Laskowskieddeda12019-07-19 11:54:13 -0700355 mCompositionEngine(mFactory.createCompositionEngine()),
Dominik Laskowskif06d68e2021-03-24 19:40:03 -0700356 mHwcServiceName(base::GetProperty("debug.sf.hwc_service_name"s, "default"s)),
Robert Carr3e2a2992021-06-11 13:42:55 -0700357 mTunnelModeEnabledReporter(new TunnelModeEnabledReporter()),
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800358 mInternalDisplayDensity(getDensityFromProperty("ro.sf.lcd_density", true)),
Alec Mouridea1ac52021-06-23 18:12:18 -0700359 mEmulatedDisplayDensity(getDensityFromProperty("qemu.sf.lcd_density", false)),
chaviw60c9d3e2021-06-04 12:52:17 -0500360 mPowerAdvisor(*this),
361 mWindowInfosListenerInvoker(new WindowInfosListenerInvoker()) {
Dominik Laskowskif06d68e2021-03-24 19:40:03 -0700362 ALOGI("Using HWComposer service: %s", mHwcServiceName.c_str());
363
Chris Ye0783e992020-06-02 21:34:49 -0700364 mSetInputWindowsListener = new SetInputWindowsListener([&]() { setInputWindowsFinished(); });
365}
Lloyd Piqueac648ee2018-01-17 13:42:24 -0800366
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700367SurfaceFlinger::SurfaceFlinger(Factory& factory) : SurfaceFlinger(factory, SkipInitialization) {
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800368 ALOGI("SurfaceFlinger is starting");
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800369
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900370 hasSyncFramework = running_without_sync_framework(true);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800371
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900372 dispSyncPresentTimeOffset = present_time_offset_from_vsync_ns(0);
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700373
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900374 useHwcForRgbToYuv = force_hwc_copy_for_virtual_displays(false);
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700375
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900376 maxFrameBufferAcquiredBuffers = max_frame_buffer_acquired_buffers(2);
Fabien Sanglard1971b632017-03-10 14:50:03 -0800377
Brian Lindahla13f2d52020-03-05 11:54:17 +0100378 maxGraphicsWidth = std::max(max_graphics_width(0), 0);
379 maxGraphicsHeight = std::max(max_graphics_height(0), 0);
380
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900381 hasWideColorDisplay = has_wide_color_display(false);
Peiyong Lin0256f722018-08-31 15:45:10 -0700382
Peiyong Lin6cedd682020-10-23 15:07:07 -0700383 // Android 12 and beyond, color management in display pipeline is turned on
384 // by default.
385 useColorManagement = use_color_management(true);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600386
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900387 mDefaultCompositionDataspace =
388 static_cast<ui::Dataspace>(default_composition_dataspace(Dataspace::V0_SRGB));
Peiyong Lin8cabfc32019-06-14 14:25:43 -0700389 mWideColorGamutCompositionDataspace = static_cast<ui::Dataspace>(wcg_composition_dataspace(
390 hasWideColorDisplay ? Dataspace::DISPLAY_P3 : Dataspace::V0_SRGB));
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900391 defaultCompositionDataspace = mDefaultCompositionDataspace;
392 wideColorGamutCompositionDataspace = mWideColorGamutCompositionDataspace;
393 defaultCompositionPixelFormat = static_cast<ui::PixelFormat>(
394 default_composition_pixel_format(ui::PixelFormat::RGBA_8888));
395 wideColorGamutCompositionPixelFormat =
396 static_cast<ui::PixelFormat>(wcg_composition_pixel_format(ui::PixelFormat::RGBA_8888));
Peiyong Linb3839ad2018-09-05 15:37:19 -0700397
Yichi Chenda901bf2019-06-28 14:58:27 +0800398 mColorSpaceAgnosticDataspace =
399 static_cast<ui::Dataspace>(color_space_agnostic_dataspace(Dataspace::UNKNOWN));
400
Alec Mouri023c1882021-05-08 16:36:33 -0700401 mLayerCachingEnabled = [] {
402 const bool enable =
403 android::sysprop::SurfaceFlingerProperties::enable_layer_caching().value_or(false);
404 return base::GetBoolProperty(std::string("debug.sf.enable_layer_caching"), enable);
405 }();
406
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900407 useContextPriority = use_context_priority(true);
Iris Chang7501ed62018-04-30 14:45:42 +0800408
Dominik Laskowski718f9602019-11-09 20:01:35 -0800409 using Values = SurfaceFlingerProperties::primary_display_orientation_values;
410 switch (primary_display_orientation(Values::ORIENTATION_0)) {
411 case Values::ORIENTATION_0:
Iris Chang7501ed62018-04-30 14:45:42 +0800412 break;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800413 case Values::ORIENTATION_90:
414 internalDisplayOrientation = ui::ROTATION_90;
Iris Chang7501ed62018-04-30 14:45:42 +0800415 break;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800416 case Values::ORIENTATION_180:
417 internalDisplayOrientation = ui::ROTATION_180;
Iris Chang7501ed62018-04-30 14:45:42 +0800418 break;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800419 case Values::ORIENTATION_270:
420 internalDisplayOrientation = ui::ROTATION_270;
Iris Chang7501ed62018-04-30 14:45:42 +0800421 break;
422 }
Dominik Laskowski718f9602019-11-09 20:01:35 -0800423 ALOGV("Internal Display Orientation: %s", toCString(internalDisplayOrientation));
Iris Chang7501ed62018-04-30 14:45:42 +0800424
Sundong Ahn85131bd2019-02-18 15:51:53 +0900425 mInternalDisplayPrimaries = sysprop::getDisplayNativePrimaries();
Daniel Solomon42d04562019-01-20 21:03:19 -0800426
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800427 // debugging stuff...
428 char value[PROPERTY_VALUE_MAX];
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700429
Mathias Agopianb4b17302013-03-20 18:36:41 -0700430 property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");
Mathias Agopian50210b92013-03-21 21:13:21 -0700431 mGpuToCpuSupported = !atoi(value);
Mathias Agopianb4b17302013-03-20 18:36:41 -0700432
Alec Mouri5f487d42020-02-06 09:26:19 -0800433 property_get("ro.build.type", value, "user");
434 mIsUserBuild = strcmp(value, "user") == 0;
435
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800436 property_get("debug.sf.showupdates", value, "0");
437 mDebugRegion = atoi(value);
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700438
Mathias Agopianc1d359d2012-08-04 20:09:03 -0700439 ALOGI_IF(mDebugRegion, "showupdates enabled");
Orion Hodson34397da2019-02-04 09:36:10 +0000440
441 // DDMS debugging deprecated (b/120782499)
442 property_get("debug.sf.ddms", value, "0");
443 int debugDdms = atoi(value);
444 ALOGI_IF(debugDdms, "DDMS debugging not supported");
Dan Stozac5da2712016-07-20 15:38:12 -0700445
Ady Abrahamadb9a992019-09-19 21:21:55 +0000446 property_get("debug.sf.enable_gl_backpressure", value, "0");
447 mPropagateBackpressureClientComposition = atoi(value);
448 ALOGI_IF(mPropagateBackpressureClientComposition,
449 "Enabling backpressure propagation for Client Composition");
450
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800451 property_get("ro.surface_flinger.supports_background_blur", value, "0");
452 bool supportsBlurs = atoi(value);
Lucas Dupin00f16422020-03-11 11:33:04 -0700453 mSupportsBlur = supportsBlurs;
454 ALOGI_IF(!mSupportsBlur, "Disabling blur effects, they are not supported.");
Lucas Dupin2dd6f392020-02-18 17:43:36 -0800455 property_get("ro.sf.blurs_are_expensive", value, "0");
456 mBlursAreExpensive = atoi(value);
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800457
Ady Abrahamb89ca7d2020-03-04 11:19:37 -0800458 const size_t defaultListSize = ISurfaceComposer::MAX_LAYERS;
Dan Stoza0a0158c2018-03-16 13:38:54 -0700459 auto listSize = property_get_int32("debug.sf.max_igbp_list_size", int32_t(defaultListSize));
460 mMaxGraphicBufferProducerListSize = (listSize > 0) ? size_t(listSize) : defaultListSize;
Alec Mouri601393f2020-02-21 13:26:52 -0800461 mGraphicBufferProducerListSizeLogThreshold =
462 std::max(static_cast<int>(0.95 *
463 static_cast<double>(mMaxGraphicBufferProducerListSize)),
464 1);
Dan Stoza0a0158c2018-03-16 13:38:54 -0700465
Dan Stozaec460082018-12-17 15:35:09 -0800466 property_get("debug.sf.luma_sampling", value, "1");
467 mLumaSampling = atoi(value);
468
Vishnu Nairb2a999b2020-01-23 13:43:02 -0800469 property_get("debug.sf.disable_client_composition_cache", value, "0");
Vishnu Nair9b079a22020-01-21 14:36:08 -0800470 mDisableClientCompositionCache = atoi(value);
471
Romain Guy11d63f42017-07-20 12:47:14 -0700472 // We should be reading 'persist.sys.sf.color_saturation' here
473 // but since /data may be encrypted, we need to wait until after vold
474 // comes online to attempt to read the property. The property is
475 // instead read after the boot animation
Kalle Raitaa099a242017-01-11 11:17:29 -0800476
Dominik Laskowskif06d68e2021-03-24 19:40:03 -0700477 if (base::GetBoolProperty("debug.sf.treble_testing_override"s, false)) {
Kalle Raitaa099a242017-01-11 11:17:29 -0800478 // Without the override SurfaceFlinger cannot connect to HIDL
479 // services that are not listed in the manifests. Considered
480 // deriving the setting from the set service name, but it
481 // would be brittle if the name that's not 'default' is used
482 // for production purposes later on.
Dominik Laskowskif06d68e2021-03-24 19:40:03 -0700483 ALOGI("Enabling Treble testing override");
Steven Moreland7c8af942020-07-08 18:35:51 +0000484 android::hardware::details::setTrebleTestingOverride(true);
Kalle Raitaa099a242017-01-11 11:17:29 -0800485 }
Ana Krulec3803b8d2020-02-03 16:35:46 -0800486
487 useFrameRateApi = use_frame_rate_api(true);
Ana Krulecb9afd792020-06-11 13:16:15 -0700488
489 mKernelIdleTimerEnabled = mSupportKernelIdleTimer = sysprop::support_kernel_idle_timer(false);
490 base::SetProperty(KERNEL_IDLE_TIMER_PROP, mKernelIdleTimerEnabled ? "true" : "false");
Ady Abraham29d0da32020-07-16 18:39:33 -0700491
492 mRefreshRateOverlaySpinner = property_get_bool("sf.debug.show_refresh_rate_overlay_spinner", 0);
John Reckac09e452021-04-07 16:35:37 -0400493
494 // Debug property overrides ro. property
495 enableSdrDimming = property_get_bool("debug.sf.enable_sdr_dimming", enable_sdr_dimming(false));
Huihong Luo86c80e32021-06-16 15:41:07 -0700496
497 enableLatchUnsignaled = base::GetBoolProperty("debug.sf.latch_unsignaled"s, false);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800498}
499
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700500SurfaceFlinger::~SurfaceFlinger() = default;
501
502void SurfaceFlinger::onFirstRef() {
Lloyd Pique3fcdef12018-01-22 17:14:00 -0800503 mEventQueue->init(this);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800504}
505
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700506void SurfaceFlinger::binderDied(const wp<IBinder>&) {
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800507 // the window manager died on us. prepare its eulogy.
Rob Carr2aa78cb2020-03-10 14:27:49 -0700508 mBootFinished = false;
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800509
Vishnu Nairb9df4702021-03-01 11:53:15 -0800510 // Sever the link to inputflinger since its gone as well.
511 static_cast<void>(schedule([=] { mInputFlinger = nullptr; }));
512
Andy McFadden13a082e2012-08-24 10:16:42 -0700513 // restore initial conditions (default device unblank, etc)
514 initializeDisplays();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800515
516 // restart the boot-animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700517 startBootAnim();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800518}
519
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700520void SurfaceFlinger::run() {
521 while (true) {
522 mEventQueue->waitMessage();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800523 }
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700524}
525
526template <typename F, typename T>
527inline std::future<T> SurfaceFlinger::schedule(F&& f) {
528 auto [task, future] = makeTask(std::move(f));
529 mEventQueue->postMessage(std::move(task));
530 return std::move(future);
Robert Carr1db73f62016-12-21 12:58:51 -0800531}
532
533sp<ISurfaceComposerClient> SurfaceFlinger::createConnection() {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700534 const sp<Client> client = new Client(this);
535 return client->initCheck() == NO_ERROR ? client : nullptr;
Robert Carr1db73f62016-12-21 12:58:51 -0800536}
537
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700538sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName, bool secure) {
chaviwd4a61642020-09-01 14:53:46 -0700539 // onTransact already checks for some permissions, but adding an additional check here.
540 // This is to ensure that only system and graphics can request to create a secure
541 // display. Secure displays can show secure content so we add an additional restriction on it.
542 const int uid = IPCThreadState::self()->getCallingUid();
543 if (secure && uid != AID_GRAPHICS && uid != AID_SYSTEM) {
544 ALOGE("Only privileged processes can create a secure display");
545 return nullptr;
546 }
547
Mathias Agopiane57f2922012-08-09 16:29:12 -0700548 class DisplayToken : public BBinder {
549 sp<SurfaceFlinger> flinger;
550 virtual ~DisplayToken() {
551 // no more references, this display must be terminated
552 Mutex::Autolock _l(flinger->mStateLock);
553 flinger->mCurrentState.displays.removeItem(this);
554 flinger->setTransactionFlags(eDisplayTransactionNeeded);
555 }
556 public:
Chih-Hung Hsiehc4067912016-05-03 14:03:27 -0700557 explicit DisplayToken(const sp<SurfaceFlinger>& flinger)
Mathias Agopiane57f2922012-08-09 16:29:12 -0700558 : flinger(flinger) {
559 }
560 };
561
562 sp<BBinder> token = new DisplayToken(this);
563
564 Mutex::Autolock _l(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700565 // Display ID is assigned when virtual display is allocated by HWC.
566 DisplayDeviceState state;
567 state.isSecure = secure;
568 state.displayName = displayName;
569 mCurrentState.displays.add(token, state);
570 mInterceptor->saveDisplayCreation(state);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700571 return token;
572}
573
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700574void SurfaceFlinger::destroyDisplay(const sp<IBinder>& displayToken) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700575 Mutex::Autolock lock(mStateLock);
Jesse Hall6c913be2013-08-08 12:15:49 -0700576
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700577 const ssize_t index = mCurrentState.displays.indexOfKey(displayToken);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700578 if (index < 0) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700579 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
Jesse Hall6c913be2013-08-08 12:15:49 -0700580 return;
581 }
582
Dominik Laskowski075d3172018-05-24 15:50:06 -0700583 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700584 if (state.physical) {
585 ALOGE("%s: Invalid operation on physical display", __FUNCTION__);
Jesse Hall6c913be2013-08-08 12:15:49 -0700586 return;
587 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700588 mInterceptor->saveDisplayDeletion(state.sequenceId);
589 mCurrentState.displays.removeItemsAt(index);
Jesse Hall6c913be2013-08-08 12:15:49 -0700590 setTransactionFlags(eDisplayTransactionNeeded);
591}
592
Dominik Laskowski13948602021-03-08 20:48:28 -0800593void SurfaceFlinger::enableHalVirtualDisplays(bool enable) {
594 auto& generator = mVirtualDisplayIdGenerators.hal;
595 if (!generator && enable) {
596 ALOGI("Enabling HAL virtual displays");
597 generator.emplace(getHwComposer().getMaxVirtualDisplayCount());
598 } else if (generator && !enable) {
599 ALOGW_IF(generator->inUse(), "Disabling HAL virtual displays while in use");
600 generator.reset();
601 }
602}
603
Dominik Laskowski263eec42021-07-21 23:13:24 -0700604VirtualDisplayId SurfaceFlinger::acquireVirtualDisplay(ui::Size resolution,
605 ui::PixelFormat format) {
Dominik Laskowski13948602021-03-08 20:48:28 -0800606 if (auto& generator = mVirtualDisplayIdGenerators.hal) {
607 if (const auto id = generator->generateId()) {
Dominik Laskowski263eec42021-07-21 23:13:24 -0700608 if (getHwComposer().allocateVirtualDisplay(*id, resolution, &format)) {
Dominik Laskowski13948602021-03-08 20:48:28 -0800609 return *id;
610 }
611
612 generator->releaseId(*id);
613 } else {
614 ALOGW("%s: Exhausted HAL virtual displays", __func__);
615 }
616
617 ALOGW("%s: Falling back to GPU virtual display", __func__);
618 }
619
620 const auto id = mVirtualDisplayIdGenerators.gpu.generateId();
621 LOG_ALWAYS_FATAL_IF(!id, "Failed to generate ID for GPU virtual display");
622 return *id;
623}
624
625void SurfaceFlinger::releaseVirtualDisplay(VirtualDisplayId displayId) {
626 if (const auto id = HalVirtualDisplayId::tryCast(displayId)) {
627 if (auto& generator = mVirtualDisplayIdGenerators.hal) {
628 generator->releaseId(*id);
629 }
630 return;
631 }
632
633 const auto id = GpuVirtualDisplayId::tryCast(displayId);
634 LOG_ALWAYS_FATAL_IF(!id);
635 mVirtualDisplayIdGenerators.gpu.releaseId(*id);
636}
637
Ady Abraham7825c682021-05-17 15:12:14 -0700638std::vector<PhysicalDisplayId> SurfaceFlinger::getPhysicalDisplayIdsLocked() const {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800639 const auto internalDisplayId = getInternalDisplayIdLocked();
640 if (!internalDisplayId) {
641 return {};
Dominik Laskowski075d3172018-05-24 15:50:06 -0700642 }
643
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800644 std::vector<PhysicalDisplayId> displayIds;
645 displayIds.reserve(mPhysicalDisplayTokens.size());
Marin Shalamanova524a092020-07-27 21:39:55 +0200646 displayIds.push_back(*internalDisplayId);
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800647
648 for (const auto& [id, token] : mPhysicalDisplayTokens) {
649 if (id != *internalDisplayId) {
Marin Shalamanova524a092020-07-27 21:39:55 +0200650 displayIds.push_back(id);
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800651 }
Mathias Agopiane57f2922012-08-09 16:29:12 -0700652 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700653
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800654 return displayIds;
655}
656
657sp<IBinder> SurfaceFlinger::getPhysicalDisplayToken(PhysicalDisplayId displayId) const {
658 Mutex::Autolock lock(mStateLock);
Marin Shalamanova524a092020-07-27 21:39:55 +0200659 return getPhysicalDisplayTokenLocked(displayId);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700660}
661
Ady Abraham37965d42018-11-01 13:43:32 -0700662status_t SurfaceFlinger::getColorManagement(bool* outGetColorManagement) const {
663 if (!outGetColorManagement) {
664 return BAD_VALUE;
665 }
666 *outGetColorManagement = useColorManagement;
667 return NO_ERROR;
Ady Abraham2a6ab2a2018-10-26 14:25:30 -0700668}
669
Lloyd Pique441d5042018-10-18 16:49:51 -0700670HWComposer& SurfaceFlinger::getHwComposer() const {
671 return mCompositionEngine->getHwComposer();
672}
673
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700674renderengine::RenderEngine& SurfaceFlinger::getRenderEngine() const {
675 return mCompositionEngine->getRenderEngine();
676}
677
Lloyd Pique70d91362018-10-18 16:02:55 -0700678compositionengine::CompositionEngine& SurfaceFlinger::getCompositionEngine() const {
679 return *mCompositionEngine.get();
680}
681
Marin Shalamanov53fc11d2020-11-20 14:00:13 +0100682void SurfaceFlinger::bootFinished() {
Rob Carr2aa78cb2020-03-10 14:27:49 -0700683 if (mBootFinished == true) {
684 ALOGE("Extra call to bootFinished");
685 return;
686 }
687 mBootFinished = true;
Wei Wangf9b05ee2017-07-19 20:59:39 -0700688 if (mStartPropertySetThread->join() != NO_ERROR) {
689 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800690 }
Ady Abrahamfe2a6db2021-06-09 15:41:37 -0700691
692 if (mRenderEnginePrimeCacheFuture.valid()) {
693 mRenderEnginePrimeCacheFuture.get();
694 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800695 const nsecs_t now = systemTime();
696 const nsecs_t duration = now - mBootTime;
Steve Blocka19954a2012-01-04 20:05:49 +0000697 ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700698
Mikael Pessa90092f42019-08-26 17:22:04 -0700699 mFrameTracer->initialize();
Adithya Srinivasan01189672020-10-20 14:23:05 -0700700 mFrameTimeline->onBootFinished();
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700701
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700702 // wait patiently for the window manager death
703 const String16 name("window");
Steven Morelanda904bb92019-07-02 17:37:23 -0700704 mWindowManager = defaultServiceManager()->getService(name);
705 if (mWindowManager != 0) {
706 mWindowManager->linkToDeath(static_cast<IBinder::DeathRecipient*>(this));
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700707 }
708
709 // stop boot animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700710 // formerly we would just kill the process, but we now ask it to exit so it
711 // can choose where to stop the animation.
712 property_set("service.bootanim.exit", "1");
Yusuke Sato0a688f52015-07-30 23:05:39 -0700713
714 const int LOGTAG_SF_STOP_BOOTANIM = 60110;
715 LOG_EVENT_LONG(LOGTAG_SF_STOP_BOOTANIM,
716 ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
Romain Guy11d63f42017-07-20 12:47:14 -0700717
Denis Hsue70cc6c2020-06-17 10:17:30 +0800718 sp<IBinder> input(defaultServiceManager()->getService(String16("inputflinger")));
719
720 static_cast<void>(schedule([=] {
721 if (input == nullptr) {
722 ALOGE("Failed to link to input service");
723 } else {
Chris Ye0783e992020-06-02 21:34:49 -0700724 mInputFlinger = interface_cast<os::IInputFlinger>(input);
Denis Hsue70cc6c2020-06-17 10:17:30 +0800725 }
726
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800727 readPersistentProperties();
Dan Stoza29e7bdf2020-03-23 14:43:09 -0700728 mPowerAdvisor.onBootFinished();
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800729 mBootStage = BootStage::FINISHED;
Ana Krulecbd6654b2019-02-15 15:18:15 -0800730
Ady Abraham8a82ba62020-01-17 12:43:17 -0800731 if (property_get_bool("sf.debug.show_refresh_rate_overlay", false)) {
Ady Abraham1b11bc62021-06-03 19:51:19 -0700732 ON_MAIN_THREAD(enableRefreshRateOverlay(true));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800733 }
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800734 }));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800735}
736
Dan Stoza436ccf32018-06-21 12:10:12 -0700737uint32_t SurfaceFlinger::getNewTexture() {
738 {
739 std::lock_guard lock(mTexturePoolMutex);
740 if (!mTexturePool.empty()) {
741 uint32_t name = mTexturePool.back();
742 mTexturePool.pop_back();
743 ATRACE_INT("TexturePoolSize", mTexturePool.size());
744 return name;
745 }
746
747 // The pool was too small, so increase it for the future
748 ++mTexturePoolSize;
749 }
750
751 // The pool was empty, so we need to get a new texture name directly using a
752 // blocking call to the main thread
Robert Carrcdd7df92021-04-12 15:32:09 -0700753 auto genTextures = [this] {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700754 uint32_t name = 0;
755 getRenderEngine().genTextures(1, &name);
756 return name;
Robert Carrcdd7df92021-04-12 15:32:09 -0700757 };
758 if (std::this_thread::get_id() == mMainThreadId) {
759 return genTextures();
760 } else {
761 return schedule(genTextures).get();
762 }
Dan Stoza436ccf32018-06-21 12:10:12 -0700763}
764
Mathias Agopian3f844832013-08-07 21:24:32 -0700765void SurfaceFlinger::deleteTextureAsync(uint32_t texture) {
Dan Stoza67765d82019-05-07 14:58:27 -0700766 std::lock_guard lock(mTexturePoolMutex);
767 // We don't change the pool size, so the fix-up logic in postComposition will decide whether
768 // to actually delete this or not based on mTexturePoolSize
769 mTexturePool.push_back(texture);
770 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700771}
772
Wei Wangf9b05ee2017-07-19 20:59:39 -0700773// Do not call property_set on main thread which will be blocked by init
774// Use StartPropertySetThread instead.
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700775void SurfaceFlinger::init() {
Mathias Agopiana4912602012-07-12 14:25:33 -0700776 ALOGI( "SurfaceFlinger's main thread ready to run. "
777 "Initializing graphics H/W...");
Steven Thomasb02664d2017-07-26 18:48:28 -0700778 Mutex::Autolock _l(mStateLock);
Kevin DuBois413287f2019-02-25 08:46:47 -0800779
Steven Thomasb02664d2017-07-26 18:48:28 -0700780 // Get a RenderEngine for the given display / config (can't fail)
Peiyong Lin0256f722018-08-31 15:45:10 -0700781 // TODO(b/77156734): We need to stop casting and use HAL types when possible.
Alec Mourida4cf3b2019-02-12 15:33:01 -0800782 // Sending maxFrameBufferAcquiredBuffers as the cache size is tightly tuned to single-display.
Peiyong Lin4137a1d2019-10-09 10:39:09 -0700783 mCompositionEngine->setRenderEngine(renderengine::RenderEngine::create(
784 renderengine::RenderEngineCreationArgs::Builder()
Alec Mourid6f09462020-12-07 11:18:17 -0800785 .setPixelFormat(static_cast<int32_t>(defaultCompositionPixelFormat))
786 .setImageCacheSize(maxFrameBufferAcquiredBuffers)
787 .setUseColorManagerment(useColorManagement)
788 .setEnableProtectedContext(enable_protected_contents(false))
789 .setPrecacheToneMapperShaderOnly(false)
790 .setSupportsBackgroundBlur(mSupportsBlur)
791 .setContextPriority(
792 useContextPriority
793 ? renderengine::RenderEngine::ContextPriority::REALTIME
794 : renderengine::RenderEngine::ContextPriority::MEDIUM)
795 .build()));
Garfield Tan9c9c1912021-07-19 12:02:16 -0700796 mMaxRenderTargetSize =
797 std::min(getRenderEngine().getMaxTextureSize(), getRenderEngine().getMaxViewportDims());
Wei Wang976a6452021-06-11 15:26:00 -0700798
799 // Set SF main policy after initializing RenderEngine which has its own policy.
800 if (!SetTaskProfiles(0, {"SFMainPolicy"})) {
801 ALOGW("Failed to set main task profile");
802 }
803
Alec Mourie4034bb2019-11-19 12:45:54 -0800804 mCompositionEngine->setTimeStats(mTimeStats);
Dominik Laskowskif06d68e2021-03-24 19:40:03 -0700805 mCompositionEngine->setHwComposer(getFactory().createHWComposer(mHwcServiceName));
Dominik Laskowskiebc8d3a2021-04-16 23:18:31 -0700806 mCompositionEngine->getHwComposer().setCallback(this);
Alec Mouria90a5702021-04-16 16:36:21 +0000807 ClientCache::getInstance().setRenderEngine(&getRenderEngine());
Dominik Laskowski13948602021-03-08 20:48:28 -0800808
809 if (base::GetBoolProperty("debug.sf.enable_hwc_vds"s, false)) {
810 enableHalVirtualDisplays(true);
811 }
812
Lloyd Piqueba04e622017-12-14 17:11:26 -0800813 // Process any initial hotplug and resulting display changes.
814 processDisplayHotplugEventsLocked();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700815 const auto display = getDefaultDisplayDeviceLocked();
816 LOG_ALWAYS_FATAL_IF(!display, "Missing internal display after registering composer callback.");
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200817 const auto displayId = display->getPhysicalId();
818 LOG_ALWAYS_FATAL_IF(!getHwComposer().isConnected(displayId),
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700819 "Internal display is disconnected.");
Jesse Hall692c7232012-11-08 15:41:56 -0800820
Mathias Agopian92a979a2012-08-02 18:32:23 -0700821 // initialize our drawing state
822 mDrawingState = mCurrentState;
Mathias Agopian86303202012-07-24 22:46:10 -0700823
Andy McFadden13a082e2012-08-24 10:16:42 -0700824 // set initial conditions (e.g. unblank default device)
825 initializeDisplays();
826
Alec Mouridea1ac52021-06-23 18:12:18 -0700827 mPowerAdvisor.init();
828
Steven Thomas137d4bc2019-07-25 16:55:14 -0700829 char primeShaderCache[PROPERTY_VALUE_MAX];
830 property_get("service.sf.prime_shader_cache", primeShaderCache, "1");
831 if (atoi(primeShaderCache)) {
Ady Abrahamfe2a6db2021-06-09 15:41:37 -0700832 if (setSchedFifo(false) != NO_ERROR) {
833 ALOGW("Can't set SCHED_OTHER for primeCache");
834 }
835
836 mRenderEnginePrimeCacheFuture = getRenderEngine().primeCache();
837
838 if (setSchedFifo(true) != NO_ERROR) {
839 ALOGW("Can't set SCHED_OTHER for primeCache");
840 }
Steven Thomas137d4bc2019-07-25 16:55:14 -0700841 }
Dan Stoza4e637772016-07-28 13:31:51 -0700842
Ady Abraham7825c682021-05-17 15:12:14 -0700843 onActiveDisplaySizeChanged(display);
Derek Sollenbergerc4a05e12021-03-24 16:45:20 -0400844
Wei Wangf9b05ee2017-07-19 20:59:39 -0700845 // Inform native graphics APIs whether the present timestamp is supported:
Lloyd Pique90c115d2018-09-18 21:39:42 -0700846
847 const bool presentFenceReliable =
Peiyong Line9d809e2020-04-14 13:10:48 -0700848 !getHwComposer().hasCapability(hal::Capability::PRESENT_FENCE_IS_NOT_RELIABLE);
Lloyd Pique90c115d2018-09-18 21:39:42 -0700849 mStartPropertySetThread = getFactory().createStartPropertySetThread(presentFenceReliable);
Wei Wangf9b05ee2017-07-19 20:59:39 -0700850
851 if (mStartPropertySetThread->Start() != NO_ERROR) {
852 ALOGE("Run StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800853 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800854
Dan Stoza9e56aa02015-11-02 13:00:03 -0800855 ALOGV("Done initializing");
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700856}
857
Romain Guy11d63f42017-07-20 12:47:14 -0700858void SurfaceFlinger::readPersistentProperties() {
Chia-I Wu28f320b2018-05-03 11:02:56 -0700859 Mutex::Autolock _l(mStateLock);
860
Romain Guy11d63f42017-07-20 12:47:14 -0700861 char value[PROPERTY_VALUE_MAX];
862
863 property_get("persist.sys.sf.color_saturation", value, "1.0");
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800864 mGlobalSaturationFactor = atof(value);
Chia-I Wu28f320b2018-05-03 11:02:56 -0700865 updateColorMatrixLocked();
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800866 ALOGV("Saturation is set to %.2f", mGlobalSaturationFactor);
Romain Guy54f154a2017-10-24 21:40:32 +0100867
868 property_get("persist.sys.sf.native_mode", value, "0");
Chia-I Wu0d711262018-05-21 15:19:35 -0700869 mDisplayColorSetting = static_cast<DisplayColorSetting>(atoi(value));
Peiyong Lina3ea5592019-02-10 14:45:00 -0800870
871 property_get("persist.sys.sf.color_mode", value, "0");
872 mForceColorMode = static_cast<ColorMode>(atoi(value));
Romain Guy11d63f42017-07-20 12:47:14 -0700873}
874
Mathias Agopiana67e4182012-06-19 17:26:12 -0700875void SurfaceFlinger::startBootAnim() {
Wei Wangb254fa32017-01-31 17:43:23 -0800876 // Start boot animation service by setting a property mailbox
877 // if property setting thread is already running, Start() will be just a NOP
Wei Wangf9b05ee2017-07-19 20:59:39 -0700878 mStartPropertySetThread->Start();
Wei Wangb254fa32017-01-31 17:43:23 -0800879 // Wait until property was set
Wei Wangf9b05ee2017-07-19 20:59:39 -0700880 if (mStartPropertySetThread->join() != NO_ERROR) {
881 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800882 }
Mathias Agopiana67e4182012-06-19 17:26:12 -0700883}
884
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800885// ----------------------------------------------------------------------------
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800886
Jamie Gennis582270d2011-08-17 18:19:00 -0700887bool SurfaceFlinger::authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800888 const sp<IGraphicBufferProducer>& bufferProducer) const {
Jamie Gennis134f0422011-03-08 12:18:54 -0800889 Mutex::Autolock _l(mStateLock);
Robert Carr0d480722017-01-10 16:42:54 -0800890 return authenticateSurfaceTextureLocked(bufferProducer);
891}
892
893bool SurfaceFlinger::authenticateSurfaceTextureLocked(
894 const sp<IGraphicBufferProducer>& bufferProducer) const {
Marco Nelissen097ca272014-11-14 08:01:01 -0800895 sp<IBinder> surfaceTextureBinder(IInterface::asBinder(bufferProducer));
Dan Stoza101d8dc2018-02-27 15:42:25 -0800896 return mGraphicBufferProducerList.count(surfaceTextureBinder.get()) > 0;
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 };
Steven Thomas6d8110b2017-08-31 18:24:21 -0700911 ConditionalLock _l(mStateLock,
912 std::this_thread::get_id() != mMainThreadId);
Peiyong Line9d809e2020-04-14 13:10:48 -0700913 if (!getHwComposer().hasCapability(hal::Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
Brian Anderson6b376712017-04-04 10:51:39 -0700914 outSupported->push_back(FrameEvent::DISPLAY_PRESENT);
915 }
916 return NO_ERROR;
917}
918
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800919status_t SurfaceFlinger::getDisplayState(const sp<IBinder>& displayToken, ui::DisplayState* state) {
920 if (!displayToken || !state) {
921 return BAD_VALUE;
922 }
923
924 Mutex::Autolock lock(mStateLock);
925
926 const auto display = getDisplayDeviceLocked(displayToken);
927 if (!display) {
928 return NAME_NOT_FOUND;
929 }
930
931 state->layerStack = display->getLayerStack();
932 state->orientation = display->getOrientation();
933
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200934 const Rect layerStackRect = display->getLayerStackSpaceRect();
935 state->layerStackSpaceRect =
936 layerStackRect.isValid() ? layerStackRect.getSize() : display->getSize();
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800937
938 return NO_ERROR;
939}
940
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100941status_t SurfaceFlinger::getStaticDisplayInfo(const sp<IBinder>& displayToken,
942 ui::StaticDisplayInfo* info) {
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800943 if (!displayToken || !info) {
944 return BAD_VALUE;
945 }
946
947 Mutex::Autolock lock(mStateLock);
948
949 const auto display = getDisplayDeviceLocked(displayToken);
950 if (!display) {
951 return NAME_NOT_FOUND;
952 }
953
Dominik Laskowski55c85402020-01-21 16:25:47 -0800954 if (const auto connectionType = display->getConnectionType())
955 info->connectionType = *connectionType;
956 else {
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800957 return INVALID_OPERATION;
958 }
959
960 if (mEmulatedDisplayDensity) {
961 info->density = mEmulatedDisplayDensity;
962 } else {
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100963 info->density = info->connectionType == ui::DisplayConnectionType::Internal
Dominik Laskowski55c85402020-01-21 16:25:47 -0800964 ? mInternalDisplayDensity
965 : FALLBACK_DENSITY;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800966 }
Dominik Laskowskid125d0e2020-05-08 12:36:39 -0700967 info->density /= ACONFIGURATION_DENSITY_MEDIUM;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800968
969 info->secure = display->isSecure();
Marin Shalamanove5cceea2020-04-30 18:13:10 +0200970 info->deviceProductInfo = display->getDeviceProductInfo();
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800971
972 return NO_ERROR;
973}
974
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100975status_t SurfaceFlinger::getDynamicDisplayInfo(const sp<IBinder>& displayToken,
976 ui::DynamicDisplayInfo* info) {
977 if (!displayToken || !info) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700978 return BAD_VALUE;
979 }
980
Dominik Laskowski22488f62019-03-28 09:53:04 -0700981 Mutex::Autolock lock(mStateLock);
982
Marin Shalamanov5801c942020-12-17 17:00:13 +0100983 const auto display = getDisplayDeviceLocked(displayToken);
984 if (!display) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700985 return NAME_NOT_FOUND;
Mathias Agopianc666cae2012-07-25 18:56:13 -0700986 }
Mathias Agopian8b736f12012-08-13 17:54:26 -0700987
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100988 info->activeDisplayModeId = static_cast<int32_t>(display->getActiveMode()->getId().value());
Mathias Agopian1604f772012-09-18 21:54:42 -0700989
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100990 const auto& supportedModes = display->getSupportedModes();
991 info->supportedDisplayModes.clear();
992 info->supportedDisplayModes.reserve(supportedModes.size());
993 for (const auto& mode : supportedModes) {
994 ui::DisplayMode outMode;
995 outMode.id = static_cast<int32_t>(mode->getId().value());
Dan Stoza7f7da322014-05-02 15:26:25 -0700996
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100997 auto width = mode->getWidth();
998 auto height = mode->getHeight();
Dan Stoza7f7da322014-05-02 15:26:25 -0700999
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001000 auto xDpi = mode->getDpiX();
1001 auto yDpi = mode->getDpiY();
Yiwei Zhang27de5df2018-08-23 17:04:51 -07001002
Marin Shalamanov5801c942020-12-17 17:00:13 +01001003 if (display->isPrimary() &&
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001004 (internalDisplayOrientation == ui::ROTATION_90 ||
1005 internalDisplayOrientation == ui::ROTATION_270)) {
1006 std::swap(width, height);
1007 std::swap(xDpi, yDpi);
Dan Stoza7f7da322014-05-02 15:26:25 -07001008 }
1009
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001010 outMode.resolution = ui::Size(width, height);
Ady Abraham2139f732019-11-13 18:56:40 -08001011
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001012 if (mEmulatedDisplayDensity) {
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001013 outMode.xDpi = mEmulatedDisplayDensity;
1014 outMode.yDpi = mEmulatedDisplayDensity;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001015 } else {
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001016 outMode.xDpi = xDpi;
1017 outMode.yDpi = yDpi;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001018 }
1019
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001020 const nsecs_t period = mode->getVsyncPeriod();
1021 outMode.refreshRate = Fps::fromPeriodNsecs(period).getValue();
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001022
Ady Abraham8287e852020-08-12 14:44:58 -07001023 const auto vsyncConfigSet =
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001024 mVsyncConfiguration->getConfigsForRefreshRate(Fps(outMode.refreshRate));
1025 outMode.appVsyncOffset = vsyncConfigSet.late.appOffset;
1026 outMode.sfVsyncOffset = vsyncConfigSet.late.sfOffset;
1027 outMode.group = mode->getGroup();
Dan Stoza9e56aa02015-11-02 13:00:03 -08001028
Andy McFadden91b2ca82014-06-13 14:04:23 -07001029 // This is how far in advance a buffer must be queued for
1030 // presentation at a given time. If you want a buffer to appear
1031 // on the screen at time N, you must submit the buffer before
1032 // (N - presentationDeadline).
1033 //
1034 // Normally it's one full refresh period (to give SF a chance to
1035 // latch the buffer), but this can be reduced by configuring a
Ady Abraham8cb21882020-08-26 18:22:05 -07001036 // VsyncController offset. Any additional delays introduced by the hardware
Andy McFadden91b2ca82014-06-13 14:04:23 -07001037 // composer or panel must be accounted for here.
1038 //
1039 // We add an additional 1ms to allow for processing time and
1040 // differences between the ideal and actual refresh rate.
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001041 outMode.presentationDeadline = period - outMode.sfVsyncOffset + 1000000;
Dan Stoza7f7da322014-05-02 15:26:25 -07001042
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001043 info->supportedDisplayModes.push_back(outMode);
Mathias Agopian8b736f12012-08-13 17:54:26 -07001044 }
1045
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001046 info->activeColorMode = display->getCompositionDisplay()->getState().colorMode;
Marin Shalamanovb173f752021-02-16 19:38:36 +01001047 const auto displayId = display->getPhysicalId();
1048 info->supportedColorModes = getDisplayColorModes(displayId);
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001049
1050 info->hdrCapabilities = display->getHdrCapabilities();
Marin Shalamanovb173f752021-02-16 19:38:36 +01001051 info->autoLowLatencyModeSupported =
1052 getHwComposer().hasDisplayCapability(displayId,
1053 hal::DisplayCapability::AUTO_LOW_LATENCY_MODE);
1054 std::vector<hal::ContentType> types;
1055 getHwComposer().getSupportedContentTypes(displayId, &types);
1056 info->gameContentTypeSupported = std::any_of(types.begin(), types.end(), [](auto type) {
1057 return type == hal::ContentType::GAME;
1058 });
Dan Stoza7f7da322014-05-02 15:26:25 -07001059 return NO_ERROR;
1060}
Jamie Gennisdd3cb842012-10-19 18:19:11 -07001061
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001062status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>&, DisplayStatInfo* stats) {
1063 if (!stats) {
Lajos Molnar67d8bd62014-09-11 14:58:45 -07001064 return BAD_VALUE;
1065 }
1066
Ady Abrahame90dd522020-12-29 12:08:45 -08001067 *stats = mScheduler->getDisplayStatInfo(systemTime());
Lajos Molnar67d8bd62014-09-11 14:58:45 -07001068 return NO_ERROR;
1069}
1070
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001071void SurfaceFlinger::setDesiredActiveMode(const ActiveModeInfo& info) {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001072 ATRACE_CALL();
Ady Abrahamb4937392021-06-23 18:05:03 -07001073
1074 if (!info.mode) {
1075 ALOGW("requested display mode is null");
1076 return;
1077 }
1078 auto display = getDisplayDeviceLocked(info.mode->getPhysicalDisplayId());
Ady Abraham3efa3942021-06-24 19:01:25 -07001079 if (!display) {
Ady Abrahamb4937392021-06-23 18:05:03 -07001080 ALOGW("%s: display is no longer valid", __func__);
Ady Abraham3efa3942021-06-24 19:01:25 -07001081 return;
1082 }
1083
Ady Abrahamb4937392021-06-23 18:05:03 -07001084 if (display->setDesiredActiveMode(info)) {
Ady Abrahamb838aed2019-02-12 15:30:16 -08001085 // This will trigger HWC refresh without resetting the idle timer.
1086 repaintEverythingForHWC();
Alec Mouri754c98a2019-03-18 18:53:42 -07001087 // Start receiving vsync samples now, so that we can detect a period
1088 // switch.
Ady Abrahamb4937392021-06-23 18:05:03 -07001089 mScheduler->resyncToHardwareVsync(true, info.mode->getVsyncPeriod());
Ady Abraham53852a52019-05-28 18:07:44 -07001090 // As we called to set period, we will call to onRefreshRateChangeCompleted once
Ady Abraham8cb21882020-08-26 18:22:05 -07001091 // VsyncController model is locked.
Dominik Laskowski08d05c22020-07-22 00:05:08 -07001092 modulateVsync(&VsyncModulator::onRefreshRateChangeInitiated);
Ady Abraham2139f732019-11-13 18:56:40 -08001093
Ady Abrahamb4937392021-06-23 18:05:03 -07001094 updatePhaseConfiguration(info.mode->getFps());
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001095 mScheduler->setModeChangePending(true);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001096 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001097}
1098
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001099status_t SurfaceFlinger::setActiveMode(const sp<IBinder>& displayToken, int modeId) {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001100 ATRACE_CALL();
Ady Abraham838de062019-02-04 10:24:03 -08001101
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001102 if (!displayToken) {
1103 return BAD_VALUE;
1104 }
Ady Abraham838de062019-02-04 10:24:03 -08001105
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001106 auto future = schedule([=]() -> status_t {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001107 const auto display = ON_MAIN_THREAD(getDisplayDeviceLocked(displayToken));
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001108 if (!display) {
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001109 ALOGE("Attempt to set allowed display modes for invalid display token %p",
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001110 displayToken.get());
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001111 return NAME_NOT_FOUND;
Marin Shalamanov5801c942020-12-17 17:00:13 +01001112 }
1113
1114 if (display->isVirtual()) {
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001115 ALOGW("Attempt to set allowed display modes for virtual display");
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001116 return INVALID_OPERATION;
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001117 }
Marin Shalamanov5801c942020-12-17 17:00:13 +01001118
1119 const auto mode = display->getMode(DisplayModeId{modeId});
1120 if (!mode) {
1121 ALOGW("Attempt to switch to an unsupported mode %d.", modeId);
1122 return BAD_VALUE;
1123 }
1124
1125 const auto fps = mode->getFps();
1126 // Keep the old switching type.
1127 const auto allowGroupSwitching =
Ady Abraham3efa3942021-06-24 19:01:25 -07001128 display->refreshRateConfigs().getCurrentPolicy().allowGroupSwitching;
Marin Shalamanov5801c942020-12-17 17:00:13 +01001129 const scheduler::RefreshRateConfigs::Policy policy{mode->getId(),
1130 allowGroupSwitching,
1131 {fps, fps}};
1132 constexpr bool kOverridePolicy = false;
1133
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001134 return setDesiredDisplayModeSpecsInternal(display, policy, kOverridePolicy);
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001135 });
1136
1137 return future.get();
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001138}
1139
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001140void SurfaceFlinger::setActiveModeInternal() {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001141 ATRACE_CALL();
1142
Dominik Laskowski22488f62019-03-28 09:53:04 -07001143 const auto display = getDefaultDisplayDeviceLocked();
1144 if (!display) {
1145 return;
1146 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001147
Ady Abrahamb4937392021-06-23 18:05:03 -07001148 const auto upcomingModeInfo = MAIN_THREAD_GUARD(display->getUpcomingActiveMode());
Ady Abrahamfaac6da2021-07-15 10:04:40 -07001149 if (!upcomingModeInfo.mode) {
1150 // There is no pending mode change. This can happen if the active
1151 // display changed and the mode change happened on a different display.
1152 return;
1153 }
1154
Ady Abrahamb4937392021-06-23 18:05:03 -07001155 if (display->getActiveMode()->getSize() != upcomingModeInfo.mode->getSize()) {
Marin Shalamanov993ddf42021-05-26 16:54:40 +02001156 auto& state = mCurrentState.displays.editValueFor(display->getDisplayToken());
1157 // We need to generate new sequenceId in order to recreate the display (and this
1158 // way the framebuffer).
1159 state.sequenceId = DisplayDeviceState{}.sequenceId;
Ady Abrahamb4937392021-06-23 18:05:03 -07001160 state.physical->activeMode = upcomingModeInfo.mode;
Marin Shalamanov993ddf42021-05-26 16:54:40 +02001161 processDisplayChangesLocked();
1162
1163 // processDisplayChangesLocked will update all necessary components so we're done here.
1164 return;
1165 }
Alec Mouri8de697e2020-03-19 10:52:01 -07001166
Ady Abrahamb4937392021-06-23 18:05:03 -07001167 // We just created this display so we can call even if we are not on
1168 // the main thread
1169 MainThreadScopedGuard fakeMainThreadGuard(SF_MAIN_THREAD);
1170 display->setActiveMode(upcomingModeInfo.mode->getId());
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001171
Ady Abrahamb4937392021-06-23 18:05:03 -07001172 const Fps refreshRate = upcomingModeInfo.mode->getFps();
Marin Shalamanov5801c942020-12-17 17:00:13 +01001173 mRefreshRateStats->setRefreshRate(refreshRate);
Dominik Laskowski08d05c22020-07-22 00:05:08 -07001174 updatePhaseConfiguration(refreshRate);
Dominik Laskowski22488f62019-03-28 09:53:04 -07001175
Ady Abrahamb4937392021-06-23 18:05:03 -07001176 if (upcomingModeInfo.event != Scheduler::ModeEvent::None) {
1177 mScheduler->onPrimaryDisplayModeChanged(mAppConnectionHandle, upcomingModeInfo.mode);
Ady Abraham447052e2019-02-13 16:07:27 -08001178 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001179}
1180
Ady Abrahamb4937392021-06-23 18:05:03 -07001181void SurfaceFlinger::clearDesiredActiveModeState(const sp<DisplayDevice>& display) {
1182 display->clearDesiredActiveModeState();
1183 if (isDisplayActiveLocked(display)) {
1184 mScheduler->setModeChangePending(false);
1185 }
Ady Abraham53852a52019-05-28 18:07:44 -07001186}
1187
Ady Abrahamb4937392021-06-23 18:05:03 -07001188void SurfaceFlinger::desiredActiveModeChangeDone(const sp<DisplayDevice>& display) {
1189 const auto refreshRate = display->getDesiredActiveMode()->mode->getFps();
1190 clearDesiredActiveModeState(display);
Marin Shalamanov5801c942020-12-17 17:00:13 +01001191 mScheduler->resyncToHardwareVsync(true, refreshRate.getPeriodNsecs());
1192 updatePhaseConfiguration(refreshRate);
1193}
1194
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001195void SurfaceFlinger::performSetActiveMode() {
Alec Mourife3dc942019-02-12 14:19:18 -08001196 ATRACE_CALL();
Marin Shalamanov5801c942020-12-17 17:00:13 +01001197 ALOGV("%s", __FUNCTION__);
Ady Abrahamb4937392021-06-23 18:05:03 -07001198
1199 for (const auto& iter : mDisplays) {
1200 const auto& display = iter.second;
1201 if (!display || !display->isInternal()) {
1202 continue;
1203 }
1204
1205 // Store the local variable to release the lock.
1206 const auto desiredActiveMode = display->getDesiredActiveMode();
1207 if (!desiredActiveMode) {
1208 // No desired active mode pending to be applied
1209 continue;
1210 }
1211
1212 if (!isDisplayActiveLocked(display)) {
1213 // display is no longer the active display, so abort the mode change
1214 clearDesiredActiveModeState(display);
1215 continue;
1216 }
1217
1218 const auto desiredMode = display->getMode(desiredActiveMode->mode->getId());
1219 if (!desiredMode) {
1220 ALOGW("Desired display mode is no longer supported. Mode ID = %d",
1221 desiredActiveMode->mode->getId().value());
1222 clearDesiredActiveModeState(display);
1223 continue;
1224 }
1225
1226 const auto refreshRate = desiredMode->getFps();
1227 ALOGV("%s changing active mode to %d(%s) for display %s", __func__,
1228 desiredMode->getId().value(), to_string(refreshRate).c_str(),
1229 to_string(display->getId()).c_str());
1230
1231 if (display->getActiveMode()->getId() == desiredActiveMode->mode->getId()) {
1232 // display is not valid or we are already in the requested mode
1233 // on both cases there is nothing left to do
1234 desiredActiveModeChangeDone(display);
1235 continue;
1236 }
1237
1238 // Desired active mode was set, it is different than the mode currently in use, however
1239 // allowed modes might have changed by the time we process the refresh.
1240 // Make sure the desired mode is still allowed
1241 const auto displayModeAllowed =
1242 display->refreshRateConfigs().isModeAllowed(desiredActiveMode->mode->getId());
1243 if (!displayModeAllowed) {
1244 desiredActiveModeChangeDone(display);
1245 continue;
1246 }
1247
1248 // TODO(b/142753666) use constrains
1249 hal::VsyncPeriodChangeConstraints constraints;
1250 constraints.desiredTimeNanos = systemTime();
1251 constraints.seamlessRequired = false;
1252 hal::VsyncPeriodChangeTimeline outTimeline;
1253
1254 const auto status = MAIN_THREAD_GUARD(
1255 display->initiateModeChange(*desiredActiveMode, constraints, &outTimeline));
1256 if (status != NO_ERROR) {
1257 // initiateModeChange may fail if a hotplug event is just about
1258 // to be sent. We just log the error in this case.
1259 ALOGW("initiateModeChange failed: %d", status);
1260 continue;
1261 }
1262 mScheduler->onNewVsyncPeriodChangeTimeline(outTimeline);
1263
1264 // Scheduler will submit an empty frame to HWC if needed.
1265 mSetActiveModePending = true;
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001266 }
Mathias Agopianc666cae2012-07-25 18:56:13 -07001267}
Dominik Laskowski075d3172018-05-24 15:50:06 -07001268
Alec Mouridea1ac52021-06-23 18:12:18 -07001269void SurfaceFlinger::disableExpensiveRendering() {
1270 schedule([=]() MAIN_THREAD {
1271 ATRACE_CALL();
1272 if (mPowerAdvisor.isUsingExpensiveRendering()) {
1273 const auto& displays = ON_MAIN_THREAD(mDisplays);
1274 for (const auto& [_, display] : displays) {
1275 const static constexpr auto kDisable = false;
1276 mPowerAdvisor.setExpensiveRenderingExpected(display->getId(), kDisable);
1277 }
1278 }
1279 }).wait();
1280}
1281
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001282std::vector<ColorMode> SurfaceFlinger::getDisplayColorModes(PhysicalDisplayId displayId) {
1283 auto modes = getHwComposer().getColorModes(displayId);
1284 bool isInternalDisplay = displayId == getInternalDisplayIdLocked();
Peiyong Linff84a152019-05-17 18:36:19 -07001285
1286 // If it's built-in display and the configuration claims it's not wide color capable,
1287 // filter out all wide color modes. The typical reason why this happens is that the
1288 // hardware is not good enough to support GPU composition of wide color, and thus the
1289 // OEMs choose to disable this capability.
1290 if (isInternalDisplay && !hasWideColorDisplay) {
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001291 const auto newEnd = std::remove_if(modes.begin(), modes.end(), isWideColorMode);
1292 modes.erase(newEnd, modes.end());
Peiyong Linff84a152019-05-17 18:36:19 -07001293 }
Michael Wright28f24d02016-07-12 13:30:53 -07001294
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001295 return modes;
Michael Wright28f24d02016-07-12 13:30:53 -07001296}
1297
Daniel Solomon42d04562019-01-20 21:03:19 -08001298status_t SurfaceFlinger::getDisplayNativePrimaries(const sp<IBinder>& displayToken,
1299 ui::DisplayPrimaries &primaries) {
1300 if (!displayToken) {
1301 return BAD_VALUE;
1302 }
1303
1304 // Currently we only support this API for a single internal display.
1305 if (getInternalDisplayToken() != displayToken) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001306 return NAME_NOT_FOUND;
Daniel Solomon42d04562019-01-20 21:03:19 -08001307 }
1308
1309 memcpy(&primaries, &mInternalDisplayPrimaries, sizeof(ui::DisplayPrimaries));
1310 return NO_ERROR;
1311}
1312
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001313status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& displayToken, ColorMode mode) {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001314 schedule([=]() MAIN_THREAD {
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001315 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1316 if (!displayId) {
1317 ALOGE("Invalid display token %p", displayToken.get());
1318 return;
1319 }
1320 const auto modes = getDisplayColorModes(*displayId);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001321 bool exists = std::find(std::begin(modes), std::end(modes), mode) != std::end(modes);
1322 if (mode < ColorMode::NATIVE || !exists) {
1323 ALOGE("Attempt to set invalid active color mode %s (%d) for display token %p",
1324 decodeColorMode(mode).c_str(), mode, displayToken.get());
1325 return;
Michael Wright28f24d02016-07-12 13:30:53 -07001326 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001327 const auto display = getDisplayDeviceLocked(displayToken);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001328 if (!display) {
1329 ALOGE("Attempt to set active color mode %s (%d) for invalid display token %p",
1330 decodeColorMode(mode).c_str(), mode, displayToken.get());
1331 } else if (display->isVirtual()) {
1332 ALOGW("Attempt to set active color mode %s (%d) for virtual display",
1333 decodeColorMode(mode).c_str(), mode);
1334 } else {
Lloyd Pique6a3b4462019-03-07 20:58:12 -08001335 display->getCompositionDisplay()->setColorProfile(
1336 compositionengine::Output::ColorProfile{mode, Dataspace::UNKNOWN,
1337 RenderIntent::COLORIMETRIC,
1338 Dataspace::UNKNOWN});
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001339 }
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001340 }).wait();
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001341
Michael Wright28f24d02016-07-12 13:30:53 -07001342 return NO_ERROR;
1343}
Mathias Agopianc666cae2012-07-25 18:56:13 -07001344
Galia Peycheva5492cb52019-10-30 14:13:16 +01001345void SurfaceFlinger::setAutoLowLatencyMode(const sp<IBinder>& displayToken, bool on) {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001346 static_cast<void>(schedule([=]() MAIN_THREAD {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001347 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
1348 getHwComposer().setAutoLowLatencyMode(*displayId, on);
1349 } else {
1350 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
1351 }
1352 }));
Galia Peycheva5492cb52019-10-30 14:13:16 +01001353}
1354
Galia Peycheva5492cb52019-10-30 14:13:16 +01001355void SurfaceFlinger::setGameContentType(const sp<IBinder>& displayToken, bool on) {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001356 static_cast<void>(schedule([=]() MAIN_THREAD {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001357 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
Peiyong Line9d809e2020-04-14 13:10:48 -07001358 const auto type = on ? hal::ContentType::GAME : hal::ContentType::NONE;
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001359 getHwComposer().setContentType(*displayId, type);
1360 } else {
1361 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
1362 }
1363 }));
Galia Peycheva5492cb52019-10-30 14:13:16 +01001364}
1365
Svetoslavd85084b2014-03-20 10:28:31 -07001366status_t SurfaceFlinger::clearAnimationFrameStats() {
1367 Mutex::Autolock _l(mStateLock);
1368 mAnimFrameTracker.clearStats();
1369 return NO_ERROR;
1370}
1371
1372status_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const {
1373 Mutex::Autolock _l(mStateLock);
1374 mAnimFrameTracker.getStats(outStats);
1375 return NO_ERROR;
1376}
1377
Kriti Dang49ad4132021-01-08 11:49:56 +01001378status_t SurfaceFlinger::overrideHdrTypes(const sp<IBinder>& displayToken,
1379 const std::vector<ui::Hdr>& hdrTypes) {
1380 Mutex::Autolock lock(mStateLock);
1381
1382 auto display = getDisplayDeviceLocked(displayToken);
1383 if (!display) {
1384 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
1385 return NAME_NOT_FOUND;
1386 }
1387
1388 display->overrideHdrTypes(hdrTypes);
1389 dispatchDisplayHotplugEvent(display->getPhysicalId(), true /* connected */);
1390 return NO_ERROR;
1391}
1392
Tej Singhe2751772021-04-06 22:05:29 -07001393status_t SurfaceFlinger::onPullAtom(const int32_t atomId, std::string* pulledData, bool* success) {
1394 *success = mTimeStats->onPullAtom(atomId, pulledData);
1395 return NO_ERROR;
1396}
1397
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001398status_t SurfaceFlinger::getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
1399 ui::PixelFormat* outFormat,
1400 ui::Dataspace* outDataspace,
1401 uint8_t* outComponentMask) const {
1402 if (!outFormat || !outDataspace || !outComponentMask) {
1403 return BAD_VALUE;
1404 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001405
1406 Mutex::Autolock lock(mStateLock);
1407
1408 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1409 if (!displayId) {
1410 return NAME_NOT_FOUND;
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001411 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001412
1413 return getHwComposer().getDisplayedContentSamplingAttributes(*displayId, outFormat,
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001414 outDataspace, outComponentMask);
1415}
1416
Kevin DuBois74e53772018-11-19 10:52:38 -08001417status_t SurfaceFlinger::setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken,
1418 bool enable, uint8_t componentMask,
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001419 uint64_t maxFrames) {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001420 return schedule([=]() MAIN_THREAD -> status_t {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001421 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
1422 return getHwComposer().setDisplayContentSamplingEnabled(*displayId, enable,
1423 componentMask,
1424 maxFrames);
1425 } else {
1426 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
1427 return NAME_NOT_FOUND;
1428 }
1429 })
1430 .get();
Kevin DuBois74e53772018-11-19 10:52:38 -08001431}
1432
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001433status_t SurfaceFlinger::getDisplayedContentSample(const sp<IBinder>& displayToken,
1434 uint64_t maxFrames, uint64_t timestamp,
1435 DisplayedFrameStats* outStats) const {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001436 Mutex::Autolock lock(mStateLock);
1437
1438 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1439 if (!displayId) {
1440 return NAME_NOT_FOUND;
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001441 }
1442
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001443 return getHwComposer().getDisplayedContentSample(*displayId, maxFrames, timestamp, outStats);
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001444}
1445
Peiyong Lin3c2791e2019-01-14 17:05:18 -08001446status_t SurfaceFlinger::getProtectedContentSupport(bool* outSupported) const {
1447 if (!outSupported) {
1448 return BAD_VALUE;
1449 }
1450 *outSupported = getRenderEngine().supportsProtectedContent();
1451 return NO_ERROR;
1452}
1453
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001454status_t SurfaceFlinger::isWideColorDisplay(const sp<IBinder>& displayToken,
1455 bool* outIsWideColorDisplay) const {
1456 if (!displayToken || !outIsWideColorDisplay) {
1457 return BAD_VALUE;
1458 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001459
1460 Mutex::Autolock lock(mStateLock);
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001461 const auto display = getDisplayDeviceLocked(displayToken);
1462 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001463 return NAME_NOT_FOUND;
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001464 }
Peiyong Linff84a152019-05-17 18:36:19 -07001465
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001466 *outIsWideColorDisplay =
1467 display->isPrimary() ? hasWideColorDisplay : display->hasWideColorGamut();
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001468 return NO_ERROR;
1469}
1470
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001471status_t SurfaceFlinger::enableVSyncInjections(bool enable) {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001472 schedule([=] {
Dominik Laskowski6505f792019-09-18 11:10:05 -07001473 Mutex::Autolock lock(mStateLock);
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001474
Dominik Laskowski6505f792019-09-18 11:10:05 -07001475 if (const auto handle = mScheduler->enableVSyncInjection(enable)) {
Dominik Laskowski208235c2020-12-03 15:38:51 -08001476 mEventQueue->setInjector(enable ? mScheduler->getEventConnection(handle) : nullptr);
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001477 }
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001478 }).wait();
Dominik Laskowski8c001672018-05-30 16:52:06 -07001479
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001480 return NO_ERROR;
1481}
1482
1483status_t SurfaceFlinger::injectVSync(nsecs_t when) {
Dominik Laskowski6505f792019-09-18 11:10:05 -07001484 Mutex::Autolock lock(mStateLock);
Ady Abrahame90dd522020-12-29 12:08:45 -08001485 const DisplayStatInfo stats = mScheduler->getDisplayStatInfo(when);
Ady Abraham56b42a42020-12-28 16:48:48 -08001486 const auto expectedPresent = calculateExpectedPresentTime(stats);
Ady Abraham9c53ee72020-07-22 21:16:18 -07001487 return mScheduler->injectVSync(when, /*expectedVSyncTime=*/expectedPresent,
1488 /*deadlineTimestamp=*/expectedPresent)
1489 ? NO_ERROR
1490 : BAD_VALUE;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001491}
1492
Vishnu Nair43bccf82020-06-05 10:53:37 -07001493status_t SurfaceFlinger::getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) {
Kalle Raitaa099a242017-01-11 11:17:29 -08001494 outLayers->clear();
Vishnu Nair43bccf82020-06-05 10:53:37 -07001495 schedule([=] {
1496 const auto display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked());
1497 mDrawingState.traverseInZOrder([&](Layer* layer) {
1498 outLayers->push_back(layer->getLayerDebugInfo(display.get()));
1499 });
1500 }).wait();
Kalle Raitaa099a242017-01-11 11:17:29 -08001501 return NO_ERROR;
1502}
1503
Peiyong Linc6780972018-10-28 15:24:08 -07001504status_t SurfaceFlinger::getCompositionPreference(
1505 Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
1506 Dataspace* outWideColorGamutDataspace,
1507 ui::PixelFormat* outWideColorGamutPixelFormat) const {
Peiyong Lin9d846a52018-11-05 13:18:20 -08001508 *outDataspace = mDefaultCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001509 *outPixelFormat = defaultCompositionPixelFormat;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001510 *outWideColorGamutDataspace = mWideColorGamutCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001511 *outWideColorGamutPixelFormat = wideColorGamutCompositionPixelFormat;
Peiyong Lin0256f722018-08-31 15:45:10 -07001512 return NO_ERROR;
1513}
1514
Dan Stozaec460082018-12-17 15:35:09 -08001515status_t SurfaceFlinger::addRegionSamplingListener(const Rect& samplingArea,
1516 const sp<IBinder>& stopLayerHandle,
1517 const sp<IRegionSamplingListener>& listener) {
tangrobinaf45f012019-02-26 18:10:10 +08001518 if (!listener || samplingArea == Rect::INVALID_RECT) {
Dan Stozaec460082018-12-17 15:35:09 -08001519 return BAD_VALUE;
1520 }
Alec Mouri9a02eda2020-04-21 17:39:34 -07001521
1522 const wp<Layer> stopLayer = fromHandle(stopLayerHandle);
1523 mRegionSamplingThread->addListener(samplingArea, stopLayer, listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001524 return NO_ERROR;
1525}
1526
Dan Stozaec460082018-12-17 15:35:09 -08001527status_t SurfaceFlinger::removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) {
tangrobinaf45f012019-02-26 18:10:10 +08001528 if (!listener) {
1529 return BAD_VALUE;
1530 }
Dan Stozaec460082018-12-17 15:35:09 -08001531 mRegionSamplingThread->removeListener(listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001532 return NO_ERROR;
1533}
Dan Gittik57e63c52019-01-18 16:37:54 +00001534
Alec Mouria9a68a62021-03-04 19:14:50 -08001535status_t SurfaceFlinger::addFpsListener(int32_t taskId, const sp<gui::IFpsListener>& listener) {
Alec Mouriadebf5c2021-01-05 12:57:36 -08001536 if (!listener) {
1537 return BAD_VALUE;
1538 }
1539
Alec Mouria9a68a62021-03-04 19:14:50 -08001540 mFpsReporter->addListener(listener, taskId);
Alec Mouriadebf5c2021-01-05 12:57:36 -08001541 return NO_ERROR;
1542}
1543
1544status_t SurfaceFlinger::removeFpsListener(const sp<gui::IFpsListener>& listener) {
1545 if (!listener) {
1546 return BAD_VALUE;
1547 }
1548 mFpsReporter->removeListener(listener);
1549 return NO_ERROR;
1550}
1551
Galia Peycheva8f04b302021-04-27 13:25:38 +02001552status_t SurfaceFlinger::addTunnelModeEnabledListener(
1553 const sp<gui::ITunnelModeEnabledListener>& listener) {
1554 if (!listener) {
1555 return BAD_VALUE;
1556 }
1557
1558 mTunnelModeEnabledReporter->addListener(listener);
1559 return NO_ERROR;
1560}
1561
1562status_t SurfaceFlinger::removeTunnelModeEnabledListener(
1563 const sp<gui::ITunnelModeEnabledListener>& listener) {
1564 if (!listener) {
1565 return BAD_VALUE;
1566 }
1567
1568 mTunnelModeEnabledReporter->removeListener(listener);
1569 return NO_ERROR;
1570}
1571
Dan Gittik57e63c52019-01-18 16:37:54 +00001572status_t SurfaceFlinger::getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
1573 bool* outSupport) const {
1574 if (!displayToken || !outSupport) {
1575 return BAD_VALUE;
1576 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001577
1578 Mutex::Autolock lock(mStateLock);
1579
Dan Gittik57e63c52019-01-18 16:37:54 +00001580 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1581 if (!displayId) {
1582 return NAME_NOT_FOUND;
1583 }
1584 *outSupport =
Peiyong Line9d809e2020-04-14 13:10:48 -07001585 getHwComposer().hasDisplayCapability(*displayId, hal::DisplayCapability::BRIGHTNESS);
Dan Gittik57e63c52019-01-18 16:37:54 +00001586 return NO_ERROR;
1587}
1588
John Reck22be6962021-03-10 12:59:54 -05001589status_t SurfaceFlinger::setDisplayBrightness(const sp<IBinder>& displayToken,
1590 const gui::DisplayBrightness& brightness) {
Dan Gittik57e63c52019-01-18 16:37:54 +00001591 if (!displayToken) {
1592 return BAD_VALUE;
1593 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001594
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -08001595 return ftl::chain(schedule([=]() MAIN_THREAD {
John Reckac09e452021-04-07 16:35:37 -04001596 if (const auto display = getDisplayDeviceLocked(displayToken)) {
1597 if (enableSdrDimming) {
1598 display->getCompositionDisplay()
1599 ->setDisplayBrightness(brightness.sdrWhitePointNits,
1600 brightness.displayBrightnessNits);
1601 }
1602 return getHwComposer().setDisplayBrightness(display->getPhysicalId(),
John Reck22be6962021-03-10 12:59:54 -05001603 brightness.displayBrightness);
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001604 } else {
1605 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -08001606 return ftl::yield<status_t>(NAME_NOT_FOUND);
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001607 }
Dominik Laskowski5690bde2020-04-23 19:04:22 -07001608 }))
1609 .then([](std::future<status_t> task) { return task; })
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001610 .get();
Dan Gittik57e63c52019-01-18 16:37:54 +00001611}
1612
John Reck88270902021-03-18 11:27:35 -04001613status_t SurfaceFlinger::addHdrLayerInfoListener(const sp<IBinder>& displayToken,
1614 const sp<gui::IHdrLayerInfoListener>& listener) {
1615 if (!displayToken) {
1616 return BAD_VALUE;
1617 }
1618
1619 Mutex::Autolock lock(mStateLock);
1620
1621 const auto display = getDisplayDeviceLocked(displayToken);
1622 if (!display) {
1623 return NAME_NOT_FOUND;
1624 }
1625 const auto displayId = display->getId();
1626 sp<HdrLayerInfoReporter>& hdrInfoReporter = mHdrLayerInfoListeners[displayId];
1627 if (!hdrInfoReporter) {
1628 hdrInfoReporter = sp<HdrLayerInfoReporter>::make();
1629 }
1630 hdrInfoReporter->addListener(listener);
Robert Carr167bdde2021-07-28 11:26:51 -07001631
1632
1633 mAddingHDRLayerInfoListener = true;
John Reck88270902021-03-18 11:27:35 -04001634 return OK;
1635}
1636
1637status_t SurfaceFlinger::removeHdrLayerInfoListener(
1638 const sp<IBinder>& displayToken, const sp<gui::IHdrLayerInfoListener>& listener) {
1639 if (!displayToken) {
1640 return BAD_VALUE;
1641 }
1642
1643 Mutex::Autolock lock(mStateLock);
1644
1645 const auto display = getDisplayDeviceLocked(displayToken);
1646 if (!display) {
1647 return NAME_NOT_FOUND;
1648 }
1649 const auto displayId = display->getId();
1650 sp<HdrLayerInfoReporter>& hdrInfoReporter = mHdrLayerInfoListeners[displayId];
1651 if (hdrInfoReporter) {
1652 hdrInfoReporter->removeListener(listener);
1653 }
1654 return OK;
1655}
1656
Lais Andrade3a6e47d2020-04-02 11:20:16 +01001657status_t SurfaceFlinger::notifyPowerBoost(int32_t boostId) {
1658 Boost powerBoost = static_cast<Boost>(boostId);
Ady Abraham8532d012019-05-08 14:50:56 -07001659
Lais Andrade3a6e47d2020-04-02 11:20:16 +01001660 if (powerBoost == Boost::INTERACTION) {
Ady Abraham8532d012019-05-08 14:50:56 -07001661 mScheduler->notifyTouchEvent();
1662 }
1663
1664 return NO_ERROR;
1665}
1666
Mathias Agopiand0566bc2011-11-17 17:49:17 -08001667// ----------------------------------------------------------------------------
1668
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -07001669sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection(
Ady Abraham62f216c2020-10-13 19:07:23 -07001670 ISurfaceComposer::VsyncSource vsyncSource,
1671 ISurfaceComposer::EventRegistrationFlags eventRegistration) {
Ana Krulecc2870422019-01-29 19:00:58 -08001672 const auto& handle =
1673 vsyncSource == eVsyncSourceSurfaceFlinger ? mSfConnectionHandle : mAppConnectionHandle;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001674
Ady Abraham62f216c2020-10-13 19:07:23 -07001675 return mScheduler->createDisplayEventConnection(handle, eventRegistration);
Mathias Agopianbb641242010-05-18 17:06:55 -07001676}
1677
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001678void SurfaceFlinger::signalTransaction() {
Ady Abraham8532d012019-05-08 14:50:56 -07001679 mScheduler->resetIdleTimer();
Dan Stoza030fbc12020-02-19 15:32:01 -08001680 mPowerAdvisor.notifyDisplayUpdateImminent();
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001681 mEventQueue->invalidate();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001682}
1683
1684void SurfaceFlinger::signalLayerUpdate() {
Ady Abraham8532d012019-05-08 14:50:56 -07001685 mScheduler->resetIdleTimer();
Dan Stoza030fbc12020-02-19 15:32:01 -08001686 mPowerAdvisor.notifyDisplayUpdateImminent();
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001687 mEventQueue->invalidate();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001688}
1689
1690void SurfaceFlinger::signalRefresh() {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07001691 mRefreshPending = true;
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001692 mEventQueue->refresh();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001693}
1694
Ady Abraham2492a022020-07-24 11:09:55 -07001695nsecs_t SurfaceFlinger::getVsyncPeriodFromHWC() const {
Marin Shalamanov045b7002021-01-07 16:56:24 +01001696 if (const auto display = getDefaultDisplayDeviceLocked()) {
1697 return display->getVsyncPeriodFromHWC();
Dominik Laskowski83b88212018-12-11 13:34:06 -08001698 }
1699
Marin Shalamanov045b7002021-01-07 16:56:24 +01001700 return 0;
Dominik Laskowski83b88212018-12-11 13:34:06 -08001701}
1702
Dominik Laskowskiebc8d3a2021-04-16 23:18:31 -07001703void SurfaceFlinger::onComposerHalVsync(hal::HWDisplayId hwcDisplayId, int64_t timestamp,
1704 std::optional<hal::VsyncPeriodNanos> vsyncPeriod) {
1705 ATRACE_CALL();
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001706
Steven Thomas3cfac282017-02-06 12:29:30 -08001707 Mutex::Autolock lock(mStateLock);
Ady Abrahame1166472021-07-15 10:56:06 -07001708 const auto displayId = getHwComposer().toPhysicalDisplayId(hwcDisplayId);
1709 if (displayId) {
1710 const auto token = getPhysicalDisplayTokenLocked(*displayId);
1711 const auto display = getDisplayDeviceLocked(token);
Marin Shalamanov045b7002021-01-07 16:56:24 +01001712 display->onVsync(timestamp);
1713 }
1714
Dominik Laskowski075d3172018-05-24 15:50:06 -07001715 if (!getHwComposer().onVsync(hwcDisplayId, timestamp)) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001716 return;
1717 }
1718
Ady Abrahame1166472021-07-15 10:56:06 -07001719 const bool isActiveDisplay =
1720 displayId && getPhysicalDisplayTokenLocked(*displayId) == mActiveDisplayToken;
1721 if (!isActiveDisplay) {
1722 // For now, we don't do anything with non active display vsyncs.
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001723 return;
1724 }
1725
Alec Mourif8e689c2019-05-20 18:32:22 -07001726 bool periodFlushed = false;
Ady Abraham5dee2f12020-02-05 17:49:47 -08001727 mScheduler->addResyncSample(timestamp, vsyncPeriod, &periodFlushed);
Alec Mourif8e689c2019-05-20 18:32:22 -07001728 if (periodFlushed) {
Dominik Laskowski08d05c22020-07-22 00:05:08 -07001729 modulateVsync(&VsyncModulator::onRefreshRateChangeCompleted);
Alec Mouri754c98a2019-03-18 18:53:42 -07001730 }
Mathias Agopian148994e2012-09-19 17:31:36 -07001731}
1732
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001733void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
David Sodman99974d22017-11-28 12:04:33 -08001734 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
1735 *compositorTiming = getBE().mCompositorTiming;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001736}
1737
Ady Abraham2139f732019-11-13 18:56:40 -08001738void SurfaceFlinger::changeRefreshRateLocked(const RefreshRate& refreshRate,
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001739 Scheduler::ModeEvent event) {
Dominik Laskowski22488f62019-03-28 09:53:04 -07001740 const auto display = getDefaultDisplayDeviceLocked();
1741 if (!display || mBootStage != BootStage::FINISHED) {
Ana Krulec7d1d6832018-12-27 11:10:09 -08001742 return;
1743 }
Alec Mouri1c9e82b2019-03-07 12:24:05 -08001744 ATRACE_CALL();
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001745
Ana Krulec7d1d6832018-12-27 11:10:09 -08001746 // Don't do any updating if the current fps is the same as the new one.
Ady Abrahamb4937392021-06-23 18:05:03 -07001747 if (!display->refreshRateConfigs().isModeAllowed(refreshRate.getModeId())) {
Marin Shalamanov228f46b2021-01-28 21:11:45 +01001748 ALOGV("Skipping mode %d as it is not part of allowed modes",
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001749 refreshRate.getModeId().value());
Ady Abraham1902d072019-03-01 17:18:59 -08001750 return;
1751 }
1752
Ady Abrahamb4937392021-06-23 18:05:03 -07001753 setDesiredActiveMode({refreshRate.getMode(), event});
Ana Krulec7d1d6832018-12-27 11:10:09 -08001754}
1755
Dominik Laskowskiebc8d3a2021-04-16 23:18:31 -07001756void SurfaceFlinger::onComposerHalHotplug(hal::HWDisplayId hwcDisplayId,
1757 hal::Connection connection) {
1758 ALOGI("%s(%" PRIu64 ", %s)", __func__, hwcDisplayId,
Peiyong Line9d809e2020-04-14 13:10:48 -07001759 connection == hal::Connection::CONNECTED ? "connected" : "disconnected");
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001760
Steven Thomasb02664d2017-07-26 18:48:28 -07001761 // Only lock if we're not on the main thread. This function is normally
1762 // called on a hwbinder thread, but for the primary display it's called on
1763 // the main thread with the state lock already held, so don't attempt to
1764 // acquire it here.
Lloyd Piqueba04e622017-12-14 17:11:26 -08001765 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
Steven Thomasb02664d2017-07-26 18:48:28 -07001766
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001767 mPendingHotplugEvents.emplace_back(HotplugEvent{hwcDisplayId, connection});
Mathias Agopian9e2463e2012-09-21 18:26:16 -07001768
Jiwen 'Steve' Caiccfd6822018-02-21 16:15:58 -08001769 if (std::this_thread::get_id() == mMainThreadId) {
1770 // Process all pending hot plug events immediately if we are on the main thread.
1771 processDisplayHotplugEventsLocked();
1772 }
1773
Lloyd Piqueba04e622017-12-14 17:11:26 -08001774 setTransactionFlags(eDisplayTransactionNeeded);
Mathias Agopian86303202012-07-24 22:46:10 -07001775}
1776
Dominik Laskowskiebc8d3a2021-04-16 23:18:31 -07001777void SurfaceFlinger::onComposerHalVsyncPeriodTimingChanged(
1778 hal::HWDisplayId, const hal::VsyncPeriodChangeTimeline& timeline) {
Ady Abraham3a77a7b2019-12-02 18:46:59 -08001779 Mutex::Autolock lock(mStateLock);
Dominik Laskowskiebc8d3a2021-04-16 23:18:31 -07001780 mScheduler->onNewVsyncPeriodChangeTimeline(timeline);
Ady Abraham7159f572019-10-11 11:10:18 -07001781}
1782
Dominik Laskowskiebc8d3a2021-04-16 23:18:31 -07001783void SurfaceFlinger::onComposerHalSeamlessPossible(hal::HWDisplayId) {
Marin Shalamanov3ea1d602020-12-16 19:59:39 +01001784 // TODO(b/142753666): use constraints when calling to setActiveModeWithConstraints and
Ady Abrahamb0433bc2020-01-08 17:31:06 -08001785 // use this callback to know when to retry in case of SEAMLESS_NOT_POSSIBLE.
1786}
1787
Dominik Laskowskiebc8d3a2021-04-16 23:18:31 -07001788void SurfaceFlinger::onComposerHalRefresh(hal::HWDisplayId) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001789 Mutex::Autolock lock(mStateLock);
Ana Krulec7d1d6832018-12-27 11:10:09 -08001790 repaintEverythingForHWC();
Steven Thomas3cfac282017-02-06 12:29:30 -08001791}
1792
Dominik Laskowski8b01cc02020-07-14 19:02:41 -07001793void SurfaceFlinger::setVsyncEnabled(bool enabled) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001794 ATRACE_CALL();
Ady Abraham9ba25122019-06-03 17:10:55 -07001795
Dominik Laskowski8b01cc02020-07-14 19:02:41 -07001796 // On main thread to avoid race conditions with display power state.
1797 static_cast<void>(schedule([=]() MAIN_THREAD {
1798 mHWCVsyncPendingState = enabled ? hal::Vsync::ENABLE : hal::Vsync::DISABLE;
Ady Abraham9ba25122019-06-03 17:10:55 -07001799
Dominik Laskowski8b01cc02020-07-14 19:02:41 -07001800 if (const auto display = getDefaultDisplayDeviceLocked();
1801 display && display->isPoweredOn()) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02001802 getHwComposer().setVsyncEnabled(display->getPhysicalId(), mHWCVsyncPendingState);
Ady Abraham9ba25122019-06-03 17:10:55 -07001803 }
Dominik Laskowski8b01cc02020-07-14 19:02:41 -07001804 }));
Mathias Agopian86303202012-07-24 22:46:10 -07001805}
1806
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07001807SurfaceFlinger::FenceWithFenceTime SurfaceFlinger::previousFrameFence() {
Ady Abrahamccf4b472021-05-11 19:53:01 -07001808 const auto now = systemTime();
1809 const auto vsyncPeriod = mScheduler->getDisplayStatInfo(now).vsyncPeriod;
1810 const bool expectedPresentTimeIsTheNextVsync = mExpectedPresentTime - now <= vsyncPeriod;
1811 return expectedPresentTimeIsTheNextVsync ? mPreviousPresentFences[0]
1812 : mPreviousPresentFences[1];
Alec Mouri6d414b52020-03-17 11:18:05 -07001813}
1814
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001815bool SurfaceFlinger::previousFramePending(int graceTimeMs) {
Alec Mouri6d414b52020-03-17 11:18:05 -07001816 ATRACE_CALL();
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07001817 const std::shared_ptr<FenceTime>& fence = previousFrameFence().fenceTime;
Ady Abrahambe0f9482019-04-24 15:41:53 -07001818
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07001819 if (fence == FenceTime::NO_FENCE) {
Ady Abraham11579302019-09-19 12:35:58 -07001820 return false;
1821 }
1822
Dan Stoza59083052020-04-28 10:13:20 -07001823 const status_t status = fence->wait(graceTimeMs);
1824 // This is the same as Fence::Status::Unsignaled, but it saves a getStatus() call,
1825 // which calls wait(0) again internally
1826 return status == -ETIME;
Ady Abrahambe0f9482019-04-24 15:41:53 -07001827}
1828
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001829nsecs_t SurfaceFlinger::previousFramePresentTime() {
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07001830 const std::shared_ptr<FenceTime>& fence = previousFrameFence().fenceTime;
Alec Mouri6d414b52020-03-17 11:18:05 -07001831
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07001832 if (fence == FenceTime::NO_FENCE) {
Alec Mouri6d414b52020-03-17 11:18:05 -07001833 return Fence::SIGNAL_TIME_INVALID;
1834 }
1835
1836 return fence->getSignalTime();
1837}
1838
Ady Abraham56b42a42020-12-28 16:48:48 -08001839nsecs_t SurfaceFlinger::calculateExpectedPresentTime(DisplayStatInfo stats) const {
Alec Mouriaa614192019-06-06 13:28:34 -07001840 // Inflate the expected present time if we're targetting the next vsync.
Ady Abraham8cb21882020-08-26 18:22:05 -07001841 return mVsyncModulator->getVsyncConfig().sfOffset > 0 ? stats.vsyncTime
1842 : stats.vsyncTime + stats.vsyncPeriod;
Alec Mouriaa614192019-06-06 13:28:34 -07001843}
1844
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -07001845void SurfaceFlinger::onMessageReceived(int32_t what, int64_t vsyncId, nsecs_t expectedVSyncTime) {
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001846 switch (what) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08001847 case MessageQueue::INVALIDATE: {
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -07001848 onMessageInvalidate(vsyncId, expectedVSyncTime);
Dan Stoza6b9454d2014-11-07 16:00:59 -08001849 break;
1850 }
1851 case MessageQueue::REFRESH: {
Dan Stoza28d46a52020-04-28 09:54:54 -07001852 onMessageRefresh();
Dan Stoza6b9454d2014-11-07 16:00:59 -08001853 break;
1854 }
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001855 }
1856}
1857
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -07001858void SurfaceFlinger::onMessageInvalidate(int64_t vsyncId, nsecs_t expectedVSyncTime) {
Dan Stoza28d46a52020-04-28 09:54:54 -07001859 const nsecs_t frameStart = systemTime();
1860 // calculate the expected present time once and use the cached
1861 // value throughout this frame to make sure all layers are
1862 // seeing this same value.
Snild Dolkow819636c2021-01-22 14:42:08 +01001863 if (expectedVSyncTime >= frameStart) {
1864 mExpectedPresentTime = expectedVSyncTime;
1865 } else {
1866 const DisplayStatInfo stats = mScheduler->getDisplayStatInfo(frameStart);
1867 mExpectedPresentTime = calculateExpectedPresentTime(stats);
1868 }
1869
1870 const nsecs_t lastScheduledPresentTime = mScheduledPresentTime;
1871 mScheduledPresentTime = expectedVSyncTime;
Dan Stoza28d46a52020-04-28 09:54:54 -07001872
Ady Abraham893c99d2021-04-30 16:00:23 -07001873 const auto vsyncIn = [&] {
1874 if (!ATRACE_ENABLED()) return 0.f;
1875 return (mExpectedPresentTime - systemTime()) / 1e6f;
1876 }();
1877 ATRACE_FORMAT("onMessageInvalidate %" PRId64 " vsyncIn %.2fms%s", vsyncId, vsyncIn,
1878 mExpectedPresentTime == expectedVSyncTime ? "" : " (adjusted)");
1879
Dan Stoza28d46a52020-04-28 09:54:54 -07001880 // When Backpressure propagation is enabled we want to give a small grace period
1881 // for the present fence to fire instead of just giving up on this frame to handle cases
1882 // where present fence is just about to get signaled.
1883 const int graceTimeForPresentFenceMs =
John Reck2ec53912020-07-07 16:53:55 -07001884 (mPropagateBackpressureClientComposition || !mHadClientComposition) ? 1 : 0;
Dan Stoza28d46a52020-04-28 09:54:54 -07001885
1886 // Pending frames may trigger backpressure propagation.
1887 const TracedOrdinal<bool> framePending = {"PrevFramePending",
1888 previousFramePending(graceTimeForPresentFenceMs)};
1889
1890 // Frame missed counts for metrics tracking.
1891 // A frame is missed if the prior frame is still pending. If no longer pending,
1892 // then we still count the frame as missed if the predicted present time
1893 // was further in the past than when the fence actually fired.
1894
1895 // Add some slop to correct for drift. This should generally be
1896 // smaller than a typical frame duration, but should not be so small
1897 // that it reports reasonable drift as a missed frame.
Ady Abrahame90dd522020-12-29 12:08:45 -08001898 const DisplayStatInfo stats = mScheduler->getDisplayStatInfo(systemTime());
Dan Stoza28d46a52020-04-28 09:54:54 -07001899 const nsecs_t frameMissedSlop = stats.vsyncPeriod / 2;
1900 const nsecs_t previousPresentTime = previousFramePresentTime();
1901 const TracedOrdinal<bool> frameMissed = {"PrevFrameMissed",
1902 framePending ||
1903 (previousPresentTime >= 0 &&
Snild Dolkow819636c2021-01-22 14:42:08 +01001904 (lastScheduledPresentTime <
Dan Stoza28d46a52020-04-28 09:54:54 -07001905 previousPresentTime - frameMissedSlop))};
1906 const TracedOrdinal<bool> hwcFrameMissed = {"PrevHwcFrameMissed",
1907 mHadDeviceComposition && frameMissed};
1908 const TracedOrdinal<bool> gpuFrameMissed = {"PrevGpuFrameMissed",
1909 mHadClientComposition && frameMissed};
1910
1911 if (frameMissed) {
1912 mFrameMissedCount++;
1913 mTimeStats->incrementMissedFrames();
Dan Stoza28d46a52020-04-28 09:54:54 -07001914 }
1915
1916 if (hwcFrameMissed) {
1917 mHwcFrameMissedCount++;
1918 }
1919
1920 if (gpuFrameMissed) {
1921 mGpuFrameMissedCount++;
1922 }
1923
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001924 // If we are in the middle of a mode change and the fence hasn't
Dan Stoza28d46a52020-04-28 09:54:54 -07001925 // fired yet just wait for the next invalidate
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001926 if (mSetActiveModePending) {
Dan Stoza28d46a52020-04-28 09:54:54 -07001927 if (framePending) {
1928 mEventQueue->invalidate();
1929 return;
1930 }
1931
1932 // We received the present fence from the HWC, so we assume it successfully updated
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001933 // the mode, hence we update SF.
1934 mSetActiveModePending = false;
1935 ON_MAIN_THREAD(setActiveModeInternal());
Dan Stoza28d46a52020-04-28 09:54:54 -07001936 }
1937
John Reck2ec53912020-07-07 16:53:55 -07001938 if (framePending) {
Dan Stoza28d46a52020-04-28 09:54:54 -07001939 if ((hwcFrameMissed && !gpuFrameMissed) || mPropagateBackpressureClientComposition) {
1940 signalLayerUpdate();
1941 return;
1942 }
1943 }
1944
Dan Stoza28d46a52020-04-28 09:54:54 -07001945 if (mTracingEnabledChanged) {
1946 mTracingEnabled = mTracing.isEnabled();
1947 mTracingEnabledChanged = false;
1948 }
1949
Ady Abraham29d0da32020-07-16 18:39:33 -07001950 if (mRefreshRateOverlaySpinner) {
Ady Abraham1b11bc62021-06-03 19:51:19 -07001951 if (Mutex::Autolock lock(mStateLock);
1952 const auto display = getDefaultDisplayDeviceLocked()) {
1953 if (display) {
1954 display->onInvalidate();
1955 } else {
1956 ALOGW("%s: default display is null", __func__);
1957 }
Ady Abraham29d0da32020-07-16 18:39:33 -07001958 }
1959 }
1960
Dan Stoza28d46a52020-04-28 09:54:54 -07001961 bool refreshNeeded;
1962 {
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07001963 mTracePostComposition = mTracing.flagIsSet(SurfaceTracing::TRACE_COMPOSITION) ||
1964 mTracing.flagIsSet(SurfaceTracing::TRACE_SYNC) ||
1965 mTracing.flagIsSet(SurfaceTracing::TRACE_BUFFERS);
1966 const bool tracePreComposition = mTracingEnabled && !mTracePostComposition;
1967 ConditionalLockGuard<std::mutex> lock(mTracingLock, tracePreComposition);
Dan Stoza28d46a52020-04-28 09:54:54 -07001968
Alec Mouri7d436ec2021-01-27 20:40:50 -08001969 mFrameTimeline->setSfWakeUp(vsyncId, frameStart, Fps::fromPeriodNsecs(stats.vsyncPeriod));
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -07001970
Dan Stoza28d46a52020-04-28 09:54:54 -07001971 refreshNeeded = handleMessageTransaction();
1972 refreshNeeded |= handleMessageInvalidate();
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07001973 if (tracePreComposition) {
1974 if (mVisibleRegionsDirty) {
Dan Stoza28d46a52020-04-28 09:54:54 -07001975 mTracing.notifyLocked("visibleRegionsDirty");
1976 }
1977 }
1978 }
1979
1980 // Layers need to get updated (in the previous line) before we can use them for
1981 // choosing the refresh rate.
1982 // Hold mStateLock as chooseRefreshRateForContent promotes wp<Layer> to sp<Layer>
1983 // and may eventually call to ~Layer() if it holds the last reference
1984 {
1985 Mutex::Autolock _l(mStateLock);
1986 mScheduler->chooseRefreshRateForContent();
1987 }
1988
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001989 ON_MAIN_THREAD(performSetActiveMode());
Dan Stoza28d46a52020-04-28 09:54:54 -07001990
1991 updateCursorAsync();
1992 updateInputFlinger();
1993
1994 refreshNeeded |= mRepaintEverything;
1995 if (refreshNeeded && CC_LIKELY(mBootStage != BootStage::BOOTLOADER)) {
1996 // Signal a refresh if a transaction modified the window state,
1997 // a new buffer was latched, or if HWC has requested a full
1998 // repaint
1999 if (mFrameStartTime <= 0) {
2000 // We should only use the time of the first invalidate
2001 // message that signals a refresh as the beginning of the
2002 // frame. Otherwise the real frame time will be
2003 // underestimated.
2004 mFrameStartTime = frameStart;
2005 }
Ady Abrahamd1b48532021-03-10 16:05:16 -08002006
2007 // Run the refresh immediately after invalidate as there is no point going thru the message
2008 // queue again, and to ensure that we actually refresh the screen instead of handling
2009 // other messages that were queued us already in the MessageQueue.
2010 mRefreshPending = true;
2011 onMessageRefresh();
Dan Stoza28d46a52020-04-28 09:54:54 -07002012 }
Ady Abraham562c2712021-05-07 15:10:42 -07002013 notifyRegionSamplingThread();
Dan Stoza28d46a52020-04-28 09:54:54 -07002014}
2015
Dan Stoza6b9454d2014-11-07 16:00:59 -08002016bool SurfaceFlinger::handleMessageTransaction() {
Alec Mourife3dc942019-02-12 14:19:18 -08002017 ATRACE_CALL();
Arthur Hung58144272021-01-16 03:43:53 +00002018
2019 if (getTransactionFlags(eTransactionFlushNeeded)) {
2020 flushTransactionQueues();
2021 }
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08002022 uint32_t transactionFlags = peekTransactionFlags();
Valerie Hau47826a72020-06-15 12:34:40 -07002023 bool runHandleTransaction =
Arthur Hung58144272021-01-16 03:43:53 +00002024 ((transactionFlags & (~eTransactionFlushNeeded)) != 0) || mForceTraversal;
Marissa Walle6e3c0d2019-03-29 10:28:30 -07002025
2026 if (runHandleTransaction) {
2027 handleTransaction(eTransactionMask);
Marissa Wall713b63f2018-10-17 15:42:43 -07002028 }
2029
Marissa Walle6e3c0d2019-03-29 10:28:30 -07002030 if (transactionFlushNeeded()) {
2031 setTransactionFlags(eTransactionFlushNeeded);
Mathias Agopian4fec8732012-06-29 14:12:52 -07002032 }
Marissa Wall713b63f2018-10-17 15:42:43 -07002033
Marissa Walle6e3c0d2019-03-29 10:28:30 -07002034 return runHandleTransaction;
Mathias Agopian4fec8732012-06-29 14:12:52 -07002035}
2036
Dan Stoza28d46a52020-04-28 09:54:54 -07002037void SurfaceFlinger::onMessageRefresh() {
Mathias Agopiancd60f992012-08-16 16:28:27 -07002038 ATRACE_CALL();
Dan Stoza14cd37c2015-07-09 12:43:33 -07002039
Dan Stoza2b6d38e2017-06-01 16:40:30 -07002040 mRefreshPending = false;
2041
Lloyd Piqueab039b52019-02-13 14:22:42 -08002042 compositionengine::CompositionRefreshArgs refreshArgs;
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002043 const auto& displays = ON_MAIN_THREAD(mDisplays);
2044 refreshArgs.outputs.reserve(displays.size());
2045 for (const auto& [_, display] : displays) {
Lloyd Piqueab039b52019-02-13 14:22:42 -08002046 refreshArgs.outputs.push_back(display->getCompositionDisplay());
2047 }
2048 mDrawingState.traverseInZOrder([&refreshArgs](Layer* layer) {
Lloyd Piquede196652020-01-22 17:29:58 -08002049 if (auto layerFE = layer->getCompositionEngineLayerFE())
2050 refreshArgs.layers.push_back(layerFE);
Lloyd Piqueab039b52019-02-13 14:22:42 -08002051 });
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002052 refreshArgs.layersWithQueuedFrames.reserve(mLayersWithQueuedFrames.size());
Alec Mouri5c9c9602020-09-01 15:10:40 -07002053 for (auto layer : mLayersWithQueuedFrames) {
Lloyd Piquede196652020-01-22 17:29:58 -08002054 if (auto layerFE = layer->getCompositionEngineLayerFE())
2055 refreshArgs.layersWithQueuedFrames.push_back(layerFE);
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002056 }
2057
Lloyd Piquef8cf14d2019-02-28 16:03:12 -08002058 refreshArgs.repaintEverything = mRepaintEverything.exchange(false);
Lloyd Pique6a3b4462019-03-07 20:58:12 -08002059 refreshArgs.outputColorSetting = useColorManagement
2060 ? mDisplayColorSetting
2061 : compositionengine::OutputColorSetting::kUnmanaged;
2062 refreshArgs.colorSpaceAgnosticDataspace = mColorSpaceAgnosticDataspace;
2063 refreshArgs.forceOutputColorMode = mForceColorMode;
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002064
2065 refreshArgs.updatingOutputGeometryThisFrame = mVisibleRegionsDirty;
2066 refreshArgs.updatingGeometryThisFrame = mGeometryInvalid || mVisibleRegionsDirty;
Lucas Dupin2dd6f392020-02-18 17:43:36 -08002067 refreshArgs.blursAreExpensive = mBlursAreExpensive;
Snild Dolkow9e217d62020-04-22 15:53:42 +02002068 refreshArgs.internalDisplayRotationFlags = DisplayDevice::getPrimaryDisplayRotationFlags();
Lloyd Pique3eb1b212019-03-07 21:15:40 -08002069
2070 if (CC_UNLIKELY(mDrawingState.colorMatrixChanged)) {
2071 refreshArgs.colorTransformMatrix = mDrawingState.colorMatrix;
2072 mDrawingState.colorMatrixChanged = false;
2073 }
2074
2075 refreshArgs.devOptForceClientComposition = mDebugDisableHWC || mDebugRegion;
2076
Lloyd Piquef8cf14d2019-02-28 16:03:12 -08002077 if (mDebugRegion != 0) {
2078 refreshArgs.devOptFlashDirtyRegionsDelay =
2079 std::chrono::milliseconds(mDebugRegion > 1 ? mDebugRegion : 0);
2080 }
Lloyd Piqueab039b52019-02-13 14:22:42 -08002081
Ady Abrahamcaba2982021-06-16 16:45:04 -07002082 const auto prevVsyncTime = mScheduler->getPreviousVsyncFrom(mExpectedPresentTime);
2083 const auto hwcMinWorkDuration = mVsyncConfiguration->getCurrentConfigs().hwcMinWorkDuration;
2084 refreshArgs.earliestPresentTime = prevVsyncTime - hwcMinWorkDuration;
Ady Abrahamec7aa8a2021-06-28 12:37:09 -07002085 refreshArgs.previousPresentFence = mPreviousPresentFences[0].fenceTime;
Alec Mouriaa831582021-06-07 16:23:01 -07002086 refreshArgs.nextInvalidateTime = mEventQueue->nextExpectedInvalidate();
Ady Abraham3645e642021-04-20 18:39:00 -07002087
Lloyd Pique3eb1b212019-03-07 21:15:40 -08002088 mGeometryInvalid = false;
2089
Ady Abraham3a77a7b2019-12-02 18:46:59 -08002090 // Store the present time just before calling to the composition engine so we could notify
2091 // the scheduler.
2092 const auto presentTime = systemTime();
2093
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002094 mCompositionEngine->present(refreshArgs);
Alec Mouri9519bf12019-11-15 16:54:44 -08002095 mTimeStats->recordFrameDuration(mFrameStartTime, systemTime());
2096 // Reset the frame start time now that we've recorded this frame.
2097 mFrameStartTime = 0;
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002098
Ady Abraham3a77a7b2019-12-02 18:46:59 -08002099 mScheduler->onDisplayRefreshed(presentTime);
2100
Jorim Jaggi9c03b502020-11-24 23:51:31 +01002101 postFrame();
2102 postComposition();
2103
Midas Chien50f52e22020-09-26 17:57:42 +08002104 const bool prevFrameHadClientComposition = mHadClientComposition;
Alec Mouri8f7a0102020-04-15 12:11:10 -07002105
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002106 mHadClientComposition = std::any_of(displays.cbegin(), displays.cend(), [](const auto& pair) {
2107 const auto& state = pair.second->getCompositionDisplay()->getState();
2108 return state.usesClientComposition && !state.reusedClientComposition;
2109 });
2110 mHadDeviceComposition = std::any_of(displays.cbegin(), displays.cend(), [](const auto& pair) {
2111 const auto& state = pair.second->getCompositionDisplay()->getState();
2112 return state.usesDeviceComposition;
2113 });
Vishnu Nair9b079a22020-01-21 14:36:08 -08002114 mReusedClientComposition =
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002115 std::any_of(displays.cbegin(), displays.cend(), [](const auto& pair) {
2116 const auto& state = pair.second->getCompositionDisplay()->getState();
2117 return state.reusedClientComposition;
Vishnu Nair9b079a22020-01-21 14:36:08 -08002118 });
Midas Chien50f52e22020-09-26 17:57:42 +08002119 // Only report a strategy change if we move in and out of client composition
2120 if (prevFrameHadClientComposition != mHadClientComposition) {
Alec Mouri8f7a0102020-04-15 12:11:10 -07002121 mTimeStats->incrementCompositionStrategyChanges();
2122 }
2123
Yichi Chen28dee2c2020-07-06 21:24:14 +08002124 // TODO: b/160583065 Enable skip validation when SF caches all client composition layers
Dominik Laskowski08d05c22020-07-22 00:05:08 -07002125 const bool usedGpuComposition = mHadClientComposition || mReusedClientComposition;
2126 modulateVsync(&VsyncModulator::onDisplayRefresh, usedGpuComposition);
Dan Stoza14cd37c2015-07-09 12:43:33 -07002127
David Sodman7e4ae112018-02-09 15:02:28 -08002128 mLayersWithQueuedFrames.clear();
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07002129 if (mTracingEnabled && mTracePostComposition) {
2130 // This may block if SurfaceTracing is running in sync mode.
2131 if (mVisibleRegionsDirty) {
Vishnu Nairdf529052019-06-07 14:53:14 -07002132 mTracing.notify("visibleRegionsDirty");
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07002133 } else if (mTracing.flagIsSet(SurfaceTracing::TRACE_BUFFERS)) {
2134 mTracing.notify("bufferLatched");
Vishnu Nairdf529052019-06-07 14:53:14 -07002135 }
2136 }
Robert Carr167bdde2021-07-28 11:26:51 -07002137
2138 mVisibleRegionsWereDirtyThisFrame = mVisibleRegionsDirty; // Cache value for use in post-comp
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07002139 mVisibleRegionsDirty = false;
Lloyd Piqueab039b52019-02-13 14:22:42 -08002140
2141 if (mCompositionEngine->needsAnotherUpdate()) {
2142 signalLayerUpdate();
2143 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07002144}
Mathias Agopian4fec8732012-06-29 14:12:52 -07002145
David Sodmanfa9b2af2017-12-24 13:28:59 -08002146bool SurfaceFlinger::handleMessageInvalidate() {
2147 ATRACE_CALL();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002148 bool refreshNeeded = handlePageFlip();
2149
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07002150 // Send on commit callbacks
2151 mTransactionCallbackInvoker.sendCallbacks();
2152
Vishnu Nair4351ad52019-02-11 14:13:02 -08002153 if (mVisibleRegionsDirty) {
2154 computeLayerBounds();
2155 }
2156
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002157 for (auto& layer : mLayersPendingRefresh) {
2158 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002159 visibleReg.set(layer->getScreenBounds());
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002160 invalidateLayerStack(layer, visibleReg);
2161 }
2162 mLayersPendingRefresh.clear();
2163 return refreshNeeded;
Mathias Agopian4fec8732012-06-29 14:12:52 -07002164}
2165
Ana Krulece588e312018-09-18 12:32:24 -07002166void SurfaceFlinger::updateCompositorTiming(const DisplayStatInfo& stats, nsecs_t compositeTime,
2167 std::shared_ptr<FenceTime>& presentFenceTime) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002168 // Update queue of past composite+present times and determine the
2169 // most recently known composite to present latency.
David Sodman99974d22017-11-28 12:04:33 -08002170 getBE().mCompositePresentTimes.push({compositeTime, presentFenceTime});
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002171 nsecs_t compositeToPresentLatency = -1;
David Sodman99974d22017-11-28 12:04:33 -08002172 while (!getBE().mCompositePresentTimes.empty()) {
2173 SurfaceFlingerBE::CompositePresentTime& cpt = getBE().mCompositePresentTimes.front();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002174 // Cached values should have been updated before calling this method,
2175 // which helps avoid duplicate syscalls.
2176 nsecs_t displayTime = cpt.display->getCachedSignalTime();
2177 if (displayTime == Fence::SIGNAL_TIME_PENDING) {
2178 break;
2179 }
2180 compositeToPresentLatency = displayTime - cpt.composite;
David Sodman99974d22017-11-28 12:04:33 -08002181 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002182 }
2183
2184 // Don't let mCompositePresentTimes grow unbounded, just in case.
David Sodman99974d22017-11-28 12:04:33 -08002185 while (getBE().mCompositePresentTimes.size() > 16) {
2186 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002187 }
2188
Ana Krulece588e312018-09-18 12:32:24 -07002189 setCompositorTimingSnapped(stats, compositeToPresentLatency);
Brian Andersond0010582017-03-07 13:20:31 -08002190}
2191
Ana Krulece588e312018-09-18 12:32:24 -07002192void SurfaceFlinger::setCompositorTimingSnapped(const DisplayStatInfo& stats,
2193 nsecs_t compositeToPresentLatency) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002194 // Integer division and modulo round toward 0 not -inf, so we need to
2195 // treat negative and positive offsets differently.
Ady Abraham8287e852020-08-12 14:44:58 -07002196 nsecs_t idealLatency = (mVsyncConfiguration->getCurrentConfigs().late.sfOffset > 0)
Ady Abraham9e16a482019-12-03 17:19:41 -08002197 ? (stats.vsyncPeriod -
Ady Abraham8287e852020-08-12 14:44:58 -07002198 (mVsyncConfiguration->getCurrentConfigs().late.sfOffset % stats.vsyncPeriod))
2199 : ((-mVsyncConfiguration->getCurrentConfigs().late.sfOffset) % stats.vsyncPeriod);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002200
Ady Abraham8287e852020-08-12 14:44:58 -07002201 // Just in case mVsyncConfiguration->getCurrentConfigs().late.sf == -vsyncInterval.
Brian Andersond0010582017-03-07 13:20:31 -08002202 if (idealLatency <= 0) {
Ana Krulece588e312018-09-18 12:32:24 -07002203 idealLatency = stats.vsyncPeriod;
Brian Andersond0010582017-03-07 13:20:31 -08002204 }
2205
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002206 // Snap the latency to a value that removes scheduling jitter from the
2207 // composition and present times, which often have >1ms of jitter.
2208 // Reducing jitter is important if an app attempts to extrapolate
2209 // something (such as user input) to an accurate diasplay time.
Ady Abraham9e16a482019-12-03 17:19:41 -08002210 // Snapping also allows an app to precisely calculate
Ady Abraham8287e852020-08-12 14:44:58 -07002211 // mVsyncConfiguration->getCurrentConfigs().late.sf with (presentLatency % interval).
Ana Krulece588e312018-09-18 12:32:24 -07002212 nsecs_t bias = stats.vsyncPeriod / 2;
2213 int64_t extraVsyncs = (compositeToPresentLatency - idealLatency + bias) / stats.vsyncPeriod;
2214 nsecs_t snappedCompositeToPresentLatency =
2215 (extraVsyncs > 0) ? idealLatency + (extraVsyncs * stats.vsyncPeriod) : idealLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002216
David Sodman99974d22017-11-28 12:04:33 -08002217 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
Ana Krulece588e312018-09-18 12:32:24 -07002218 getBE().mCompositorTiming.deadline = stats.vsyncTime - idealLatency;
2219 getBE().mCompositorTiming.interval = stats.vsyncPeriod;
David Sodman99974d22017-11-28 12:04:33 -08002220 getBE().mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002221}
2222
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01002223void SurfaceFlinger::postComposition() {
Dan Stoza9e56aa02015-11-02 13:00:03 -08002224 ATRACE_CALL();
2225 ALOGV("postComposition");
2226
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002227 const auto* display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked()).get();
Brian Anderson3d4039d2016-09-23 16:31:30 -07002228
David Sodman73beded2017-11-15 11:56:06 -08002229 getBE().mGlCompositionDoneTimeline.updateSignalTimes();
Brian Anderson3d4039d2016-09-23 16:31:30 -07002230 std::shared_ptr<FenceTime> glCompositionDoneFenceTime;
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002231 if (display && display->getCompositionDisplay()->getState().usesClientComposition) {
Brian Anderson3d4039d2016-09-23 16:31:30 -07002232 glCompositionDoneFenceTime =
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002233 std::make_shared<FenceTime>(display->getCompositionDisplay()
Lloyd Pique31cb2942018-10-19 17:23:03 -07002234 ->getRenderSurface()
2235 ->getClientTargetAcquireFence());
David Sodman73beded2017-11-15 11:56:06 -08002236 getBE().mGlCompositionDoneTimeline.push(glCompositionDoneFenceTime);
Brian Anderson3d4039d2016-09-23 16:31:30 -07002237 } else {
2238 glCompositionDoneFenceTime = FenceTime::NO_FENCE;
2239 }
Brian Anderson3d4039d2016-09-23 16:31:30 -07002240
David Sodman73beded2017-11-15 11:56:06 -08002241 getBE().mDisplayTimeline.updateSignalTimes();
Ady Abrahambe0f9482019-04-24 15:41:53 -07002242 mPreviousPresentFences[1] = mPreviousPresentFences[0];
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07002243 mPreviousPresentFences[0].fence =
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02002244 display ? getHwComposer().getPresentFence(display->getPhysicalId()) : Fence::NO_FENCE;
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07002245 mPreviousPresentFences[0].fenceTime =
2246 std::make_shared<FenceTime>(mPreviousPresentFences[0].fence);
2247
2248 getBE().mDisplayTimeline.push(mPreviousPresentFences[0].fenceTime);
Brian Anderson3d4039d2016-09-23 16:31:30 -07002249
Vishnu Nair9a69a042021-06-18 13:19:49 -07002250 nsecs_t now = systemTime();
2251
Jorim Jaggi8d34c902020-12-16 21:43:07 +01002252 // Set presentation information before calling Layer::releasePendingBuffer, such that jank
2253 // information from previous' frame classification is already available when sending jank info
2254 // to clients, so they get jank classification as early as possible.
Vishnu Nair9a69a042021-06-18 13:19:49 -07002255 mFrameTimeline->setSfPresent(/* sfPresentTime */ now, mPreviousPresentFences[0].fenceTime,
Adithya Srinivasan36b01af2021-04-07 22:29:47 +00002256 glCompositionDoneFenceTime);
Jorim Jaggi8d34c902020-12-16 21:43:07 +01002257
Vishnu Nair9a69a042021-06-18 13:19:49 -07002258 const DisplayStatInfo stats = mScheduler->getDisplayStatInfo(now);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002259
Lloyd Piqueab039b52019-02-13 14:22:42 -08002260 // We use the CompositionEngine::getLastFrameRefreshTimestamp() which might
2261 // be sampled a little later than when we started doing work for this frame,
2262 // but that should be okay since updateCompositorTiming has snapping logic.
2263 updateCompositorTiming(stats, mCompositionEngine->getLastFrameRefreshTimestamp(),
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07002264 mPreviousPresentFences[0].fenceTime);
Brian Andersond0010582017-03-07 13:20:31 -08002265 CompositorTiming compositorTiming;
2266 {
David Sodman99974d22017-11-28 12:04:33 -08002267 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
2268 compositorTiming = getBE().mCompositorTiming;
Brian Andersond0010582017-03-07 13:20:31 -08002269 }
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002270
Robert Carrc747ad02021-06-11 14:01:24 -07002271 for (const auto& layer: mLayersWithQueuedFrames) {
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07002272 const bool frameLatched =
2273 layer->onPostComposition(display, glCompositionDoneFenceTime,
2274 mPreviousPresentFences[0].fenceTime, compositorTiming);
Vishnu Nair9a69a042021-06-18 13:19:49 -07002275 layer->releasePendingBuffer(/*dequeueReadyTime*/ now);
Dan Stozae77c7662016-05-13 11:37:28 -07002276 if (frameLatched) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07002277 recordBufferingStats(layer->getName(), layer->getOccupancyHistory(false));
Dan Stozae77c7662016-05-13 11:37:28 -07002278 }
Robert Carrc747ad02021-06-11 14:01:24 -07002279 }
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002280
John Reck88270902021-03-18 11:27:35 -04002281 std::vector<std::pair<std::shared_ptr<compositionengine::Display>, sp<HdrLayerInfoReporter>>>
2282 hdrInfoListeners;
Robert Carr167bdde2021-07-28 11:26:51 -07002283 bool haveNewListeners = false;
Alec Mouriadebf5c2021-01-05 12:57:36 -08002284 {
2285 Mutex::Autolock lock(mStateLock);
2286 if (mFpsReporter) {
2287 mFpsReporter->dispatchLayerFps();
2288 }
Galia Peycheva8f04b302021-04-27 13:25:38 +02002289
2290 if (mTunnelModeEnabledReporter) {
2291 mTunnelModeEnabledReporter->updateTunnelModeStatus();
2292 }
John Reck88270902021-03-18 11:27:35 -04002293 hdrInfoListeners.reserve(mHdrLayerInfoListeners.size());
Dominik Laskowski0bb9e652021-03-18 12:21:29 -07002294 for (const auto& [displayId, reporter] : mHdrLayerInfoListeners) {
2295 if (reporter && reporter->hasListeners()) {
2296 if (const auto display = getDisplayDeviceLocked(displayId)) {
2297 hdrInfoListeners.emplace_back(display->getCompositionDisplay(), reporter);
John Reck88270902021-03-18 11:27:35 -04002298 }
2299 }
2300 }
Robert Carr167bdde2021-07-28 11:26:51 -07002301 haveNewListeners = mAddingHDRLayerInfoListener; // grab this with state lock
2302 mAddingHDRLayerInfoListener = false;
John Reck88270902021-03-18 11:27:35 -04002303 }
2304
Robert Carr167bdde2021-07-28 11:26:51 -07002305 if (haveNewListeners || mSomeDataspaceChanged || mVisibleRegionsWereDirtyThisFrame) {
2306 for (auto& [compositionDisplay, listener] : hdrInfoListeners) {
2307 HdrLayerInfoReporter::HdrLayerInfo info;
2308 int32_t maxArea = 0;
2309 mDrawingState.traverse([&, compositionDisplay = compositionDisplay](Layer* layer) {
2310 const auto layerFe = layer->getCompositionEngineLayerFE();
2311 if (layer->isVisible() && compositionDisplay->belongsInOutput(layerFe)) {
2312 const Dataspace transfer =
John Reck241cc4a2021-05-12 09:56:40 -04002313 static_cast<Dataspace>(layer->getDataSpace() & Dataspace::TRANSFER_MASK);
Robert Carr167bdde2021-07-28 11:26:51 -07002314 const bool isHdr = (transfer == Dataspace::TRANSFER_ST2084 ||
2315 transfer == Dataspace::TRANSFER_HLG);
John Reck88270902021-03-18 11:27:35 -04002316
Robert Carr167bdde2021-07-28 11:26:51 -07002317 if (isHdr) {
2318 const auto* outputLayer =
2319 compositionDisplay->getOutputLayerForLayer(layerFe);
2320 if (outputLayer) {
2321 info.numberOfHdrLayers++;
2322 const auto displayFrame = outputLayer->getState().displayFrame;
2323 const int32_t area = displayFrame.width() * displayFrame.height();
2324 if (area > maxArea) {
2325 maxArea = area;
2326 info.maxW = displayFrame.width();
2327 info.maxH = displayFrame.height();
2328 }
John Reckdb1a16b2021-07-09 13:05:52 -04002329 }
John Reck88270902021-03-18 11:27:35 -04002330 }
2331 }
Robert Carr167bdde2021-07-28 11:26:51 -07002332 });
2333 listener->dispatchHdrLayerInfo(info);
2334 }
Alec Mouriadebf5c2021-01-05 12:57:36 -08002335 }
2336
Robert Carr167bdde2021-07-28 11:26:51 -07002337 mSomeDataspaceChanged = false;
2338 mVisibleRegionsWereDirtyThisFrame = false;
2339
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07002340 mTransactionCallbackInvoker.addPresentFence(mPreviousPresentFences[0].fence);
Robert Carr9a803c32021-01-14 16:57:58 -08002341 mTransactionCallbackInvoker.sendCallbacks();
Valerie Hau4b678442020-04-14 10:50:42 -07002342
Ady Abraham7825c682021-05-17 15:12:14 -07002343 if (display && display->isInternal() && display->getPowerMode() == hal::PowerMode::ON &&
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07002344 mPreviousPresentFences[0].fenceTime->isValid()) {
2345 mScheduler->addPresentFence(mPreviousPresentFences[0].fenceTime);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07002346 }
2347
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02002348 const bool isDisplayConnected =
2349 display && getHwComposer().isConnected(display->getPhysicalId());
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002350
Fabien Sanglardcbf153b2017-03-10 17:57:12 -08002351 if (!hasSyncFramework) {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002352 if (isDisplayConnected && display->isPoweredOn()) {
Ana Krulecc2870422019-01-29 19:00:58 -08002353 mScheduler->enableHardwareVsync();
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07002354 }
2355 }
2356
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002357 if (mAnimCompositionPending) {
2358 mAnimCompositionPending = false;
2359
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07002360 if (mPreviousPresentFences[0].fenceTime->isValid()) {
2361 mAnimFrameTracker.setActualPresentFence(mPreviousPresentFences[0].fenceTime);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002362 } else if (isDisplayConnected) {
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002363 // The HWC doesn't support present fences, so use the refresh
2364 // timestamp instead.
Marin Shalamanov045b7002021-01-07 16:56:24 +01002365 const nsecs_t presentTime = display->getRefreshTimestamp();
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002366 mAnimFrameTracker.setActualPresentTime(presentTime);
2367 }
2368 mAnimFrameTracker.advanceFrame();
2369 }
Dan Stozab90cf072015-03-05 11:05:59 -08002370
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002371 mTimeStats->incrementTotalFrames();
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07002372 if (mHadClientComposition) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002373 mTimeStats->incrementClientCompositionFrames();
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07002374 }
2375
Vishnu Nair9b079a22020-01-21 14:36:08 -08002376 if (mReusedClientComposition) {
2377 mTimeStats->incrementClientCompositionReusedFrames();
2378 }
2379
Ady Abraham6c1b7ac2021-03-31 16:56:03 -07002380 mTimeStats->setPresentFenceGlobal(mPreviousPresentFences[0].fenceTime);
Yiwei Zhangce6ebc02018-10-20 12:42:38 -07002381
Alec Mouri717bcb62020-02-10 17:07:19 -08002382 const size_t sfConnections = mScheduler->getEventThreadConnectionCount(mSfConnectionHandle);
2383 const size_t appConnections = mScheduler->getEventThreadConnectionCount(mAppConnectionHandle);
2384 mTimeStats->recordDisplayEventConnectionCount(sfConnections + appConnections);
2385
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002386 if (isDisplayConnected && !display->isPoweredOn()) {
Dan Stozab90cf072015-03-05 11:05:59 -08002387 return;
2388 }
2389
2390 nsecs_t currentTime = systemTime();
2391 if (mHasPoweredOff) {
2392 mHasPoweredOff = false;
2393 } else {
David Sodman4a36e932017-11-07 14:29:47 -08002394 nsecs_t elapsedTime = currentTime - getBE().mLastSwapTime;
Ana Krulece588e312018-09-18 12:32:24 -07002395 size_t numPeriods = static_cast<size_t>(elapsedTime / stats.vsyncPeriod);
David Sodman4a36e932017-11-07 14:29:47 -08002396 if (numPeriods < SurfaceFlingerBE::NUM_BUCKETS - 1) {
2397 getBE().mFrameBuckets[numPeriods] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002398 } else {
David Sodman4a36e932017-11-07 14:29:47 -08002399 getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002400 }
David Sodman4a36e932017-11-07 14:29:47 -08002401 getBE().mTotalTime += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002402 }
David Sodman4a36e932017-11-07 14:29:47 -08002403 getBE().mLastSwapTime = currentTime;
Dan Stoza436ccf32018-06-21 12:10:12 -07002404
Lingfeng Yang2e4fef62020-04-24 14:48:43 +00002405 // Cleanup any outstanding resources due to rendering a prior frame.
2406 getRenderEngine().cleanupPostRender();
2407
Dan Stoza436ccf32018-06-21 12:10:12 -07002408 {
2409 std::lock_guard lock(mTexturePoolMutex);
Dan Stoza67765d82019-05-07 14:58:27 -07002410 if (mTexturePool.size() < mTexturePoolSize) {
2411 const size_t refillCount = mTexturePoolSize - mTexturePool.size();
Dan Stoza436ccf32018-06-21 12:10:12 -07002412 const size_t offset = mTexturePool.size();
2413 mTexturePool.resize(mTexturePoolSize);
2414 getRenderEngine().genTextures(refillCount, mTexturePool.data() + offset);
2415 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Dan Stoza67765d82019-05-07 14:58:27 -07002416 } else if (mTexturePool.size() > mTexturePoolSize) {
2417 const size_t deleteCount = mTexturePool.size() - mTexturePoolSize;
2418 const size_t offset = mTexturePoolSize;
2419 getRenderEngine().deleteTextures(deleteCount, mTexturePool.data() + offset);
2420 mTexturePool.resize(mTexturePoolSize);
2421 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Dan Stoza436ccf32018-06-21 12:10:12 -07002422 }
2423 }
Marissa Walle2ffb422018-10-12 11:33:52 -07002424
Dan Stoza45de5ba2019-04-25 14:12:09 -07002425 // Even though ATRACE_INT64 already checks if tracing is enabled, it doesn't prevent the
2426 // side-effect of getTotalSize(), so we check that again here
2427 if (ATRACE_ENABLED()) {
Marissa Wall22b2de12019-12-02 18:11:43 -08002428 // getTotalSize returns the total number of buffers that were allocated by SurfaceFlinger
Dan Stoza45de5ba2019-04-25 14:12:09 -07002429 ATRACE_INT64("Total Buffer Size", GraphicBufferAllocator::get().getTotalSize());
2430 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07002431}
2432
Lloyd Pique7eebe692020-04-22 22:40:06 -07002433FloatRect SurfaceFlinger::getLayerClipBoundsForDisplay(const DisplayDevice& displayDevice) const {
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02002434 return displayDevice.getLayerStackSpaceRect().toFloatRect();
Lloyd Pique7eebe692020-04-22 22:40:06 -07002435}
2436
Vishnu Nair4351ad52019-02-11 14:13:02 -08002437void SurfaceFlinger::computeLayerBounds() {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002438 for (const auto& pair : ON_MAIN_THREAD(mDisplays)) {
Vishnu Nair4351ad52019-02-11 14:13:02 -08002439 const auto& displayDevice = pair.second;
2440 const auto display = displayDevice->getCompositionDisplay();
2441 for (const auto& layer : mDrawingState.layersSortedByZ) {
2442 // only consider the layers on the given layer stack
2443 if (!display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
Vishnu Nair01ace762019-02-12 14:25:24 -08002444 continue;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002445 }
2446
Lloyd Pique7eebe692020-04-22 22:40:06 -07002447 layer->computeBounds(getLayerClipBoundsForDisplay(*displayDevice), ui::Transform(),
Vishnu Nairc97b8db2019-10-29 18:19:35 -07002448 0.f /* shadowRadius */);
Vishnu Nair4351ad52019-02-11 14:13:02 -08002449 }
2450 }
2451}
2452
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002453void SurfaceFlinger::postFrame() {
2454 const auto display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked());
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02002455 if (display && getHwComposer().isConnected(display->getPhysicalId())) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002456 uint32_t flipCount = display->getPageFlipCount();
David Sodmanfa9b2af2017-12-24 13:28:59 -08002457 if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
2458 logFrameStats();
2459 }
2460 }
2461}
2462
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01002463void SurfaceFlinger::handleTransaction(uint32_t transactionFlags) {
Mathias Agopian841cde52012-03-01 15:44:37 -08002464 ATRACE_CALL();
2465
Mathias Agopian7cc6df52013-06-05 14:30:54 -07002466 // here we keep a copy of the drawing state (that is the state that's
2467 // going to be overwritten by handleTransactionLocked()) outside of
2468 // mStateLock so that the side-effects of the State assignment
2469 // don't happen with mStateLock held (which can cause deadlocks).
2470 State drawingState(mDrawingState);
2471
Mathias Agopianca4d3602011-05-19 15:38:14 -07002472 Mutex::Autolock _l(mStateLock);
Dominik Laskowski9dab3432019-03-27 13:21:10 -07002473 mDebugInTransaction = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002474
Mathias Agopianca4d3602011-05-19 15:38:14 -07002475 // Here we're guaranteed that some transaction flags are set
2476 // so we can call handleTransactionLocked() unconditionally.
2477 // We call getTransactionFlags(), which will also clear the flags,
2478 // with mStateLock held to guarantee that mCurrentState won't change
2479 // until the transaction is committed.
Dominik Laskowski08d05c22020-07-22 00:05:08 -07002480 modulateVsync(&VsyncModulator::onTransactionCommit);
Mathias Agopiane57f2922012-08-09 16:29:12 -07002481 transactionFlags = getTransactionFlags(eTransactionMask);
Mathias Agopian87baae12012-07-31 12:38:26 -07002482 handleTransactionLocked(transactionFlags);
Mathias Agopiandea20b12011-05-03 17:04:02 -07002483
Mathias Agopianca4d3602011-05-19 15:38:14 -07002484 mDebugInTransaction = 0;
Mathias Agopianca4d3602011-05-19 15:38:14 -07002485 // here the transaction has been committed
Mathias Agopian3d579642009-06-04 18:46:21 -07002486}
2487
Marin Shalamanovd3b5c5d2021-02-11 18:26:14 +01002488void SurfaceFlinger::loadDisplayModes(PhysicalDisplayId displayId, DisplayModes& outModes,
2489 DisplayModePtr& outActiveMode) const {
2490 std::vector<HWComposer::HWCDisplayMode> hwcModes;
2491 std::optional<hal::HWDisplayId> activeModeHwcId;
2492 bool activeModeIsSupported;
2493 int attempt = 0;
2494 constexpr int kMaxAttempts = 3;
2495 do {
2496 hwcModes = getHwComposer().getModes(displayId);
2497 activeModeHwcId = getHwComposer().getActiveMode(displayId);
2498 LOG_ALWAYS_FATAL_IF(!activeModeHwcId, "HWC returned no active mode");
2499
2500 activeModeIsSupported =
2501 std::any_of(hwcModes.begin(), hwcModes.end(),
2502 [activeModeHwcId](const HWComposer::HWCDisplayMode& mode) {
2503 return mode.hwcId == *activeModeHwcId;
2504 });
2505 } while (!activeModeIsSupported && ++attempt < kMaxAttempts);
2506 LOG_ALWAYS_FATAL_IF(!activeModeIsSupported,
2507 "After %d attempts HWC still returns an active mode which is not"
2508 " supported. Active mode ID = %" PRIu64 " . Supported modes = %s",
2509 kMaxAttempts, *activeModeHwcId, base::Join(hwcModes, ", ").c_str());
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01002510
2511 DisplayModes oldModes;
2512
2513 if (const auto token = getPhysicalDisplayTokenLocked(displayId)) {
2514 oldModes = getDisplayDeviceLocked(token)->getSupportedModes();
Marin Shalamanov045b7002021-01-07 16:56:24 +01002515 }
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01002516
2517 int largestUsedModeId = -1; // Use int instead of DisplayModeId for signedness
2518 for (const auto& mode : oldModes) {
2519 const auto id = static_cast<int>(mode->getId().value());
2520 if (id > largestUsedModeId) {
2521 largestUsedModeId = id;
2522 }
2523 }
2524
2525 DisplayModes newModes;
2526 int32_t nextModeId = largestUsedModeId + 1;
2527 for (const auto& hwcMode : hwcModes) {
2528 newModes.push_back(DisplayMode::Builder(hwcMode.hwcId)
2529 .setId(DisplayModeId{nextModeId++})
Ady Abrahamf3e81d22021-06-23 17:43:41 -07002530 .setPhysicalDisplayId(displayId)
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01002531 .setWidth(hwcMode.width)
2532 .setHeight(hwcMode.height)
2533 .setVsyncPeriod(hwcMode.vsyncPeriod)
2534 .setDpiX(hwcMode.dpiX)
2535 .setDpiY(hwcMode.dpiY)
2536 .setGroup(hwcMode.configGroup)
2537 .build());
2538 }
2539
2540 const bool modesAreSame =
2541 std::equal(newModes.begin(), newModes.end(), oldModes.begin(), oldModes.end(),
2542 [](DisplayModePtr left, DisplayModePtr right) {
2543 return left->equalsExceptDisplayModeId(right);
2544 });
2545
2546 if (modesAreSame) {
2547 // The supported modes have not changed, keep the old IDs.
Marin Shalamanovd3b5c5d2021-02-11 18:26:14 +01002548 outModes = oldModes;
2549 } else {
2550 outModes = newModes;
Marin Shalamanovf22e6ac2021-02-10 20:45:15 +01002551 }
2552
Marin Shalamanovd3b5c5d2021-02-11 18:26:14 +01002553 outActiveMode = *std::find_if(outModes.begin(), outModes.end(),
2554 [activeModeHwcId](const DisplayModePtr& mode) {
2555 return mode->getHwcId() == *activeModeHwcId;
2556 });
Marin Shalamanov045b7002021-01-07 16:56:24 +01002557}
2558
Lloyd Piqueba04e622017-12-14 17:11:26 -08002559void SurfaceFlinger::processDisplayHotplugEventsLocked() {
2560 for (const auto& event : mPendingHotplugEvents) {
Marin Shalamanovf8c63722020-10-06 13:11:21 +02002561 std::optional<DisplayIdentificationInfo> info =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002562 getHwComposer().onHotplug(event.hwcDisplayId, event.connection);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002563
Dominik Laskowski075d3172018-05-24 15:50:06 -07002564 if (!info) {
Lloyd Piqueba04e622017-12-14 17:11:26 -08002565 continue;
2566 }
2567
Marin Shalamanova524a092020-07-27 21:39:55 +02002568 const auto displayId = info->id;
Dominik Laskowski55c85402020-01-21 16:25:47 -08002569 const auto it = mPhysicalDisplayTokens.find(displayId);
2570
Peiyong Line9d809e2020-04-14 13:10:48 -07002571 if (event.connection == hal::Connection::CONNECTED) {
Marin Shalamanovd3b5c5d2021-02-11 18:26:14 +01002572 DisplayModes supportedModes;
2573 DisplayModePtr activeMode;
2574 loadDisplayModes(displayId, supportedModes, activeMode);
Marin Shalamanova903d032020-12-29 20:35:13 +01002575
Dominik Laskowski55c85402020-01-21 16:25:47 -08002576 if (it == mPhysicalDisplayTokens.end()) {
2577 ALOGV("Creating display %s", to_string(displayId).c_str());
2578
Dominik Laskowski075d3172018-05-24 15:50:06 -07002579 DisplayDeviceState state;
Marin Shalamanov7ce87642020-05-06 13:45:58 +02002580 state.physical = {.id = displayId,
2581 .type = getHwComposer().getDisplayConnectionType(displayId),
2582 .hwcDisplayId = event.hwcDisplayId,
Marin Shalamanova903d032020-12-29 20:35:13 +01002583 .deviceProductInfo = std::move(info->deviceProductInfo),
2584 .supportedModes = std::move(supportedModes),
2585 .activeMode = activeMode};
Dominik Laskowski075d3172018-05-24 15:50:06 -07002586 state.isSecure = true; // All physical displays are currently considered secure.
Marin Shalamanovf8c63722020-10-06 13:11:21 +02002587 state.displayName = std::move(info->name);
Dominik Laskowski55c85402020-01-21 16:25:47 -08002588
2589 sp<IBinder> token = new BBinder();
2590 mCurrentState.displays.add(token, state);
2591 mPhysicalDisplayTokens.emplace(displayId, std::move(token));
Dominik Laskowski075d3172018-05-24 15:50:06 -07002592 mInterceptor->saveDisplayCreation(state);
Marin Shalamanov700e6392020-02-12 20:22:26 +01002593 } else {
2594 ALOGV("Recreating display %s", to_string(displayId).c_str());
2595
2596 const auto token = it->second;
2597 auto& state = mCurrentState.displays.editValueFor(token);
Marin Shalamanovf8c63722020-10-06 13:11:21 +02002598 state.sequenceId = DisplayDeviceState{}.sequenceId; // Generate new sequenceId
Marin Shalamanova903d032020-12-29 20:35:13 +01002599 state.physical->supportedModes = std::move(supportedModes);
2600 state.physical->activeMode = activeMode;
Marin Shalamanovf8c63722020-10-06 13:11:21 +02002601 if (getHwComposer().updatesDeviceProductInfoOnHotplugReconnect()) {
2602 state.physical->deviceProductInfo = std::move(info->deviceProductInfo);
2603 }
Steven Thomaseb6d2052018-03-20 15:40:48 -07002604 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08002605 } else {
Dominik Laskowski55c85402020-01-21 16:25:47 -08002606 ALOGV("Removing display %s", to_string(displayId).c_str());
Lloyd Piqueba04e622017-12-14 17:11:26 -08002607
Dominik Laskowski55c85402020-01-21 16:25:47 -08002608 const ssize_t index = mCurrentState.displays.indexOfKey(it->second);
Dominik Laskowski075d3172018-05-24 15:50:06 -07002609 if (index >= 0) {
2610 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
2611 mInterceptor->saveDisplayDeletion(state.sequenceId);
2612 mCurrentState.displays.removeItemsAt(index);
Lloyd Piquefcd86612017-12-14 17:15:36 -08002613 }
Dominik Laskowski55c85402020-01-21 16:25:47 -08002614 mPhysicalDisplayTokens.erase(it);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002615 }
2616
2617 processDisplayChangesLocked();
2618 }
2619
2620 mPendingHotplugEvents.clear();
2621}
2622
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002623void SurfaceFlinger::dispatchDisplayHotplugEvent(PhysicalDisplayId displayId, bool connected) {
Marin Shalamanov9cf9e512020-12-02 13:28:06 +01002624 ALOGI("Dispatching display hotplug event displayId=%s, connected=%d",
2625 to_string(displayId).c_str(), connected);
Dominik Laskowski98041832019-08-01 18:35:59 -07002626 mScheduler->onHotplugReceived(mAppConnectionHandle, displayId, connected);
2627 mScheduler->onHotplugReceived(mSfConnectionHandle, displayId, connected);
Dominik Laskowski1eba0202019-01-24 09:14:40 -08002628}
2629
Lloyd Pique99d3da52018-01-22 17:48:03 -08002630sp<DisplayDevice> SurfaceFlinger::setupNewDisplayDeviceInternal(
Lloyd Pique9370a482019-10-03 17:58:30 -07002631 const wp<IBinder>& displayToken,
2632 std::shared_ptr<compositionengine::Display> compositionDisplay,
Marin Shalamanovae685592020-02-12 17:12:22 +01002633 const DisplayDeviceState& state,
2634 const sp<compositionengine::DisplaySurface>& displaySurface,
Dominik Laskowski075d3172018-05-24 15:50:06 -07002635 const sp<IGraphicBufferProducer>& producer) {
Marin Shalamanov12c9e5a2021-01-07 00:25:35 +01002636 DisplayDeviceCreationArgs creationArgs(this, getHwComposer(), displayToken, compositionDisplay);
Dominik Laskowskie9774092018-12-11 10:04:24 -08002637 creationArgs.sequenceId = state.sequenceId;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002638 creationArgs.isSecure = state.isSecure;
Marin Shalamanovae685592020-02-12 17:12:22 +01002639 creationArgs.displaySurface = displaySurface;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002640 creationArgs.hasWideColorGamut = false;
2641 creationArgs.supportedPerFrameMetadata = 0;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002642
Dominik Laskowski55c85402020-01-21 16:25:47 -08002643 if (const auto& physical = state.physical) {
2644 creationArgs.connectionType = physical->type;
Marin Shalamanova903d032020-12-29 20:35:13 +01002645 creationArgs.supportedModes = physical->supportedModes;
Ady Abraham3efa3942021-06-24 19:01:25 -07002646 creationArgs.activeModeId = physical->activeMode->getId();
2647 scheduler::RefreshRateConfigs::Config config =
2648 {.enableFrameRateOverride = android::sysprop::enable_frame_rate_override(false),
2649 .frameRateMultipleThreshold =
2650 base::GetIntProperty("debug.sf.frame_rate_multiple_threshold", 0)};
2651 creationArgs.refreshRateConfigs =
2652 std::make_shared<scheduler::RefreshRateConfigs>(creationArgs.supportedModes,
2653 creationArgs.activeModeId, config);
Dominik Laskowski55c85402020-01-21 16:25:47 -08002654 }
2655
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02002656 if (const auto id = PhysicalDisplayId::tryCast(compositionDisplay->getId())) {
2657 creationArgs.isPrimary = id == getInternalDisplayIdLocked();
Dominik Laskowski075d3172018-05-24 15:50:06 -07002658
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02002659 if (useColorManagement) {
2660 std::vector<ColorMode> modes = getHwComposer().getColorModes(*id);
2661 for (ColorMode colorMode : modes) {
2662 if (isWideColorMode(colorMode)) {
2663 creationArgs.hasWideColorGamut = true;
2664 }
2665
2666 std::vector<RenderIntent> renderIntents =
2667 getHwComposer().getRenderIntents(*id, colorMode);
2668 creationArgs.hwcColorModes.emplace(colorMode, renderIntents);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002669 }
2670 }
tangrobin6753a022018-08-10 10:58:54 +08002671 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002672
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02002673 if (const auto id = HalDisplayId::tryCast(compositionDisplay->getId())) {
2674 getHwComposer().getHdrCapabilities(*id, &creationArgs.hdrCapabilities);
2675 creationArgs.supportedPerFrameMetadata = getHwComposer().getSupportedPerFrameMetadata(*id);
Chia-I Wu0f509fb2018-06-21 15:52:50 +08002676 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002677
Lloyd Pique90c115d2018-09-18 21:39:42 -07002678 auto nativeWindowSurface = getFactory().createNativeWindowSurface(producer);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002679 auto nativeWindow = nativeWindowSurface->getNativeWindow();
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002680 creationArgs.nativeWindow = nativeWindow;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002681
Lloyd Pique99d3da52018-01-22 17:48:03 -08002682 // Make sure that composition can never be stalled by a virtual display
2683 // consumer that isn't processing buffers fast enough. We have to do this
Alec Mouri0a9c7b82018-11-16 13:05:25 -08002684 // here, in case the display is composed entirely by HWC.
Dominik Laskowski281644e2018-04-19 15:47:35 -07002685 if (state.isVirtual()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002686 nativeWindow->setSwapInterval(nativeWindow.get(), 0);
2687 }
2688
Dominik Laskowski718f9602019-11-09 20:01:35 -08002689 creationArgs.physicalOrientation =
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02002690 creationArgs.isPrimary ? internalDisplayOrientation : ui::ROTATION_0;
Chia-I Wua02871c2018-08-27 14:38:23 -07002691
Lloyd Pique99d3da52018-01-22 17:48:03 -08002692 // virtual displays are always considered enabled
Peiyong Lin65248e02020-04-18 21:15:07 -07002693 creationArgs.initialPowerMode = state.isVirtual() ? hal::PowerMode::ON : hal::PowerMode::OFF;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002694
Lloyd Pique9370a482019-10-03 17:58:30 -07002695 sp<DisplayDevice> display = getFactory().createDisplayDevice(creationArgs);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002696
Ady Abraham8565ad22021-06-22 17:45:44 -07002697 nativeWindowSurface->preallocateBuffers();
Lloyd Pique99d3da52018-01-22 17:48:03 -08002698
2699 ColorMode defaultColorMode = ColorMode::NATIVE;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002700 Dataspace defaultDataSpace = Dataspace::UNKNOWN;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002701 if (display->hasWideColorGamut()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002702 defaultColorMode = ColorMode::SRGB;
Peiyong Lin14724e62018-12-05 07:27:30 -08002703 defaultDataSpace = Dataspace::V0_SRGB;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002704 }
Lloyd Pique6a3b4462019-03-07 20:58:12 -08002705 display->getCompositionDisplay()->setColorProfile(
2706 compositionengine::Output::ColorProfile{defaultColorMode, defaultDataSpace,
2707 RenderIntent::COLORIMETRIC,
2708 Dataspace::UNKNOWN});
Dominik Laskowski075d3172018-05-24 15:50:06 -07002709 if (!state.isVirtual()) {
Ady Abrahamb4937392021-06-23 18:05:03 -07002710 MAIN_THREAD_GUARD(display->setActiveMode(state.physical->activeMode->getId()));
Marin Shalamanov7ce87642020-05-06 13:45:58 +02002711 display->setDeviceProductInfo(state.physical->deviceProductInfo);
Lloyd Pique3c085a02018-05-09 19:38:32 -07002712 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07002713
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002714 display->setLayerStack(state.layerStack);
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02002715 display->setProjection(state.orientation, state.layerStackSpaceRect,
2716 state.orientedDisplaySpaceRect);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002717 display->setDisplayName(state.displayName);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002718
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002719 return display;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002720}
2721
Marin Shalamanovae685592020-02-12 17:12:22 +01002722void SurfaceFlinger::processDisplayAdded(const wp<IBinder>& displayToken,
2723 const DisplayDeviceState& state) {
Marin Shalamanov045b7002021-01-07 16:56:24 +01002724 ui::Size resolution(0, 0);
Marin Shalamanovae685592020-02-12 17:12:22 +01002725 ui::PixelFormat pixelFormat = static_cast<ui::PixelFormat>(PIXEL_FORMAT_UNKNOWN);
2726 if (state.physical) {
Marin Shalamanov045b7002021-01-07 16:56:24 +01002727 resolution = state.physical->activeMode->getSize();
Marin Shalamanovae685592020-02-12 17:12:22 +01002728 pixelFormat = static_cast<ui::PixelFormat>(PIXEL_FORMAT_RGBA_8888);
2729 } else if (state.surface != nullptr) {
Marin Shalamanov045b7002021-01-07 16:56:24 +01002730 int status = state.surface->query(NATIVE_WINDOW_WIDTH, &resolution.width);
Marin Shalamanovae685592020-02-12 17:12:22 +01002731 ALOGE_IF(status != NO_ERROR, "Unable to query width (%d)", status);
Marin Shalamanov045b7002021-01-07 16:56:24 +01002732 status = state.surface->query(NATIVE_WINDOW_HEIGHT, &resolution.height);
Marin Shalamanovae685592020-02-12 17:12:22 +01002733 ALOGE_IF(status != NO_ERROR, "Unable to query height (%d)", status);
Dominik Laskowski13948602021-03-08 20:48:28 -08002734 int format;
2735 status = state.surface->query(NATIVE_WINDOW_FORMAT, &format);
Marin Shalamanovae685592020-02-12 17:12:22 +01002736 ALOGE_IF(status != NO_ERROR, "Unable to query format (%d)", status);
Dominik Laskowski13948602021-03-08 20:48:28 -08002737 pixelFormat = static_cast<ui::PixelFormat>(format);
Marin Shalamanovae685592020-02-12 17:12:22 +01002738 } else {
2739 // Virtual displays without a surface are dormant:
2740 // they have external state (layer stack, projection,
2741 // etc.) but no internal state (i.e. a DisplayDevice).
2742 return;
2743 }
2744
2745 compositionengine::DisplayCreationArgsBuilder builder;
2746 if (const auto& physical = state.physical) {
Dominik Laskowski13948602021-03-08 20:48:28 -08002747 builder.setId(physical->id);
2748 builder.setConnectionType(physical->type);
2749 } else {
Dominik Laskowski263eec42021-07-21 23:13:24 -07002750 builder.setId(acquireVirtualDisplay(resolution, pixelFormat));
Marin Shalamanovae685592020-02-12 17:12:22 +01002751 }
Dominik Laskowski13948602021-03-08 20:48:28 -08002752
Marin Shalamanov045b7002021-01-07 16:56:24 +01002753 builder.setPixels(resolution);
Marin Shalamanovae685592020-02-12 17:12:22 +01002754 builder.setIsSecure(state.isSecure);
2755 builder.setLayerStackId(state.layerStack);
2756 builder.setPowerAdvisor(&mPowerAdvisor);
Marin Shalamanovae685592020-02-12 17:12:22 +01002757 builder.setName(state.displayName);
Dominik Laskowski13948602021-03-08 20:48:28 -08002758 auto compositionDisplay = getCompositionEngine().createDisplay(builder.build());
Alec Mouri023c1882021-05-08 16:36:33 -07002759 compositionDisplay->setLayerCachingEnabled(mLayerCachingEnabled);
Marin Shalamanovae685592020-02-12 17:12:22 +01002760
2761 sp<compositionengine::DisplaySurface> displaySurface;
2762 sp<IGraphicBufferProducer> producer;
2763 sp<IGraphicBufferProducer> bqProducer;
2764 sp<IGraphicBufferConsumer> bqConsumer;
2765 getFactory().createBufferQueue(&bqProducer, &bqConsumer, /*consumerIsSurfaceFlinger =*/false);
2766
Marin Shalamanovae685592020-02-12 17:12:22 +01002767 if (state.isVirtual()) {
Dominik Laskowski13948602021-03-08 20:48:28 -08002768 const auto displayId = VirtualDisplayId::tryCast(compositionDisplay->getId());
2769 LOG_FATAL_IF(!displayId);
2770 auto surface = sp<VirtualDisplaySurface>::make(getHwComposer(), *displayId, state.surface,
2771 bqProducer, bqConsumer, state.displayName);
2772 displaySurface = surface;
2773 producer = std::move(surface);
Marin Shalamanovae685592020-02-12 17:12:22 +01002774 } else {
2775 ALOGE_IF(state.surface != nullptr,
2776 "adding a supported display, but rendering "
2777 "surface is provided (%p), ignoring it",
2778 state.surface.get());
Dominik Laskowski13948602021-03-08 20:48:28 -08002779 const auto displayId = PhysicalDisplayId::tryCast(compositionDisplay->getId());
2780 LOG_FATAL_IF(!displayId);
2781 displaySurface =
2782 sp<FramebufferSurface>::make(getHwComposer(), *displayId, bqConsumer,
2783 state.physical->activeMode->getSize(),
2784 ui::Size(maxGraphicsWidth, maxGraphicsHeight));
Marin Shalamanovae685592020-02-12 17:12:22 +01002785 producer = bqProducer;
2786 }
2787
Marin Shalamanov700e6392020-02-12 20:22:26 +01002788 LOG_FATAL_IF(!displaySurface);
Dominik Laskowski13948602021-03-08 20:48:28 -08002789 const auto display = setupNewDisplayDeviceInternal(displayToken, std::move(compositionDisplay),
2790 state, displaySurface, producer);
Marin Shalamanov700e6392020-02-12 20:22:26 +01002791 mDisplays.emplace(displayToken, display);
Ady Abraham3efa3942021-06-24 19:01:25 -07002792 if (display->isPrimary()) {
2793 initScheduler(display);
2794 }
Marin Shalamanov700e6392020-02-12 20:22:26 +01002795 if (!state.isVirtual()) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02002796 dispatchDisplayHotplugEvent(display->getPhysicalId(), true);
Marin Shalamanov700e6392020-02-12 20:22:26 +01002797 }
Marin Shalamanovae685592020-02-12 17:12:22 +01002798}
2799
2800void SurfaceFlinger::processDisplayRemoved(const wp<IBinder>& displayToken) {
Vishnu Nairf78589c2020-12-02 18:36:03 -08002801 auto display = getDisplayDeviceLocked(displayToken);
2802 if (display) {
Marin Shalamanovae685592020-02-12 17:12:22 +01002803 display->disconnect();
Dominik Laskowski13948602021-03-08 20:48:28 -08002804
2805 if (display->isVirtual()) {
2806 releaseVirtualDisplay(display->getVirtualId());
2807 } else {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02002808 dispatchDisplayHotplugEvent(display->getPhysicalId(), false);
Marin Shalamanovae685592020-02-12 17:12:22 +01002809 }
2810 }
2811
2812 mDisplays.erase(displayToken);
Vishnu Nairf78589c2020-12-02 18:36:03 -08002813
2814 if (display && display->isVirtual()) {
2815 static_cast<void>(schedule([display = std::move(display)] {
2816 // Destroy the display without holding the mStateLock.
2817 // This is a temporary solution until we can manage transaction queues without
2818 // holding the mStateLock.
2819 // With blast, the IGBP that is passed to the VirtualDisplaySurface is owned by the
2820 // client. When the IGBP is disconnected, its buffer cache in SF will be cleared
2821 // via SurfaceComposerClient::doUncacheBufferTransaction. This call from the client
2822 // ends up running on the main thread causing a deadlock since setTransactionstate
2823 // will try to acquire the mStateLock. Instead we extend the lifetime of
2824 // DisplayDevice and destroy it in the main thread without holding the mStateLock.
2825 // The display will be disconnected and removed from the mDisplays list so it will
2826 // not be accessible.
2827 }));
2828 }
Marin Shalamanovae685592020-02-12 17:12:22 +01002829}
2830
2831void SurfaceFlinger::processDisplayChanged(const wp<IBinder>& displayToken,
2832 const DisplayDeviceState& currentState,
2833 const DisplayDeviceState& drawingState) {
2834 const sp<IBinder> currentBinder = IInterface::asBinder(currentState.surface);
2835 const sp<IBinder> drawingBinder = IInterface::asBinder(drawingState.surface);
Dominik Laskowski13948602021-03-08 20:48:28 -08002836
2837 // Recreate the DisplayDevice if the surface or sequence ID changed.
Marin Shalamanov700e6392020-02-12 20:22:26 +01002838 if (currentBinder != drawingBinder || currentState.sequenceId != drawingState.sequenceId) {
Marin Shalamanov23c31af2020-09-09 15:01:47 +02002839 getRenderEngine().cleanFramebufferCache();
Dominik Laskowski13948602021-03-08 20:48:28 -08002840
Marin Shalamanovae685592020-02-12 17:12:22 +01002841 if (const auto display = getDisplayDeviceLocked(displayToken)) {
2842 display->disconnect();
Dominik Laskowski13948602021-03-08 20:48:28 -08002843 if (display->isVirtual()) {
2844 releaseVirtualDisplay(display->getVirtualId());
2845 }
Marin Shalamanovae685592020-02-12 17:12:22 +01002846 }
Dominik Laskowski13948602021-03-08 20:48:28 -08002847
Marin Shalamanovae685592020-02-12 17:12:22 +01002848 mDisplays.erase(displayToken);
Dominik Laskowski13948602021-03-08 20:48:28 -08002849
Marin Shalamanov700e6392020-02-12 20:22:26 +01002850 if (const auto& physical = currentState.physical) {
2851 getHwComposer().allocatePhysicalDisplay(physical->hwcDisplayId, physical->id);
2852 }
Dominik Laskowski13948602021-03-08 20:48:28 -08002853
Marin Shalamanovae685592020-02-12 17:12:22 +01002854 processDisplayAdded(displayToken, currentState);
Dominik Laskowski13948602021-03-08 20:48:28 -08002855
Marin Shalamanov700e6392020-02-12 20:22:26 +01002856 if (currentState.physical) {
Marin Shalamanov4c5e3012020-06-04 21:41:42 +02002857 const auto display = getDisplayDeviceLocked(displayToken);
2858 setPowerModeInternal(display, hal::PowerMode::ON);
Marin Shalamanovf7f6b3c2020-12-09 13:19:38 +01002859
2860 // TODO(b/175678251) Call a listener instead.
Marin Shalamanov526c3382020-12-10 15:22:29 +01002861 if (currentState.physical->hwcDisplayId == getHwComposer().getInternalHwcDisplayId()) {
Ady Abraham3efa3942021-06-24 19:01:25 -07002862 updateInternalDisplayVsyncLocked(display);
Marin Shalamanovf7f6b3c2020-12-09 13:19:38 +01002863 }
Marin Shalamanov700e6392020-02-12 20:22:26 +01002864 }
Marin Shalamanovae685592020-02-12 17:12:22 +01002865 return;
2866 }
2867
2868 if (const auto display = getDisplayDeviceLocked(displayToken)) {
2869 if (currentState.layerStack != drawingState.layerStack) {
2870 display->setLayerStack(currentState.layerStack);
2871 }
Evan Rosky2239b372021-05-20 13:43:47 -07002872 if (currentState.flags != drawingState.flags) {
2873 display->setFlags(currentState.flags);
2874 }
Marin Shalamanovae685592020-02-12 17:12:22 +01002875 if ((currentState.orientation != drawingState.orientation) ||
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02002876 (currentState.layerStackSpaceRect != drawingState.layerStackSpaceRect) ||
2877 (currentState.orientedDisplaySpaceRect != drawingState.orientedDisplaySpaceRect)) {
2878 display->setProjection(currentState.orientation, currentState.layerStackSpaceRect,
2879 currentState.orientedDisplaySpaceRect);
Arthur Hungb6aa9a02021-06-09 14:23:01 +08002880 if (display->isPrimary()) {
2881 mDefaultDisplayTransformHint = display->getTransformHint();
2882 }
Marin Shalamanovae685592020-02-12 17:12:22 +01002883 }
2884 if (currentState.width != drawingState.width ||
2885 currentState.height != drawingState.height) {
2886 display->setDisplaySize(currentState.width, currentState.height);
Dominik Laskowski20134642020-04-20 22:36:44 -07002887
Ady Abraham7825c682021-05-17 15:12:14 -07002888 if (isDisplayActiveLocked(display)) {
2889 onActiveDisplaySizeChanged(display);
Marin Shalamanovae685592020-02-12 17:12:22 +01002890 }
2891 }
2892 }
2893}
Ady Abraham3efa3942021-06-24 19:01:25 -07002894void SurfaceFlinger::updateInternalDisplayVsyncLocked(const sp<DisplayDevice>& activeDisplay) {
Ady Abraham7825c682021-05-17 15:12:14 -07002895 mVsyncConfiguration->reset();
Ady Abraham3efa3942021-06-24 19:01:25 -07002896 const Fps refreshRate = activeDisplay->refreshRateConfigs().getCurrentRefreshRate().getFps();
Ady Abraham7825c682021-05-17 15:12:14 -07002897 updatePhaseConfiguration(refreshRate);
2898 mRefreshRateStats->setRefreshRate(refreshRate);
Ady Abraham7825c682021-05-17 15:12:14 -07002899}
Marin Shalamanovae685592020-02-12 17:12:22 +01002900
Lloyd Pique347200f2017-12-14 17:00:15 -08002901void SurfaceFlinger::processDisplayChangesLocked() {
2902 // here we take advantage of Vector's copy-on-write semantics to
2903 // improve performance by skipping the transaction entirely when
2904 // know that the lists are identical
2905 const KeyedVector<wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
2906 const KeyedVector<wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
2907 if (!curr.isIdenticalTo(draw)) {
2908 mVisibleRegionsDirty = true;
Lloyd Pique347200f2017-12-14 17:00:15 -08002909
2910 // find the displays that were removed
2911 // (ie: in drawing state but not in current state)
2912 // also handle displays that changed
2913 // (ie: displays that are in both lists)
Marin Shalamanovae685592020-02-12 17:12:22 +01002914 for (size_t i = 0; i < draw.size(); i++) {
2915 const wp<IBinder>& displayToken = draw.keyAt(i);
2916 const ssize_t j = curr.indexOfKey(displayToken);
Lloyd Pique347200f2017-12-14 17:00:15 -08002917 if (j < 0) {
2918 // in drawing state but not in current state
Marin Shalamanovae685592020-02-12 17:12:22 +01002919 processDisplayRemoved(displayToken);
Lloyd Pique347200f2017-12-14 17:00:15 -08002920 } else {
2921 // this display is in both lists. see if something changed.
Marin Shalamanovae685592020-02-12 17:12:22 +01002922 const DisplayDeviceState& currentState = curr[j];
2923 const DisplayDeviceState& drawingState = draw[i];
2924 processDisplayChanged(displayToken, currentState, drawingState);
Lloyd Pique347200f2017-12-14 17:00:15 -08002925 }
Lloyd Pique347200f2017-12-14 17:00:15 -08002926 }
2927
2928 // find displays that were added
2929 // (ie: in current state but not in drawing state)
Marin Shalamanovae685592020-02-12 17:12:22 +01002930 for (size_t i = 0; i < curr.size(); i++) {
2931 const wp<IBinder>& displayToken = curr.keyAt(i);
2932 if (draw.indexOfKey(displayToken) < 0) {
2933 processDisplayAdded(displayToken, curr[i]);
Lloyd Pique347200f2017-12-14 17:00:15 -08002934 }
2935 }
2936 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08002937
2938 mDrawingState.displays = mCurrentState.displays;
Lloyd Pique347200f2017-12-14 17:00:15 -08002939}
2940
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01002941void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags) {
Vishnu Nair6bdec7d2021-05-10 15:01:13 -07002942 // Commit display transactions
2943 const bool displayTransactionNeeded = transactionFlags & eDisplayTransactionNeeded;
2944 if (displayTransactionNeeded) {
2945 processDisplayChangesLocked();
2946 processDisplayHotplugEventsLocked();
2947 }
Robert Carrb552ff52021-06-11 13:35:54 -07002948 mForceTraversal = false;
2949 mForceTransactionDisplayChange = displayTransactionNeeded;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002950
Robert Carre450fb52021-06-11 13:21:09 -07002951 if (mSomeChildrenChanged) {
2952 mVisibleRegionsDirty = true;
2953 mSomeChildrenChanged = false;
2954 }
2955
Vishnu Nair6bdec7d2021-05-10 15:01:13 -07002956 // Update transform hint
Vishnu Nair6213bd92020-05-08 17:42:25 -07002957 if (transactionFlags & (eTransformHintUpdateNeeded | eDisplayTransactionNeeded)) {
Mathias Agopian84300952012-11-21 16:02:13 -08002958 // The transform hint might have changed for some layers
2959 // (either because a display has changed, or because a layer
2960 // as changed).
2961 //
2962 // Walk through all the layers in currentLayers,
2963 // and update their transform hint.
2964 //
2965 // If a layer is visible only on a single display, then that
2966 // display is used to calculate the hint, otherwise we use the
2967 // default display.
2968 //
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002969 // NOTE: we do this here, rather than when presenting the display so that
Mathias Agopian84300952012-11-21 16:02:13 -08002970 // the hint is set before we acquire a buffer from the surface texture.
2971 //
2972 // NOTE: layer transactions have taken place already, so we use their
2973 // drawing state. However, SurfaceFlinger's own transaction has not
2974 // happened yet, so we must use the current state layer list
2975 // (soon to become the drawing state list).
2976 //
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002977 sp<const DisplayDevice> hintDisplay;
Mathias Agopian84300952012-11-21 16:02:13 -08002978 uint32_t currentlayerStack = 0;
Robert Carr2047fae2016-11-28 14:09:09 -08002979 bool first = true;
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07002980 mCurrentState.traverse([&](Layer* layer) REQUIRES(mStateLock) {
Mathias Agopian84300952012-11-21 16:02:13 -08002981 // NOTE: we rely on the fact that layers are sorted by
2982 // layerStack first (so we don't have to traverse the list
2983 // of displays for every layer).
Robert Carr1f0a16a2016-10-24 16:27:39 -07002984 uint32_t layerStack = layer->getLayerStack();
Robert Carr2047fae2016-11-28 14:09:09 -08002985 if (first || currentlayerStack != layerStack) {
Mathias Agopian84300952012-11-21 16:02:13 -08002986 currentlayerStack = layerStack;
2987 // figure out if this layerstack is mirrored
2988 // (more than one display) if so, pick the default display,
2989 // if not, pick the only display it's on.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002990 hintDisplay = nullptr;
2991 for (const auto& [token, display] : mDisplays) {
Lloyd Piqueef36b002019-01-23 17:52:04 -08002992 if (display->getCompositionDisplay()
2993 ->belongsInOutput(layer->getLayerStack(),
2994 layer->getPrimaryDisplayOnly())) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002995 if (hintDisplay) {
2996 hintDisplay = nullptr;
Mathias Agopian84300952012-11-21 16:02:13 -08002997 break;
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002998 } else {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002999 hintDisplay = display;
Mathias Agopian84300952012-11-21 16:02:13 -08003000 }
3001 }
3002 }
3003 }
Chet Haase91d25932013-04-11 15:24:55 -07003004
Dominik Laskowski9fae1022018-05-29 13:17:40 -07003005 if (!hintDisplay) {
Lloyd Piqued432a7c2018-03-23 16:05:31 -07003006 // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
3007 // redraw after transform hint changes. See bug 8508397.
Robert Carr56a0b9a2017-12-04 16:06:13 -08003008
Lloyd Piqued432a7c2018-03-23 16:05:31 -07003009 // could be null when this layer is using a layerStack
3010 // that is not visible on any display. Also can occur at
3011 // screen off/on times.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07003012 hintDisplay = getDefaultDisplayDeviceLocked();
Mathias Agopian84300952012-11-21 16:02:13 -08003013 }
Lloyd Piqued432a7c2018-03-23 16:05:31 -07003014
Dominik Laskowski9fae1022018-05-29 13:17:40 -07003015 // could be null if there is no display available at all to get
Lloyd Piqued432a7c2018-03-23 16:05:31 -07003016 // the transform hint from.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07003017 if (hintDisplay) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -07003018 layer->updateTransformHint(hintDisplay->getTransformHint());
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08003019 }
Robert Carr2047fae2016-11-28 14:09:09 -08003020
3021 first = false;
3022 });
Mathias Agopian84300952012-11-21 16:02:13 -08003023 }
3024
Mathias Agopian3559b072012-08-15 13:46:03 -07003025 /*
3026 * Perform our own transaction if needed
3027 */
Robert Carr1f0a16a2016-10-24 16:27:39 -07003028
3029 if (mLayersAdded) {
3030 mLayersAdded = false;
3031 // Layers have been added.
Mathias Agopian3559b072012-08-15 13:46:03 -07003032 mVisibleRegionsDirty = true;
3033 }
3034
3035 // some layers might have been removed, so
3036 // we need to update the regions they're exposing.
3037 if (mLayersRemoved) {
3038 mLayersRemoved = false;
3039 mVisibleRegionsDirty = true;
Robert Carr2047fae2016-11-28 14:09:09 -08003040 mDrawingState.traverseInZOrder([&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003041 if (mLayersPendingRemoval.indexOf(layer) >= 0) {
Mathias Agopian3559b072012-08-15 13:46:03 -07003042 // this layer is not visible anymore
Robert Carr1f0a16a2016-10-24 16:27:39 -07003043 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08003044 visibleReg.set(layer->getScreenBounds());
Chia-I Wuab0c3192017-08-01 11:29:00 -07003045 invalidateLayerStack(layer, visibleReg);
Mathias Agopian0aa758d2009-04-22 15:23:34 -07003046 }
Robert Carr2047fae2016-11-28 14:09:09 -08003047 });
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003048 }
3049
3050 commitTransaction();
Riley Andrews03414a12014-07-01 14:22:59 -07003051}
3052
Vishnu Nair6194e2e2019-02-06 12:58:39 -08003053void SurfaceFlinger::updateInputFlinger() {
Robert Carr720e5062018-07-30 17:45:14 -07003054 ATRACE_CALL();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08003055 if (!mInputFlinger) {
Vishnu Nairde19f852018-12-18 16:11:53 -08003056 return;
3057 }
3058
Vishnu Nair6194e2e2019-02-06 12:58:39 -08003059 if (mVisibleRegionsDirty || mInputInfoChanged) {
3060 mInputInfoChanged = false;
3061 updateInputWindowInfo();
chaviw95ef3c42019-02-14 10:55:09 -08003062 } else if (mInputWindowCommands.syncInputWindows) {
3063 // If the caller requested to sync input windows, but there are no
3064 // changes to input windows, notify immediately.
3065 setInputWindowsFinished();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08003066 }
3067
Vishnu Nair958da932020-08-21 17:12:37 -07003068 for (const auto& focusRequest : mInputWindowCommands.focusRequests) {
3069 mInputFlinger->setFocusedWindow(focusRequest);
3070 }
Arthur Hung6cbb9752019-09-05 16:38:18 +08003071 mInputWindowCommands.clear();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08003072}
3073
[1;3C2b9fc252021-02-04 16:16:50 -08003074bool enablePerWindowInputRotation() {
3075 static bool value =
3076 android::base::GetBoolProperty("persist.debug.per_window_input_rotation", false);
3077 return value;
3078}
3079
Vishnu Nair6194e2e2019-02-06 12:58:39 -08003080void SurfaceFlinger::updateInputWindowInfo() {
chaviw3277faf2021-05-19 16:45:23 -05003081 std::vector<WindowInfo> inputInfos;
Robert Carr720e5062018-07-30 17:45:14 -07003082
3083 mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
[1;3C2b9fc252021-02-04 16:16:50 -08003084 if (!layer->needsInputInfo()) return;
Evan Rosky2239b372021-05-20 13:43:47 -07003085 sp<DisplayDevice> display = enablePerWindowInputRotation()
3086 ? ON_MAIN_THREAD(getDisplayWithInputByLayer(layer))
3087 : nullptr;
[1;3C2b9fc252021-02-04 16:16:50 -08003088 // When calculating the screen bounds we ignore the transparent region since it may
3089 // result in an unwanted offset.
3090 inputInfos.push_back(layer->fillInputInfo(display));
Robert Carr720e5062018-07-30 17:45:14 -07003091 });
chaviw291d88a2019-02-14 10:33:58 -08003092
Chris Ye0783e992020-06-02 21:34:49 -07003093 mInputFlinger->setInputWindows(inputInfos,
3094 mInputWindowCommands.syncInputWindows ? mSetInputWindowsListener
3095 : nullptr);
Robert Carr720e5062018-07-30 17:45:14 -07003096}
3097
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07003098void SurfaceFlinger::updateCursorAsync() {
Lloyd Piquec7b0c752019-03-07 20:59:59 -08003099 compositionengine::CompositionRefreshArgs refreshArgs;
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07003100 for (const auto& [_, display] : ON_MAIN_THREAD(mDisplays)) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02003101 if (HalDisplayId::tryCast(display->getId())) {
Lloyd Piquec7b0c752019-03-07 20:59:59 -08003102 refreshArgs.outputs.push_back(display->getCompositionDisplay());
Riley Andrews03414a12014-07-01 14:22:59 -07003103 }
3104 }
Lloyd Piquec7b0c752019-03-07 20:59:59 -08003105
3106 mCompositionEngine->updateCursorAsync(refreshArgs);
Mathias Agopian4fec8732012-06-29 14:12:52 -07003107}
3108
Marin Shalamanova7fe3042021-01-29 21:02:08 +01003109void SurfaceFlinger::changeRefreshRate(const RefreshRate& refreshRate, Scheduler::ModeEvent event) {
Ady Abraham8a82ba62020-01-17 12:43:17 -08003110 // If this is called from the main thread mStateLock must be locked before
3111 // Currently the only way to call this function from the main thread is from
Ady Abraham62a0be22020-12-08 16:54:10 -08003112 // Scheduler::chooseRefreshRateForContent
Ady Abraham8a82ba62020-01-17 12:43:17 -08003113
3114 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
Ady Abraham2139f732019-11-13 18:56:40 -08003115 changeRefreshRateLocked(refreshRate, event);
3116}
3117
Ady Abraham62a0be22020-12-08 16:54:10 -08003118void SurfaceFlinger::triggerOnFrameRateOverridesChanged() {
3119 PhysicalDisplayId displayId = [&]() {
3120 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
3121 return getDefaultDisplayDeviceLocked()->getPhysicalId();
3122 }();
3123
3124 mScheduler->onFrameRateOverridesChanged(mAppConnectionHandle, displayId);
3125}
3126
Ady Abraham3efa3942021-06-24 19:01:25 -07003127void SurfaceFlinger::initScheduler(const sp<DisplayDevice>& display) {
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003128 if (mScheduler) {
Ady Abrahamac2bf482021-07-20 10:59:51 -07003129 // If the scheduler is already initialized, this means that we received
3130 // a hotplug(connected) on the primary display. In that case we should
3131 // update the scheduler with the most recent display information.
3132 ALOGW("Scheduler already initialized, updating instead");
3133 mScheduler->setRefreshRateConfigs(display->holdRefreshRateConfigs());
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003134 return;
3135 }
Ady Abraham3efa3942021-06-24 19:01:25 -07003136 const auto currRefreshRate = display->getActiveMode()->getFps();
Marin Shalamanova903d032020-12-29 20:35:13 +01003137 mRefreshRateStats = std::make_unique<scheduler::RefreshRateStats>(*mTimeStats, currRefreshRate,
3138 hal::PowerMode::OFF);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003139
Marin Shalamanova903d032020-12-29 20:35:13 +01003140 mVsyncConfiguration = getFactory().createVsyncConfiguration(currRefreshRate);
Ady Abraham23ea9da2021-07-14 16:32:56 -07003141 mVsyncModulator = sp<VsyncModulator>::make(mVsyncConfiguration->getCurrentConfigs());
Ady Abraham9e16a482019-12-03 17:19:41 -08003142
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003143 // start the EventThread
Ady Abraham3efa3942021-06-24 19:01:25 -07003144 mScheduler = getFactory().createScheduler(display->holdRefreshRateConfigs(), *this);
Ady Abraham9c53ee72020-07-22 21:16:18 -07003145 const auto configs = mVsyncConfiguration->getCurrentConfigs();
Marin Shalamanova903d032020-12-29 20:35:13 +01003146 const nsecs_t vsyncPeriod = currRefreshRate.getPeriodNsecs();
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003147 mAppConnectionHandle =
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -07003148 mScheduler->createConnection("app", mFrameTimeline->getTokenManager(),
Ady Abraham9c53ee72020-07-22 21:16:18 -07003149 /*workDuration=*/configs.late.appWorkDuration,
3150 /*readyDuration=*/configs.late.sfWorkDuration,
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003151 impl::EventThread::InterceptVSyncsCallback());
3152 mSfConnectionHandle =
Ady Abraham55fa7272020-09-30 19:19:27 -07003153 mScheduler->createConnection("appSf", mFrameTimeline->getTokenManager(),
3154 /*workDuration=*/std::chrono::nanoseconds(vsyncPeriod),
3155 /*readyDuration=*/configs.late.sfWorkDuration,
3156 [this](nsecs_t timestamp) {
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003157 mInterceptor->saveVSyncEvent(timestamp);
3158 });
3159
Ady Abraham55fa7272020-09-30 19:19:27 -07003160 mEventQueue->initVsync(mScheduler->getVsyncDispatch(), *mFrameTimeline->getTokenManager(),
3161 configs.late.sfWorkDuration);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003162
3163 mRegionSamplingThread =
Ady Abraham562c2712021-05-07 15:10:42 -07003164 new RegionSamplingThread(*this, RegionSamplingThread::EnvironmentTimingTunables());
Alec Mouria9a68a62021-03-04 19:14:50 -08003165 mFpsReporter = new FpsReporter(*mFrameTimeline, *this);
Marin Shalamanova7fe3042021-01-29 21:02:08 +01003166 // Dispatch a mode change request for the primary display on scheduler
Alec Mouri60aee1c2019-10-28 16:18:59 -07003167 // initialization, so that the EventThreads always contain a reference to a
3168 // prior configuration.
3169 //
3170 // This is a bit hacky, but this avoids a back-pointer into the main SF
3171 // classes from EventThread, and there should be no run-time binder cost
3172 // anyway since there are no connected apps at this point.
Ady Abrahamb4937392021-06-23 18:05:03 -07003173 mScheduler->onPrimaryDisplayModeChanged(mAppConnectionHandle, display->getActiveMode());
Ady Abrahamce139ad2020-08-07 17:23:16 -07003174 static auto ignorePresentFences =
3175 base::GetBoolProperty("debug.sf.vsync_reactor_ignore_present_fences"s, false);
3176 mScheduler->setIgnorePresentFences(
3177 ignorePresentFences ||
3178 getHwComposer().hasCapability(hal::Capability::PRESENT_FENCE_IS_NOT_RELIABLE));
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003179}
3180
Marin Shalamanov5801c942020-12-17 17:00:13 +01003181void SurfaceFlinger::updatePhaseConfiguration(const Fps& refreshRate) {
3182 mVsyncConfiguration->setRefreshRateFps(refreshRate);
Ady Abraham55fa7272020-09-30 19:19:27 -07003183 setVsyncConfig(mVsyncModulator->setVsyncConfigSet(mVsyncConfiguration->getCurrentConfigs()),
Marin Shalamanov5801c942020-12-17 17:00:13 +01003184 refreshRate.getPeriodNsecs());
Dominik Laskowski08d05c22020-07-22 00:05:08 -07003185}
3186
Ady Abraham55fa7272020-09-30 19:19:27 -07003187void SurfaceFlinger::setVsyncConfig(const VsyncModulator::VsyncConfig& config,
3188 nsecs_t vsyncPeriod) {
Ady Abraham9c53ee72020-07-22 21:16:18 -07003189 mScheduler->setDuration(mAppConnectionHandle,
3190 /*workDuration=*/config.appWorkDuration,
3191 /*readyDuration=*/config.sfWorkDuration);
3192 mScheduler->setDuration(mSfConnectionHandle,
Ady Abraham55fa7272020-09-30 19:19:27 -07003193 /*workDuration=*/std::chrono::nanoseconds(vsyncPeriod),
3194 /*readyDuration=*/config.sfWorkDuration);
3195 mEventQueue->setDuration(config.sfWorkDuration);
Dominik Laskowski08d05c22020-07-22 00:05:08 -07003196}
3197
3198void SurfaceFlinger::commitTransaction() {
Robert Carr6a160312021-05-17 12:08:20 -07003199 ATRACE_CALL();
Vishnu Nair60db8c02020-04-02 11:55:16 -07003200 commitTransactionLocked();
Arthur Hung2274a312021-04-28 15:13:06 +00003201 signalSynchronousTransactions(CountDownLatch::eSyncTransaction);
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003202 mAnimTransactionPending = false;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003203}
3204
Lloyd Pique58e24a32019-08-01 15:50:14 -07003205void SurfaceFlinger::commitTransactionLocked() {
3206 if (!mLayersPendingRemoval.isEmpty()) {
3207 // Notify removed layers now that they can't be drawn from
3208 for (const auto& l : mLayersPendingRemoval) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003209 recordBufferingStats(l->getName(), l->getOccupancyHistory(true));
Lloyd Pique58e24a32019-08-01 15:50:14 -07003210
3211 // Ensure any buffers set to display on any children are released.
3212 if (l->isRemovedFromCurrentState()) {
3213 l->latchAndReleaseBuffer();
3214 }
3215
3216 // If the layer has been removed and has no parent, then it will not be reachable
3217 // when traversing layers on screen. Add the layer to the offscreenLayers set to
3218 // ensure we can copy its current to drawing state.
3219 if (!l->getParent()) {
3220 mOffscreenLayers.emplace(l.get());
3221 }
3222 }
3223 mLayersPendingRemoval.clear();
3224 }
3225
3226 // If this transaction is part of a window animation then the next frame
3227 // we composite should be considered an animation as well.
3228 mAnimCompositionPending = mAnimTransactionPending;
3229
3230 mDrawingState = mCurrentState;
3231 // clear the "changed" flags in current state
3232 mCurrentState.colorMatrixChanged = false;
3233
Robert Carra70e91c2021-06-11 13:59:52 -07003234 if (mVisibleRegionsDirty) {
3235 for (const auto& rootLayer : mDrawingState.layersSortedByZ) {
3236 rootLayer->commitChildList();
3237 }
Andrei Stanciudadac5a2020-08-05 17:02:34 +03003238 }
Robert Carra70e91c2021-06-11 13:59:52 -07003239
Lloyd Pique58e24a32019-08-01 15:50:14 -07003240 commitOffscreenLayers();
Robert Carr6a0382d2021-07-01 15:57:17 -07003241 if (mNumClones > 0) {
3242 mDrawingState.traverse([&](Layer* layer) { layer->updateMirrorInfo(); });
3243 }
Lloyd Pique58e24a32019-08-01 15:50:14 -07003244}
3245
chaviw74d90ad2019-04-26 14:45:26 -07003246void SurfaceFlinger::commitOffscreenLayers() {
3247 for (Layer* offscreenLayer : mOffscreenLayers) {
Edgar Arriaga844fa672020-01-16 14:21:42 -08003248 offscreenLayer->traverse(LayerVector::StateSet::Drawing, [](Layer* layer) {
chaviw74d90ad2019-04-26 14:45:26 -07003249 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
3250 if (!trFlags) return;
3251
3252 layer->doTransaction(0);
3253 layer->commitChildList();
3254 });
3255 }
3256}
3257
Chia-I Wuab0c3192017-08-01 11:29:00 -07003258void SurfaceFlinger::invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty) {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07003259 for (const auto& [token, displayDevice] : ON_MAIN_THREAD(mDisplays)) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003260 auto display = displayDevice->getCompositionDisplay();
Lloyd Piqueef36b002019-01-23 17:52:04 -08003261 if (display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003262 display->editState().dirtyRegion.orSelf(dirty);
Mathias Agopian92a979a2012-08-02 18:32:23 -07003263 }
3264 }
Mathias Agopian87baae12012-07-31 12:38:26 -07003265}
3266
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01003267bool SurfaceFlinger::handlePageFlip() {
Ady Abraham09bd3922019-04-08 10:44:56 -07003268 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08003269 ALOGV("handlePageFlip");
3270
Brian Andersond6927fb2016-07-23 23:37:30 -07003271 nsecs_t latchTime = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003272
Mathias Agopian4fec8732012-06-29 14:12:52 -07003273 bool visibleRegions = false;
Dan Stoza6b9454d2014-11-07 16:00:59 -08003274 bool frameQueued = false;
Mike Stroyan0cd76192017-04-20 12:10:48 -06003275 bool newDataLatched = false;
Eric Penner51c59cd2014-07-28 19:51:58 -07003276
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003277 const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
3278
Eric Penner51c59cd2014-07-28 19:51:58 -07003279 // Store the set of layers that need updates. This set must not change as
3280 // buffers are being latched, as this could result in a deadlock.
3281 // Example: Two producers share the same command stream and:
3282 // 1.) Layer 0 is latched
3283 // 2.) Layer 0 gets a new frame
3284 // 2.) Layer 1 gets a new frame
3285 // 3.) Layer 1 is latched.
3286 // Display is now waiting on Layer 1's frame, which is behind layer 0's
3287 // second frame. But layer 0's second frame could be waiting on display.
Edgar Arriaga844fa672020-01-16 14:21:42 -08003288 mDrawingState.traverse([&](Layer* layer) {
Robert Carrb552ff52021-06-11 13:35:54 -07003289 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
3290 if (trFlags || mForceTransactionDisplayChange) {
3291 const uint32_t flags = layer->doTransaction(0);
3292 if (flags & Layer::eVisibleRegion)
3293 mVisibleRegionsDirty = true;
3294 }
3295
3296 if (layer->hasReadyFrame()) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08003297 frameQueued = true;
Ana Krulec010d2192018-10-08 06:29:54 -07003298 if (layer->shouldPresentNow(expectedPresentTime)) {
Alec Mouri5c9c9602020-09-01 15:10:40 -07003299 mLayersWithQueuedFrames.emplace(layer);
Dan Stozaee44edd2015-03-23 15:50:23 -07003300 } else {
Ady Abraham09bd3922019-04-08 10:44:56 -07003301 ATRACE_NAME("!layer->shouldPresentNow()");
Dan Stozaee44edd2015-03-23 15:50:23 -07003302 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08003303 }
Robert Carrb552ff52021-06-11 13:35:54 -07003304 } else {
Dan Stozaee44edd2015-03-23 15:50:23 -07003305 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08003306 }
Robert Carr2047fae2016-11-28 14:09:09 -08003307 });
Robert Carrb552ff52021-06-11 13:35:54 -07003308 mForceTransactionDisplayChange = false;
Robert Carr2047fae2016-11-28 14:09:09 -08003309
chaviw49a108c2019-08-12 11:23:06 -07003310 // The client can continue submitting buffers for offscreen layers, but they will not
3311 // be shown on screen. Therefore, we need to latch and release buffers of offscreen
3312 // layers to ensure dequeueBuffer doesn't block indefinitely.
3313 for (Layer* offscreenLayer : mOffscreenLayers) {
Edgar Arriaga844fa672020-01-16 14:21:42 -08003314 offscreenLayer->traverse(LayerVector::StateSet::Drawing,
chaviw49a108c2019-08-12 11:23:06 -07003315 [&](Layer* l) { l->latchAndReleaseBuffer(); });
3316 }
3317
Lloyd Piquef2c79392018-12-20 16:23:33 -08003318 if (!mLayersWithQueuedFrames.empty()) {
3319 // mStateLock is needed for latchBuffer as LayerRejecter::reject()
3320 // writes to Layer current state. See also b/119481871
3321 Mutex::Autolock lock(mStateLock);
3322
Alec Mouri2f7d9ae2020-11-30 19:32:33 -08003323 for (const auto& layer : mLayersWithQueuedFrames) {
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003324 if (layer->latchBuffer(visibleRegions, latchTime, expectedPresentTime)) {
Vishnu Nair6194e2e2019-02-06 12:58:39 -08003325 mLayersPendingRefresh.push_back(layer);
3326 }
Lloyd Piquef2c79392018-12-20 16:23:33 -08003327 layer->useSurfaceDamage();
Lloyd Piquef2c79392018-12-20 16:23:33 -08003328 if (layer->isBufferLatched()) {
3329 newDataLatched = true;
3330 }
Mike Stroyan0cd76192017-04-20 12:10:48 -06003331 }
Mathias Agopian4fec8732012-06-29 14:12:52 -07003332 }
Mathias Agopian4da75192010-08-10 17:19:56 -07003333
Mathias Agopian3b1d2b62012-07-11 13:48:17 -07003334 mVisibleRegionsDirty |= visibleRegions;
Dan Stoza6b9454d2014-11-07 16:00:59 -08003335
3336 // If we will need to wake up at some time in the future to deal with a
3337 // queued frame that shouldn't be displayed during this vsync period, wake
3338 // up during the next vsync period to check again.
Chia-I Wua36bf922017-06-30 12:51:05 -07003339 if (frameQueued && (mLayersWithQueuedFrames.empty() || !newDataLatched)) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08003340 signalLayerUpdate();
3341 }
3342
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08003343 // enter boot animation on first buffer latch
3344 if (CC_UNLIKELY(mBootStage == BootStage::BOOTLOADER && newDataLatched)) {
3345 ALOGI("Enter boot animation");
3346 mBootStage = BootStage::BOOTANIMATION;
3347 }
3348
Robert Carr6a0382d2021-07-01 15:57:17 -07003349 if (mNumClones > 0) {
3350 mDrawingState.traverse([&](Layer* layer) { layer->updateCloneBufferInfo(); });
3351 }
chaviw74b03172019-08-19 11:09:03 -07003352
Dan Stoza6b9454d2014-11-07 16:00:59 -08003353 // Only continue with the refresh if there is actually new work to do
Mike Stroyan0cd76192017-04-20 12:10:48 -06003354 return !mLayersWithQueuedFrames.empty() && newDataLatched;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003355}
3356
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01003357void SurfaceFlinger::invalidateHwcGeometry() {
Dan Stoza9e56aa02015-11-02 13:00:03 -08003358 mGeometryInvalid = true;
Mathias Agopianad456f92011-01-13 17:53:01 -08003359}
3360
Robert Carrc0df3122019-04-11 13:18:21 -07003361status_t SurfaceFlinger::addClientLayer(const sp<Client>& client, const sp<IBinder>& handle,
3362 const sp<IGraphicBufferProducer>& gbc, const sp<Layer>& lbc,
3363 const sp<IBinder>& parentHandle,
chaviwe0c7b822021-07-20 10:16:05 -05003364 const sp<Layer>& parentLayer, bool addToRoot,
Vishnu Nair6213bd92020-05-08 17:42:25 -07003365 uint32_t* outTransformHint) {
arthurhungdba591c2021-02-08 17:28:49 +08003366 if (mNumLayers >= ISurfaceComposer::MAX_LAYERS) {
3367 ALOGE("AddClientLayer failed, mNumLayers (%zu) >= MAX_LAYERS (%zu)", mNumLayers.load(),
3368 ISurfaceComposer::MAX_LAYERS);
3369 return NO_MEMORY;
Dan Stoza7d89d062015-04-30 13:29:25 -07003370 }
3371
arthurhungdba591c2021-02-08 17:28:49 +08003372 wp<IBinder> initialProducer;
3373 if (gbc != nullptr) {
3374 initialProducer = IInterface::asBinder(gbc);
3375 }
chaviwe0c7b822021-07-20 10:16:05 -05003376 setLayerCreatedState(handle, lbc, parentHandle, parentLayer, initialProducer, addToRoot);
arthurhungdba591c2021-02-08 17:28:49 +08003377
3378 // Create a transaction includes the initial parent and producer.
3379 Vector<ComposerState> states;
3380 Vector<DisplayState> displays;
3381
3382 ComposerState composerState;
3383 composerState.state.what = layer_state_t::eLayerCreated;
3384 composerState.state.surface = handle;
3385 states.add(composerState);
3386
3387 lbc->updateTransformHint(mDefaultDisplayTransformHint);
3388 if (outTransformHint) {
3389 *outTransformHint = mDefaultDisplayTransformHint;
3390 }
Mathias Agopian96f08192010-06-02 23:28:45 -07003391 // attach this layer to the client
Mathias Agopianac9fa422013-02-11 16:40:36 -08003392 client->attachLayer(handle, lbc);
Mathias Agopian4f113742011-05-03 16:21:41 -07003393
arthurhungdba591c2021-02-08 17:28:49 +08003394 return setTransactionState(FrameTimelineInfo{}, states, displays, 0 /* flags */, nullptr,
3395 InputWindowCommands{}, -1 /* desiredPresentTime */,
3396 true /* isAutoTimestamp */, {}, false /* hasListenerCallbacks */, {},
3397 0 /* Undefined transactionId */);
Mathias Agopian96f08192010-06-02 23:28:45 -07003398}
3399
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07003400void SurfaceFlinger::removeGraphicBufferProducerAsync(const wp<IBinder>& binder) {
3401 static_cast<void>(schedule([=] {
3402 Mutex::Autolock lock(mStateLock);
3403 mGraphicBufferProducerList.erase(binder);
3404 }));
3405}
3406
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08003407uint32_t SurfaceFlinger::peekTransactionFlags() {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003408 return mTransactionFlags;
Mathias Agopiandea20b12011-05-03 17:04:02 -07003409}
3410
Mathias Agopian3f844832013-08-07 21:24:32 -07003411uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003412 return mTransactionFlags.fetch_and(~flags) & flags;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003413}
3414
Mathias Agopian3f844832013-08-07 21:24:32 -07003415uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) {
Dominik Laskowski08d05c22020-07-22 00:05:08 -07003416 return setTransactionFlags(flags, TransactionSchedule::Late);
Dan Stoza84d619e2018-03-28 17:07:36 -07003417}
3418
Ady Abraham23ea9da2021-07-14 16:32:56 -07003419uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags, TransactionSchedule schedule,
3420 const sp<IBinder>& token) {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003421 uint32_t old = mTransactionFlags.fetch_or(flags);
Ady Abraham23ea9da2021-07-14 16:32:56 -07003422 modulateVsync(&VsyncModulator::setTransactionSchedule, schedule, token);
Dominik Laskowski08d05c22020-07-22 00:05:08 -07003423 if ((old & flags) == 0) signalTransaction();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003424 return old;
3425}
3426
Valerie Haud50e7412020-06-16 17:58:14 -07003427void SurfaceFlinger::setTraversalNeeded() {
3428 mForceTraversal = true;
Robert Carr4b874132020-05-29 12:02:51 -07003429}
3430
Arthur Hung58144272021-01-16 03:43:53 +00003431void SurfaceFlinger::flushTransactionQueues() {
Valerie Haufce31b82019-04-30 16:41:14 -07003432 // to prevent onHandleDestroyed from being called while the lock is held,
3433 // we must keep a copy of the transactions (specifically the composer
3434 // states) around outside the scope of the lock
3435 std::vector<const TransactionState> transactions;
Vishnu Nair12f62a02021-02-03 16:23:16 -08003436 // Layer handles that have transactions with buffers that are ready to be applied.
Vishnu Nair83df0342021-03-30 11:50:44 -07003437 std::unordered_set<sp<IBinder>, ISurfaceComposer::SpHash<IBinder>> bufferLayersReadyToPresent;
Valerie Haufce31b82019-04-30 16:41:14 -07003438 {
Vishnu Nair12f62a02021-02-03 16:23:16 -08003439 Mutex::Autolock _l(mStateLock);
3440 {
3441 Mutex::Autolock _l(mQueueLock);
3442 // Collect transactions from pending transaction queue.
3443 auto it = mPendingTransactionQueues.begin();
3444 while (it != mPendingTransactionQueues.end()) {
3445 auto& [applyToken, transactionQueue] = *it;
Marissa Wall713b63f2018-10-17 15:42:43 -07003446
Vishnu Nair12f62a02021-02-03 16:23:16 -08003447 while (!transactionQueue.empty()) {
arthurhungf1b7c7b2021-03-03 17:42:23 +08003448 auto& transaction = transactionQueue.front();
Ady Abraham43752eb2021-03-04 16:24:25 -08003449 if (!transactionIsReadyToBeApplied(transaction.frameTimelineInfo,
3450 transaction.isAutoTimestamp,
Vishnu Nair12f62a02021-02-03 16:23:16 -08003451 transaction.desiredPresentTime,
Ady Abraham5690bda2021-03-12 15:01:18 -08003452 transaction.originUid, transaction.states,
Vishnu Nair83df0342021-03-30 11:50:44 -07003453 bufferLayersReadyToPresent)) {
Vishnu Nair12f62a02021-02-03 16:23:16 -08003454 setTransactionFlags(eTransactionFlushNeeded);
3455 break;
3456 }
Vishnu Nair83df0342021-03-30 11:50:44 -07003457 transaction.traverseStatesWithBuffers([&](const layer_state_t& state) {
3458 bufferLayersReadyToPresent.insert(state.surface);
3459 });
arthurhungf1b7c7b2021-03-03 17:42:23 +08003460 transactions.emplace_back(std::move(transaction));
Vishnu Nair12f62a02021-02-03 16:23:16 -08003461 transactionQueue.pop();
3462 }
3463
3464 if (transactionQueue.empty()) {
3465 it = mPendingTransactionQueues.erase(it);
3466 mTransactionQueueCV.broadcast();
3467 } else {
3468 it = std::next(it, 1);
3469 }
3470 }
3471
3472 // Collect transactions from current transaction queue or queue to pending transactions.
3473 // Case 1: push to pending when transactionIsReadyToBeApplied is false.
3474 // Case 2: push to pending when there exist a pending queue.
3475 // Case 3: others are ready to apply.
3476 while (!mTransactionQueue.empty()) {
arthurhungf1b7c7b2021-03-03 17:42:23 +08003477 auto& transaction = mTransactionQueue.front();
Vishnu Nair12f62a02021-02-03 16:23:16 -08003478 bool pendingTransactions = mPendingTransactionQueues.find(transaction.applyToken) !=
3479 mPendingTransactionQueues.end();
Vishnu Nair83df0342021-03-30 11:50:44 -07003480 if (pendingTransactions ||
3481 !transactionIsReadyToBeApplied(transaction.frameTimelineInfo,
Ady Abraham43752eb2021-03-04 16:24:25 -08003482 transaction.isAutoTimestamp,
Vishnu Nairf6eddb62021-01-27 22:02:11 -08003483 transaction.desiredPresentTime,
Ady Abraham5690bda2021-03-12 15:01:18 -08003484 transaction.originUid, transaction.states,
Vishnu Nair83df0342021-03-30 11:50:44 -07003485 bufferLayersReadyToPresent)) {
arthurhungf1b7c7b2021-03-03 17:42:23 +08003486 mPendingTransactionQueues[transaction.applyToken].push(std::move(transaction));
Vishnu Nair12f62a02021-02-03 16:23:16 -08003487 } else {
Vishnu Nair83df0342021-03-30 11:50:44 -07003488 transaction.traverseStatesWithBuffers([&](const layer_state_t& state) {
3489 bufferLayersReadyToPresent.insert(state.surface);
3490 });
arthurhungf1b7c7b2021-03-03 17:42:23 +08003491 transactions.emplace_back(std::move(transaction));
Valerie Haufce31b82019-04-30 16:41:14 -07003492 }
Vishnu Nair12f62a02021-02-03 16:23:16 -08003493 mTransactionQueue.pop();
Ady Abrahame46243a2021-02-23 19:33:49 -08003494 ATRACE_INT("TransactionQueue", mTransactionQueue.size());
Valerie Haufce31b82019-04-30 16:41:14 -07003495 }
Valerie Hauf6016b62019-03-28 10:49:59 -07003496 }
Arthur Hung58144272021-01-16 03:43:53 +00003497
Vishnu Nair12f62a02021-02-03 16:23:16 -08003498 // Now apply all transactions.
3499 for (const auto& transaction : transactions) {
3500 applyTransactionState(transaction.frameTimelineInfo, transaction.states,
3501 transaction.displays, transaction.flags,
3502 transaction.inputWindowCommands, transaction.desiredPresentTime,
3503 transaction.isAutoTimestamp, transaction.buffer,
Vishnu Nair24e3bba2021-02-23 14:19:36 -08003504 transaction.postTime, transaction.permissions,
Vishnu Nair12f62a02021-02-03 16:23:16 -08003505 transaction.hasListenerCallbacks, transaction.listenerCallbacks,
3506 transaction.originPid, transaction.originUid, transaction.id);
arthurhungf1b7c7b2021-03-03 17:42:23 +08003507 if (transaction.transactionCommittedSignal) {
3508 mTransactionCommittedSignals.emplace_back(
3509 std::move(transaction.transactionCommittedSignal));
3510 }
Arthur Hung58144272021-01-16 03:43:53 +00003511 }
Marissa Wall713b63f2018-10-17 15:42:43 -07003512 }
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003513}
3514
3515bool SurfaceFlinger::transactionFlushNeeded() {
Arthur Hung58144272021-01-16 03:43:53 +00003516 Mutex::Autolock _l(mQueueLock);
Robert Carr79bf8a92021-03-11 16:24:28 -08003517 return !mPendingTransactionQueues.empty() || !mTransactionQueue.empty();
Marissa Wall713b63f2018-10-17 15:42:43 -07003518}
3519
Ady Abraham8db10102021-03-15 17:19:23 -07003520bool SurfaceFlinger::frameIsEarly(nsecs_t expectedPresentTime, int64_t vsyncId) const {
3521 // The amount of time SF can delay a frame if it is considered early based
3522 // on the VsyncModulator::VsyncConfig::appWorkDuration
3523 constexpr static std::chrono::nanoseconds kEarlyLatchMaxThreshold = 100ms;
3524
3525 const auto currentVsyncPeriod = mScheduler->getDisplayStatInfo(systemTime()).vsyncPeriod;
3526 const auto earlyLatchVsyncThreshold = currentVsyncPeriod / 2;
3527
3528 const auto prediction = mFrameTimeline->getTokenManager()->getPredictionsForToken(vsyncId);
3529 if (!prediction.has_value()) {
3530 return false;
3531 }
3532
3533 if (std::abs(prediction->presentTime - expectedPresentTime) >=
3534 kEarlyLatchMaxThreshold.count()) {
3535 return false;
3536 }
3537
3538 return prediction->presentTime >= expectedPresentTime &&
3539 prediction->presentTime - expectedPresentTime >= earlyLatchVsyncThreshold;
3540}
3541
Vishnu Nair12f62a02021-02-03 16:23:16 -08003542bool SurfaceFlinger::transactionIsReadyToBeApplied(
Ady Abraham43752eb2021-03-04 16:24:25 -08003543 const FrameTimelineInfo& info, bool isAutoTimestamp, int64_t desiredPresentTime,
Ady Abraham5690bda2021-03-12 15:01:18 -08003544 uid_t originUid, const Vector<ComposerState>& states,
Vishnu Nair83df0342021-03-30 11:50:44 -07003545 const std::unordered_set<sp<IBinder>, ISurfaceComposer::SpHash<IBinder>>&
3546 bufferLayersReadyToPresent) const {
Ady Abraham2f43b202021-03-12 12:34:52 -08003547 ATRACE_CALL();
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003548 const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
Marissa Wall17b4e452018-12-26 16:32:34 -08003549 // Do not present if the desiredPresentTime has not passed unless it is more than one second
3550 // in the future. We ignore timestamps more than 1 second in the future for stability reasons.
Vishnu Nairf6eddb62021-01-27 22:02:11 -08003551 if (!isAutoTimestamp && desiredPresentTime >= expectedPresentTime &&
Marissa Wall17b4e452018-12-26 16:32:34 -08003552 desiredPresentTime < expectedPresentTime + s2ns(1)) {
Ady Abraham2f43b202021-03-12 12:34:52 -08003553 ATRACE_NAME("not current");
Vishnu Nair83df0342021-03-30 11:50:44 -07003554 return false;
Marissa Wall17b4e452018-12-26 16:32:34 -08003555 }
3556
Ady Abraham5690bda2021-03-12 15:01:18 -08003557 if (!mScheduler->isVsyncValid(expectedPresentTime, originUid)) {
3558 ATRACE_NAME("!isVsyncValid");
Vishnu Nair83df0342021-03-30 11:50:44 -07003559 return false;
Ady Abraham5690bda2021-03-12 15:01:18 -08003560 }
3561
Ady Abraham8db10102021-03-15 17:19:23 -07003562 // If the client didn't specify desiredPresentTime, use the vsyncId to determine the expected
3563 // present time of this transaction.
3564 if (isAutoTimestamp && frameIsEarly(expectedPresentTime, info.vsyncId)) {
3565 ATRACE_NAME("frameIsEarly");
Vishnu Nair83df0342021-03-30 11:50:44 -07003566 return false;
Ady Abraham8db10102021-03-15 17:19:23 -07003567 }
3568
Marissa Wall713b63f2018-10-17 15:42:43 -07003569 for (const ComposerState& state : states) {
3570 const layer_state_t& s = state.state;
Ady Abraham29d16cb2021-03-08 13:19:21 -08003571 const bool acquireFenceChanged = (s.what & layer_state_t::eAcquireFenceChanged);
Huihong Luo86c80e32021-06-16 15:41:07 -07003572 if (acquireFenceChanged && s.acquireFence && !enableLatchUnsignaled &&
Ady Abraham29d16cb2021-03-08 13:19:21 -08003573 s.acquireFence->getStatus() == Fence::Status::Unsignaled) {
Ady Abraham7061fd12021-03-22 12:55:39 -07003574 ATRACE_NAME("fence unsignaled");
Vishnu Nair83df0342021-03-30 11:50:44 -07003575 return false;
Robert Carr7121caf2020-12-15 13:07:32 -08003576 }
Arthur Hung58144272021-01-16 03:43:53 +00003577
Ady Abrahamf20c1922020-12-21 18:39:01 -08003578 sp<Layer> layer = nullptr;
3579 if (s.surface) {
3580 layer = fromHandleLocked(s.surface).promote();
Vishnu Nairddf9b5c2021-03-29 18:53:41 -07003581 } else if (s.hasBufferChanges()) {
Ady Abrahamf20c1922020-12-21 18:39:01 -08003582 ALOGW("Transaction with buffer, but no Layer?");
3583 continue;
3584 }
Vishnu Nairf6eddb62021-01-27 22:02:11 -08003585 if (!layer) {
3586 continue;
3587 }
Ady Abraham43752eb2021-03-04 16:24:25 -08003588
Ady Abraham2f43b202021-03-12 12:34:52 -08003589 ATRACE_NAME(layer->getName().c_str());
3590
Vishnu Nairddf9b5c2021-03-29 18:53:41 -07003591 if (s.hasBufferChanges()) {
Ady Abraham29d16cb2021-03-08 13:19:21 -08003592 // If backpressure is enabled and we already have a buffer to commit, keep the
3593 // transaction in the queue.
Vishnu Nair83df0342021-03-30 11:50:44 -07003594 const bool hasPendingBuffer =
3595 bufferLayersReadyToPresent.find(s.surface) != bufferLayersReadyToPresent.end();
Ady Abraham29d16cb2021-03-08 13:19:21 -08003596 if (layer->backpressureEnabled() && hasPendingBuffer && isAutoTimestamp) {
Ady Abraham2f43b202021-03-12 12:34:52 -08003597 ATRACE_NAME("hasPendingBuffer");
Vishnu Nair83df0342021-03-30 11:50:44 -07003598 return false;
Ady Abraham29d16cb2021-03-08 13:19:21 -08003599 }
Marissa Wall713b63f2018-10-17 15:42:43 -07003600 }
3601 }
Vishnu Nair83df0342021-03-30 11:50:44 -07003602 return true;
Marissa Wall713b63f2018-10-17 15:42:43 -07003603}
3604
arthurhungf1b7c7b2021-03-03 17:42:23 +08003605void SurfaceFlinger::queueTransaction(TransactionState& state) {
Ady Abrahame46243a2021-02-23 19:33:49 -08003606 Mutex::Autolock _l(mQueueLock);
3607
3608 // If its TransactionQueue already has a pending TransactionState or if it is pending
3609 auto itr = mPendingTransactionQueues.find(state.applyToken);
3610 // if this is an animation frame, wait until prior animation frame has
3611 // been applied by SF
3612 if (state.flags & eAnimation) {
3613 while (itr != mPendingTransactionQueues.end()) {
3614 status_t err = mTransactionQueueCV.waitRelative(mQueueLock, s2ns(5));
3615 if (CC_UNLIKELY(err != NO_ERROR)) {
3616 ALOGW_IF(err == TIMED_OUT,
3617 "setTransactionState timed out "
3618 "waiting for animation frame to apply");
3619 break;
3620 }
3621 itr = mPendingTransactionQueues.find(state.applyToken);
3622 }
3623 }
3624
arthurhungf1b7c7b2021-03-03 17:42:23 +08003625 // Generate a CountDownLatch pending state if this is a synchronous transaction.
3626 if ((state.flags & eSynchronous) || state.inputWindowCommands.syncInputWindows) {
3627 state.transactionCommittedSignal = std::make_shared<CountDownLatch>(
Arthur Hung2274a312021-04-28 15:13:06 +00003628 (state.inputWindowCommands.syncInputWindows
3629 ? (CountDownLatch::eSyncInputWindows | CountDownLatch::eSyncTransaction)
3630 : CountDownLatch::eSyncTransaction));
arthurhungf1b7c7b2021-03-03 17:42:23 +08003631 }
3632
Ady Abrahame46243a2021-02-23 19:33:49 -08003633 mTransactionQueue.emplace(state);
3634 ATRACE_INT("TransactionQueue", mTransactionQueue.size());
3635
Ady Abrahame46243a2021-02-23 19:33:49 -08003636 const auto schedule = [](uint32_t flags) {
Ady Abraham8cbd3072021-03-15 16:39:06 -07003637 if (flags & eEarlyWakeupEnd) return TransactionSchedule::EarlyEnd;
3638 if (flags & eEarlyWakeupStart) return TransactionSchedule::EarlyStart;
Ady Abrahame46243a2021-02-23 19:33:49 -08003639 return TransactionSchedule::Late;
3640 }(state.flags);
3641
Ady Abraham23ea9da2021-07-14 16:32:56 -07003642 setTransactionFlags(eTransactionFlushNeeded, schedule, state.applyToken);
Ady Abrahame46243a2021-02-23 19:33:49 -08003643}
3644
arthurhungf1b7c7b2021-03-03 17:42:23 +08003645void SurfaceFlinger::waitForSynchronousTransaction(
3646 const CountDownLatch& transactionCommittedSignal) {
3647 // applyTransactionState is called on the main SF thread. While a given process may wish
3648 // to wait on synchronous transactions, the main SF thread should apply the transaction and
3649 // set the value to notify this after committed.
3650 if (!transactionCommittedSignal.wait_until(std::chrono::seconds(5))) {
3651 ALOGE("setTransactionState timed out!");
Ady Abrahame46243a2021-02-23 19:33:49 -08003652 }
arthurhungf1b7c7b2021-03-03 17:42:23 +08003653}
Ady Abrahame46243a2021-02-23 19:33:49 -08003654
Arthur Hung2274a312021-04-28 15:13:06 +00003655void SurfaceFlinger::signalSynchronousTransactions(const uint32_t flag) {
arthurhungf1b7c7b2021-03-03 17:42:23 +08003656 for (auto it = mTransactionCommittedSignals.begin();
3657 it != mTransactionCommittedSignals.end();) {
Arthur Hung2274a312021-04-28 15:13:06 +00003658 if ((*it)->countDown(flag)) {
arthurhungf1b7c7b2021-03-03 17:42:23 +08003659 it = mTransactionCommittedSignals.erase(it);
3660 } else {
3661 it++;
Ady Abrahame46243a2021-02-23 19:33:49 -08003662 }
3663 }
3664}
3665
chaviw308ddba2020-08-11 16:23:51 -07003666status_t SurfaceFlinger::setTransactionState(
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10003667 const FrameTimelineInfo& frameTimelineInfo, const Vector<ComposerState>& states,
Ady Abraham22c7b5c2020-09-22 19:33:40 -07003668 const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
3669 const InputWindowCommands& inputWindowCommands, int64_t desiredPresentTime,
Ady Abrahamf0c56492020-12-17 18:04:15 -08003670 bool isAutoTimestamp, const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
Pablo Gamito7eb7ee72020-08-05 10:57:05 +00003671 const std::vector<ListenerCallbacks>& listenerCallbacks, uint64_t transactionId) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003672 ATRACE_CALL();
Robert Carr14167e02019-02-13 13:50:55 -08003673
Vishnu Nair24e3bba2021-02-23 14:19:36 -08003674 uint32_t permissions =
3675 callingThreadHasUnscopedSurfaceFlingerAccess() ? Permission::ACCESS_SURFACE_FLINGER : 0;
3676 // Avoid checking for rotation permissions if the caller already has ACCESS_SURFACE_FLINGER
3677 // permissions.
3678 if ((permissions & Permission::ACCESS_SURFACE_FLINGER) ||
3679 callingThreadHasRotateSurfaceFlingerAccess()) {
3680 permissions |= Permission::ROTATE_SURFACE_FLINGER;
3681 }
3682
arthurhungf1b7c7b2021-03-03 17:42:23 +08003683 if (!(permissions & Permission::ACCESS_SURFACE_FLINGER) &&
Ady Abraham8cbd3072021-03-15 16:39:06 -07003684 (flags & (eEarlyWakeupStart | eEarlyWakeupEnd))) {
3685 ALOGE("Only WindowManager is allowed to use eEarlyWakeup[Start|End] flags");
3686 flags &= ~(eEarlyWakeupStart | eEarlyWakeupEnd);
arthurhungf1b7c7b2021-03-03 17:42:23 +08003687 }
3688
Vishnu Nair24e3bba2021-02-23 14:19:36 -08003689 const int64_t postTime = systemTime();
3690
3691 IPCThreadState* ipc = IPCThreadState::self();
3692 const int originPid = ipc->getCallingPid();
3693 const int originUid = ipc->getCallingUid();
arthurhungf1b7c7b2021-03-03 17:42:23 +08003694 TransactionState state{frameTimelineInfo, states,
3695 displays, flags,
3696 applyToken, inputWindowCommands,
3697 desiredPresentTime, isAutoTimestamp,
3698 uncacheBuffer, postTime,
3699 permissions, hasListenerCallbacks,
3700 listenerCallbacks, originPid,
3701 originUid, transactionId};
Vishnu Nair83df0342021-03-30 11:50:44 -07003702
3703 // Check for incoming buffer updates and increment the pending buffer count.
3704 state.traverseStatesWithBuffers([&](const layer_state_t& state) {
3705 mBufferCountTracker.increment(state.surface->localBinder());
3706 });
arthurhungf1b7c7b2021-03-03 17:42:23 +08003707 queueTransaction(state);
Vishnu Nair24e3bba2021-02-23 14:19:36 -08003708
arthurhungf1b7c7b2021-03-03 17:42:23 +08003709 // Check the pending state to make sure the transaction is synchronous.
3710 if (state.transactionCommittedSignal) {
3711 waitForSynchronousTransaction(*state.transactionCommittedSignal);
Arthur Hung58144272021-01-16 03:43:53 +00003712 }
3713
Zhuoyao Zhang3d3540d2021-01-14 05:14:54 +00003714 return NO_ERROR;
3715}
Marissa Wall713b63f2018-10-17 15:42:43 -07003716
Arthur Hung58144272021-01-16 03:43:53 +00003717void SurfaceFlinger::applyTransactionState(const FrameTimelineInfo& frameTimelineInfo,
3718 const Vector<ComposerState>& states,
3719 const Vector<DisplayState>& displays, uint32_t flags,
3720 const InputWindowCommands& inputWindowCommands,
3721 const int64_t desiredPresentTime, bool isAutoTimestamp,
3722 const client_cache_t& uncacheBuffer,
Vishnu Nair24e3bba2021-02-23 14:19:36 -08003723 const int64_t postTime, uint32_t permissions,
Arthur Hung58144272021-01-16 03:43:53 +00003724 bool hasListenerCallbacks,
3725 const std::vector<ListenerCallbacks>& listenerCallbacks,
3726 int originPid, int originUid, uint64_t transactionId) {
Zhuoyao Zhang3d3540d2021-01-14 05:14:54 +00003727 uint32_t transactionFlags = 0;
chaviwca27f252018-02-06 16:46:39 -08003728 for (const DisplayState& display : displays) {
3729 transactionFlags |= setDisplayStateLocked(display);
Jamie Gennisb8d69a52011-10-10 15:48:06 -07003730 }
3731
Valerie Hau9dab9732019-08-20 09:29:25 -07003732 // start and end registration for listeners w/ no surface so they can get their callback. Note
3733 // that listeners with SurfaceControls will start registration during setClientStateLocked
3734 // below.
3735 for (const auto& listener : listenerCallbacks) {
Robert Carr9a803c32021-01-14 16:57:58 -08003736 mTransactionCallbackInvoker.startRegistration(listener);
3737 mTransactionCallbackInvoker.endRegistration(listener);
Marissa Walld600d572019-03-26 15:38:50 -07003738 }
3739
Valerie Hau9dab9732019-08-20 09:29:25 -07003740 std::unordered_set<ListenerCallbacks, ListenerCallbacksHash> listenerCallbacksWithSurfaces;
Marissa Walle2ffb422018-10-12 11:33:52 -07003741 uint32_t clientStateFlags = 0;
chaviwca27f252018-02-06 16:46:39 -08003742 for (const ComposerState& state : states) {
Galia Peycheva700342f2021-01-12 19:59:51 +01003743 clientStateFlags |=
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10003744 setClientStateLocked(frameTimelineInfo, state, desiredPresentTime, isAutoTimestamp,
Vishnu Nair24e3bba2021-02-23 14:19:36 -08003745 postTime, permissions, listenerCallbacksWithSurfaces);
Ady Abraham5def7332020-05-29 16:13:47 -07003746 if ((flags & eAnimation) && state.state.surface) {
3747 if (const auto layer = fromHandleLocked(state.state.surface).promote(); layer) {
Ady Abrahamf0c56492020-12-17 18:04:15 -08003748 mScheduler->recordLayerHistory(layer.get(),
3749 isAutoTimestamp ? 0 : desiredPresentTime,
Ady Abraham5def7332020-05-29 16:13:47 -07003750 LayerHistory::LayerUpdateType::AnimationTX);
3751 }
3752 }
Marissa Wall3dad52d2019-03-22 14:03:19 -07003753 }
3754
Valerie Hau9dab9732019-08-20 09:29:25 -07003755 for (const auto& listenerCallback : listenerCallbacksWithSurfaces) {
Robert Carr9a803c32021-01-14 16:57:58 -08003756 mTransactionCallbackInvoker.endRegistration(listenerCallback);
Marissa Wallefb71af2019-06-27 14:45:53 -07003757 }
3758
Marissa Walle2ffb422018-10-12 11:33:52 -07003759 // If the state doesn't require a traversal and there are callbacks, send them now
Valerie Hau9dab9732019-08-20 09:29:25 -07003760 if (!(clientStateFlags & eTraversalNeeded) && hasListenerCallbacks) {
Robert Carr9a803c32021-01-14 16:57:58 -08003761 mTransactionCallbackInvoker.sendCallbacks();
Marissa Walle2ffb422018-10-12 11:33:52 -07003762 }
3763 transactionFlags |= clientStateFlags;
chaviwca27f252018-02-06 16:46:39 -08003764
Vishnu Nair24e3bba2021-02-23 14:19:36 -08003765 if (permissions & Permission::ACCESS_SURFACE_FLINGER) {
Vishnu Nair958da932020-08-21 17:12:37 -07003766 transactionFlags |= addInputWindowCommands(inputWindowCommands);
3767 } else if (!inputWindowCommands.empty()) {
3768 ALOGE("Only privileged callers are allowed to send input commands.");
3769 }
chaviw273171b2018-12-26 11:46:30 -08003770
Marissa Wall947d34e2019-03-29 14:03:53 -07003771 if (uncacheBuffer.isValid()) {
3772 ClientCache::getInstance().erase(uncacheBuffer);
Marissa Wall78b72202019-03-15 14:58:34 -07003773 }
3774
Jorim Jaggibdcf09c2017-08-08 15:22:08 +02003775 // If a synchronous transaction is explicitly requested without any changes, force a transaction
3776 // anyway. This can be used as a flush mechanism for previous async transactions.
3777 // Empty animation transaction can be used to simulate back-pressure, so also force a
3778 // transaction for empty animation transactions.
3779 if (transactionFlags == 0 &&
3780 ((flags & eSynchronous) || (flags & eAnimation))) {
Robert Carr2a7dbb42016-05-24 11:41:28 -07003781 transactionFlags = eTransactionNeeded;
3782 }
3783
Mathias Agopian386aa982011-11-07 21:58:03 -08003784 if (transactionFlags) {
Arthur Hung1bedccb2020-09-24 10:09:25 +00003785 if (mInterceptor->isEnabled()) {
3786 mInterceptor->saveTransaction(states, mCurrentState.displays, displays, flags,
Pablo Gamito7eb7ee72020-08-05 10:57:05 +00003787 originPid, originUid, transactionId);
Arthur Hung1bedccb2020-09-24 10:09:25 +00003788 }
3789
Arthur Hung58144272021-01-16 03:43:53 +00003790 // We are on the main thread, we are about to preform a traversal. Clear the traversal bit
3791 // so we don't have to wake up again next frame to preform an unnecessary traversal.
3792 if (transactionFlags & eTraversalNeeded) {
3793 transactionFlags = transactionFlags & (~eTraversalNeeded);
3794 mForceTraversal = true;
Arthur Hung1bedccb2020-09-24 10:09:25 +00003795 }
Arthur Hung58144272021-01-16 03:43:53 +00003796 if (transactionFlags) {
3797 setTransactionFlags(transactionFlags);
Arthur Hung1bedccb2020-09-24 10:09:25 +00003798 }
3799
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003800 if (flags & eAnimation) {
3801 mAnimTransactionPending = true;
3802 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003803 }
3804}
3805
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003806uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s) {
3807 const ssize_t index = mCurrentState.displays.indexOfKey(s.token);
3808 if (index < 0) return 0;
Jesse Hall9a143922012-10-04 16:29:19 -07003809
Mathias Agopiane57f2922012-08-09 16:29:12 -07003810 uint32_t flags = 0;
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003811 DisplayDeviceState& state = mCurrentState.displays.editValueAt(index);
3812
3813 const uint32_t what = s.what;
3814 if (what & DisplayState::eSurfaceChanged) {
3815 if (IInterface::asBinder(state.surface) != IInterface::asBinder(s.surface)) {
3816 state.surface = s.surface;
3817 flags |= eDisplayTransactionNeeded;
Michael Lentine47e45402014-07-18 15:34:25 -07003818 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07003819 }
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003820 if (what & DisplayState::eLayerStackChanged) {
3821 if (state.layerStack != s.layerStack) {
3822 state.layerStack = s.layerStack;
3823 flags |= eDisplayTransactionNeeded;
3824 }
3825 }
Evan Rosky2239b372021-05-20 13:43:47 -07003826 if (what & DisplayState::eFlagsChanged) {
3827 if (state.flags != s.flags) {
3828 state.flags = s.flags;
3829 flags |= eDisplayTransactionNeeded;
3830 }
3831 }
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003832 if (what & DisplayState::eDisplayProjectionChanged) {
3833 if (state.orientation != s.orientation) {
3834 state.orientation = s.orientation;
3835 flags |= eDisplayTransactionNeeded;
3836 }
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02003837 if (state.orientedDisplaySpaceRect != s.orientedDisplaySpaceRect) {
3838 state.orientedDisplaySpaceRect = s.orientedDisplaySpaceRect;
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003839 flags |= eDisplayTransactionNeeded;
3840 }
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02003841 if (state.layerStackSpaceRect != s.layerStackSpaceRect) {
3842 state.layerStackSpaceRect = s.layerStackSpaceRect;
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003843 flags |= eDisplayTransactionNeeded;
3844 }
3845 }
3846 if (what & DisplayState::eDisplaySizeChanged) {
3847 if (state.width != s.width) {
3848 state.width = s.width;
3849 flags |= eDisplayTransactionNeeded;
3850 }
3851 if (state.height != s.height) {
3852 state.height = s.height;
3853 flags |= eDisplayTransactionNeeded;
3854 }
3855 }
3856
Mathias Agopiane57f2922012-08-09 16:29:12 -07003857 return flags;
3858}
3859
Steven Thomasd4071902020-03-24 16:02:53 -07003860bool SurfaceFlinger::callingThreadHasUnscopedSurfaceFlingerAccess(bool usePermissionCache) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003861 IPCThreadState* ipc = IPCThreadState::self();
3862 const int pid = ipc->getCallingPid();
3863 const int uid = ipc->getCallingUid();
Robert Carrd4ae7f32018-06-07 16:10:57 -07003864 if ((uid != AID_GRAPHICS && uid != AID_SYSTEM) &&
Steven Thomasd4071902020-03-24 16:02:53 -07003865 (usePermissionCache ? !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)
3866 : !checkPermission(sAccessSurfaceFlinger, pid, uid))) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003867 return false;
3868 }
3869 return true;
3870}
3871
Marissa Wall3dad52d2019-03-22 14:03:19 -07003872uint32_t SurfaceFlinger::setClientStateLocked(
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10003873 const FrameTimelineInfo& frameTimelineInfo, const ComposerState& composerState,
Vishnu Nair24e3bba2021-02-23 14:19:36 -08003874 int64_t desiredPresentTime, bool isAutoTimestamp, int64_t postTime, uint32_t permissions,
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07003875 std::unordered_set<ListenerCallbacks, ListenerCallbacksHash>& outListenerCallbacks) {
chaviwca27f252018-02-06 16:46:39 -08003876 const layer_state_t& s = composerState.state;
Vishnu Nair24e3bba2021-02-23 14:19:36 -08003877 const bool privileged = permissions & Permission::ACCESS_SURFACE_FLINGER;
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07003878
3879 std::vector<ListenerCallbacks> filteredListeners;
Valerie Hau9dab9732019-08-20 09:29:25 -07003880 for (auto& listener : s.listeners) {
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07003881 // Starts a registration but separates the callback ids according to callback type. This
3882 // allows the callback invoker to send on latch callbacks earlier.
Valerie Hau9dab9732019-08-20 09:29:25 -07003883 // note that startRegistration will not re-register if the listener has
3884 // already be registered for a prior surface control
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07003885
3886 ListenerCallbacks onCommitCallbacks = listener.filter(CallbackId::Type::ON_COMMIT);
3887 if (!onCommitCallbacks.callbackIds.empty()) {
3888 mTransactionCallbackInvoker.startRegistration(onCommitCallbacks);
3889 filteredListeners.push_back(onCommitCallbacks);
3890 outListenerCallbacks.insert(onCommitCallbacks);
3891 }
3892
3893 ListenerCallbacks onCompleteCallbacks = listener.filter(CallbackId::Type::ON_COMPLETE);
3894 if (!onCompleteCallbacks.callbackIds.empty()) {
3895 mTransactionCallbackInvoker.startRegistration(onCompleteCallbacks);
3896 filteredListeners.push_back(onCompleteCallbacks);
3897 outListenerCallbacks.insert(onCompleteCallbacks);
3898 }
Valerie Hau9dab9732019-08-20 09:29:25 -07003899 }
3900
arthurhungdba591c2021-02-08 17:28:49 +08003901 const uint64_t what = s.what;
3902 uint32_t flags = 0;
Vishnu Nairdc6f5b92019-12-03 07:33:37 -08003903 sp<Layer> layer = nullptr;
3904 if (s.surface) {
arthurhungdba591c2021-02-08 17:28:49 +08003905 if (what & layer_state_t::eLayerCreated) {
chaviwe0c7b822021-07-20 10:16:05 -05003906 layer = handleLayerCreatedLocked(s.surface);
arthurhungdba591c2021-02-08 17:28:49 +08003907 if (layer) {
3908 // put the created layer into mLayersByLocalBinderToken.
3909 mLayersByLocalBinderToken.emplace(s.surface->localBinder(), layer);
3910 flags |= eTransactionNeeded | eTraversalNeeded;
3911 mLayersAdded = true;
3912 }
3913 } else {
3914 layer = fromHandleLocked(s.surface).promote();
3915 }
Vishnu Nairdc6f5b92019-12-03 07:33:37 -08003916 } else {
3917 // The client may provide us a null handle. Treat it as if the layer was removed.
3918 ALOGW("Attempt to set client state with a null layer handle");
3919 }
chaviw8b3871a2017-11-01 17:41:01 -07003920 if (layer == nullptr) {
Valerie Hau9dab9732019-08-20 09:29:25 -07003921 for (auto& [listener, callbackIds] : s.listeners) {
Robert Carr9a803c32021-01-14 16:57:58 -08003922 mTransactionCallbackInvoker.registerUnpresentedCallbackHandle(
Valerie Hau9dab9732019-08-20 09:29:25 -07003923 new CallbackHandle(listener, callbackIds, s.surface));
Marissa Wall88e20482019-06-24 10:49:42 -07003924 }
chaviw8b3871a2017-11-01 17:41:01 -07003925 return 0;
3926 }
3927
Valerie Hau871d6352020-01-29 08:44:02 -08003928 // Only set by BLAST adapter layers
3929 if (what & layer_state_t::eProducerDisconnect) {
3930 layer->onDisconnect();
3931 }
3932
chaviw8b3871a2017-11-01 17:41:01 -07003933 if (what & layer_state_t::ePositionChanged) {
chaviw214c89d2019-09-04 16:03:53 -07003934 if (layer->setPosition(s.x, s.y)) {
chaviw8b3871a2017-11-01 17:41:01 -07003935 flags |= eTraversalNeeded;
Mathias Agopiane57f2922012-08-09 16:29:12 -07003936 }
chaviw8b3871a2017-11-01 17:41:01 -07003937 }
3938 if (what & layer_state_t::eLayerChanged) {
3939 // NOTE: index needs to be calculated before we update the state
3940 const auto& p = layer->getParent();
3941 if (p == nullptr) {
chaviw64f7b422017-07-12 10:31:58 -07003942 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
chaviw8b3871a2017-11-01 17:41:01 -07003943 if (layer->setLayer(s.z) && idx >= 0) {
Mathias Agopiane57f2922012-08-09 16:29:12 -07003944 mCurrentState.layersSortedByZ.removeAt(idx);
3945 mCurrentState.layersSortedByZ.add(layer);
3946 // we need traversal (state changed)
3947 // AND transaction (list changed)
3948 flags |= eTransactionNeeded|eTraversalNeeded;
3949 }
chaviw8b3871a2017-11-01 17:41:01 -07003950 } else {
3951 if (p->setChildLayer(layer, s.z)) {
chaviw06178942017-07-27 10:25:59 -07003952 flags |= eTransactionNeeded|eTraversalNeeded;
3953 }
3954 }
chaviw8b3871a2017-11-01 17:41:01 -07003955 }
3956 if (what & layer_state_t::eRelativeLayerChanged) {
Robert Carr503c7042017-09-27 15:06:08 -07003957 // NOTE: index needs to be calculated before we update the state
3958 const auto& p = layer->getParent();
Robert Carrbc384962021-01-27 15:44:50 -08003959 const auto& relativeHandle = s.relativeLayerSurfaceControl ?
3960 s.relativeLayerSurfaceControl->getHandle() : nullptr;
Robert Carr503c7042017-09-27 15:06:08 -07003961 if (p == nullptr) {
3962 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
Robert Carrbc384962021-01-27 15:44:50 -08003963 if (layer->setRelativeLayer(relativeHandle, s.z) &&
Pablo Gamito11dcc222020-09-12 15:49:39 +00003964 idx >= 0) {
Robert Carr503c7042017-09-27 15:06:08 -07003965 mCurrentState.layersSortedByZ.removeAt(idx);
3966 mCurrentState.layersSortedByZ.add(layer);
3967 // we need traversal (state changed)
3968 // AND transaction (list changed)
3969 flags |= eTransactionNeeded|eTraversalNeeded;
3970 }
3971 } else {
Robert Carrbc384962021-01-27 15:44:50 -08003972 if (p->setChildRelativeLayer(layer, relativeHandle, s.z)) {
Robert Carr503c7042017-09-27 15:06:08 -07003973 flags |= eTransactionNeeded|eTraversalNeeded;
3974 }
chaviw8b3871a2017-11-01 17:41:01 -07003975 }
3976 }
3977 if (what & layer_state_t::eSizeChanged) {
3978 if (layer->setSize(s.w, s.h)) {
3979 flags |= eTraversalNeeded;
3980 }
3981 }
3982 if (what & layer_state_t::eAlphaChanged) {
3983 if (layer->setAlpha(s.alpha))
3984 flags |= eTraversalNeeded;
3985 }
3986 if (what & layer_state_t::eColorChanged) {
3987 if (layer->setColor(s.color))
3988 flags |= eTraversalNeeded;
3989 }
Peiyong Lind3788632018-09-18 16:01:31 -07003990 if (what & layer_state_t::eColorTransformChanged) {
3991 if (layer->setColorTransform(s.colorTransform)) {
3992 flags |= eTraversalNeeded;
3993 }
3994 }
Valerie Haudd0b7572019-01-29 14:59:27 -08003995 if (what & layer_state_t::eBackgroundColorChanged) {
3996 if (layer->setBackgroundColor(s.color, s.bgColorAlpha, s.bgColorDataspace)) {
3997 flags |= eTraversalNeeded;
3998 }
3999 }
chaviw8b3871a2017-11-01 17:41:01 -07004000 if (what & layer_state_t::eMatrixChanged) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07004001 // TODO: b/109894387
4002 //
4003 // SurfaceFlinger's renderer is not prepared to handle cropping in the face of arbitrary
4004 // rotation. To see the problem observe that if we have a square parent, and a child
4005 // of the same size, then we rotate the child 45 degrees around it's center, the child
4006 // must now be cropped to a non rectangular 8 sided region.
4007 //
4008 // Of course we can fix this in the future. For now, we are lucky, SurfaceControl is
Hongwei Wang46213ea2020-12-04 17:17:31 -08004009 // private API, and arbitrary rotation is used in limited use cases, for instance:
4010 // - WindowManager only uses rotation in one case, which is on a top level layer in which
4011 // cropping is not an issue.
4012 // - Launcher, as a privileged app, uses this to transition an application to PiP
4013 // (picture-in-picture) mode.
Robert Carrd4ae7f32018-06-07 16:10:57 -07004014 //
4015 // However given that abuse of rotation matrices could lead to surfaces extending outside
Hongwei Wang46213ea2020-12-04 17:17:31 -08004016 // of cropped areas, we need to prevent non-root clients without permission
4017 // ACCESS_SURFACE_FLINGER nor ROTATE_SURFACE_FLINGER
4018 // (a.k.a. everyone except WindowManager / tests / Launcher) from setting non rectangle
4019 // preserving transformations.
Vishnu Nair24e3bba2021-02-23 14:19:36 -08004020 const bool allowNonRectPreservingTransforms =
4021 permissions & Permission::ROTATE_SURFACE_FLINGER;
Hongwei Wang46213ea2020-12-04 17:17:31 -08004022 if (layer->setMatrix(s.matrix, allowNonRectPreservingTransforms)) flags |= eTraversalNeeded;
chaviw8b3871a2017-11-01 17:41:01 -07004023 }
4024 if (what & layer_state_t::eTransparentRegionChanged) {
4025 if (layer->setTransparentRegionHint(s.transparentRegion))
4026 flags |= eTraversalNeeded;
4027 }
4028 if (what & layer_state_t::eFlagsChanged) {
4029 if (layer->setFlags(s.flags, s.mask))
4030 flags |= eTraversalNeeded;
4031 }
Lucas Dupin1b6531c2018-07-05 17:18:21 -07004032 if (what & layer_state_t::eCornerRadiusChanged) {
4033 if (layer->setCornerRadius(s.cornerRadius))
4034 flags |= eTraversalNeeded;
4035 }
Galia Peycheva33713f72021-05-27 10:24:20 +02004036 if (what & layer_state_t::eBackgroundBlurRadiusChanged && mSupportsBlur) {
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08004037 if (layer->setBackgroundBlurRadius(s.backgroundBlurRadius)) flags |= eTraversalNeeded;
4038 }
Galia Peychevae11d5752021-01-22 13:50:16 +00004039 if (what & layer_state_t::eBlurRegionsChanged) {
Lucas Dupinc3800b82020-10-02 16:24:48 -07004040 if (layer->setBlurRegions(s.blurRegions)) flags |= eTraversalNeeded;
4041 }
chaviw8b3871a2017-11-01 17:41:01 -07004042 if (what & layer_state_t::eLayerStackChanged) {
4043 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
4044 // We only allow setting layer stacks for top level layers,
4045 // everything else inherits layer stack from its parent.
4046 if (layer->hasParent()) {
4047 ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004048 layer->getDebugName());
chaviw8b3871a2017-11-01 17:41:01 -07004049 } else if (idx < 0) {
4050 ALOGE("Attempt to set layer stack on layer without parent (%s) that "
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004051 "that also does not appear in the top level layer list. Something"
4052 " has gone wrong.",
4053 layer->getDebugName());
chaviw8b3871a2017-11-01 17:41:01 -07004054 } else if (layer->setLayerStack(s.layerStack)) {
4055 mCurrentState.layersSortedByZ.removeAt(idx);
4056 mCurrentState.layersSortedByZ.add(layer);
4057 // we need traversal (state changed)
4058 // AND transaction (list changed)
Vishnu Nair6213bd92020-05-08 17:42:25 -07004059 flags |= eTransactionNeeded | eTraversalNeeded | eTransformHintUpdateNeeded;
chaviw8b3871a2017-11-01 17:41:01 -07004060 }
4061 }
Marissa Wall61c58622018-07-18 10:12:20 -07004062 if (what & layer_state_t::eTransformChanged) {
4063 if (layer->setTransform(s.transform)) flags |= eTraversalNeeded;
4064 }
4065 if (what & layer_state_t::eTransformToDisplayInverseChanged) {
4066 if (layer->setTransformToDisplayInverse(s.transformToDisplayInverse))
4067 flags |= eTraversalNeeded;
4068 }
4069 if (what & layer_state_t::eCropChanged) {
4070 if (layer->setCrop(s.crop)) flags |= eTraversalNeeded;
4071 }
Marissa Wall61c58622018-07-18 10:12:20 -07004072 if (what & layer_state_t::eAcquireFenceChanged) {
4073 if (layer->setAcquireFence(s.acquireFence)) flags |= eTraversalNeeded;
4074 }
4075 if (what & layer_state_t::eDataspaceChanged) {
4076 if (layer->setDataspace(s.dataspace)) flags |= eTraversalNeeded;
4077 }
4078 if (what & layer_state_t::eHdrMetadataChanged) {
4079 if (layer->setHdrMetadata(s.hdrMetadata)) flags |= eTraversalNeeded;
4080 }
4081 if (what & layer_state_t::eSurfaceDamageRegionChanged) {
4082 if (layer->setSurfaceDamageRegion(s.surfaceDamageRegion)) flags |= eTraversalNeeded;
4083 }
4084 if (what & layer_state_t::eApiChanged) {
4085 if (layer->setApi(s.api)) flags |= eTraversalNeeded;
4086 }
4087 if (what & layer_state_t::eSidebandStreamChanged) {
4088 if (layer->setSidebandStream(s.sidebandStream)) flags |= eTraversalNeeded;
4089 }
Robert Carr720e5062018-07-30 17:45:14 -07004090 if (what & layer_state_t::eInputInfoChanged) {
Vishnu Nairce5d0cc2019-02-28 14:38:41 -08004091 if (privileged) {
chaviw3277faf2021-05-19 16:45:23 -05004092 layer->setInputInfo(*s.windowInfoHandle->getInfo());
Robert Carr11ac2012019-01-22 09:05:25 -08004093 flags |= eTraversalNeeded;
4094 } else {
chaviw3277faf2021-05-19 16:45:23 -05004095 ALOGE("Attempt to update WindowInfo without permission ACCESS_SURFACE_FLINGER");
Robert Carr11ac2012019-01-22 09:05:25 -08004096 }
Robert Carr720e5062018-07-30 17:45:14 -07004097 }
Vishnu Nairadf632b2021-01-07 14:05:08 -08004098 std::optional<nsecs_t> dequeueBufferTimestamp;
Evan Rosky1f6d6d52018-12-06 10:47:26 -08004099 if (what & layer_state_t::eMetadataChanged) {
Vishnu Nairadf632b2021-01-07 14:05:08 -08004100 dequeueBufferTimestamp = s.metadata.getInt64(METADATA_DEQUEUE_TIME);
Adithya Srinivasanac977e62021-05-21 22:50:56 +00004101 auto gameMode = s.metadata.getInt32(METADATA_GAME_MODE, -1);
4102 if (gameMode != -1) {
4103 // The transaction will be received on the Task layer and needs to be applied to all
4104 // child layers. Child layers that are added at a later point will obtain the game mode
4105 // info through addChild().
4106 layer->setGameModeForTree(gameMode);
4107 }
Evan Rosky1f6d6d52018-12-06 10:47:26 -08004108 if (layer->setMetadata(s.metadata)) flags |= eTraversalNeeded;
4109 }
Peiyong Linc502cb72019-03-01 15:00:23 -08004110 if (what & layer_state_t::eColorSpaceAgnosticChanged) {
4111 if (layer->setColorSpaceAgnostic(s.colorSpaceAgnostic)) {
4112 flags |= eTraversalNeeded;
4113 }
4114 }
Vishnu Nairc97b8db2019-10-29 18:19:35 -07004115 if (what & layer_state_t::eShadowRadiusChanged) {
4116 if (layer->setShadowRadius(s.shadowRadius)) flags |= eTraversalNeeded;
4117 }
Ana Krulecc84d09b2019-11-02 23:10:29 +01004118 if (what & layer_state_t::eFrameRateSelectionPriority) {
4119 if (privileged && layer->setFrameRateSelectionPriority(s.frameRateSelectionPriority)) {
4120 flags |= eTraversalNeeded;
4121 }
4122 }
Steven Thomas3172e202020-01-06 19:25:30 -08004123 if (what & layer_state_t::eFrameRateChanged) {
Marin Shalamanovc5986772021-03-16 16:09:49 +01004124 if (ValidateFrameRate(s.frameRate, s.frameRateCompatibility, s.changeFrameRateStrategy,
4125 "SurfaceFlinger::setClientStateLocked", privileged)) {
4126 const auto compatibility =
4127 Layer::FrameRate::convertCompatibility(s.frameRateCompatibility);
4128 const auto strategy =
4129 Layer::FrameRate::convertChangeFrameRateStrategy(s.changeFrameRateStrategy);
4130
4131 if (layer->setFrameRate(Layer::FrameRate(Fps(s.frameRate), compatibility, strategy))) {
4132 flags |= eTraversalNeeded;
4133 }
Steven Thomas62a4cf82020-01-31 12:04:03 -08004134 }
Steven Thomas3172e202020-01-06 19:25:30 -08004135 }
Vishnu Nair6213bd92020-05-08 17:42:25 -07004136 if (what & layer_state_t::eFixedTransformHintChanged) {
4137 if (layer->setFixedTransformHint(s.fixedTransformHint)) {
4138 flags |= eTraversalNeeded | eTransformHintUpdateNeeded;
4139 }
4140 }
Vishnu Naircf26a0a2020-11-13 12:56:20 -08004141 if (what & layer_state_t::eAutoRefreshChanged) {
4142 layer->setAutoRefresh(s.autoRefresh);
4143 }
Winson Chunga30f7c92021-06-29 15:42:56 -07004144 if (what & layer_state_t::eTrustedOverlayChanged) {
4145 if (privileged) {
4146 if (layer->setTrustedOverlay(s.isTrustedOverlay)) {
4147 flags |= eTraversalNeeded;
4148 }
4149 } else {
4150 ALOGE("Attempt to set trusted overlay without permission ACCESS_SURFACE_FLINGER");
4151 }
4152 }
John Reckcdb4ed72021-02-04 13:39:33 -05004153 if (what & layer_state_t::eStretchChanged) {
4154 if (layer->setStretchEffect(s.stretchEffect)) {
4155 flags |= eTraversalNeeded;
4156 }
4157 }
chaviwf3f40fe2021-04-27 15:54:02 -05004158 if (what & layer_state_t::eBufferCropChanged) {
4159 if (layer->setBufferCrop(s.bufferCrop)) {
4160 flags |= eTraversalNeeded;
4161 }
4162 }
Vishnu Nair6bdec7d2021-05-10 15:01:13 -07004163 if (what & layer_state_t::eDestinationFrameChanged) {
4164 if (layer->setDestinationFrame(s.destinationFrame)) {
4165 flags |= eTraversalNeeded;
4166 }
4167 }
Vishnu Nair14d76922019-08-05 08:41:20 -07004168 // This has to happen after we reparent children because when we reparent to null we remove
4169 // child layers from current state and remove its relative z. If the children are reparented in
4170 // the same transaction, then we have to make sure we reparent the children first so we do not
4171 // lose its relative z order.
4172 if (what & layer_state_t::eReparent) {
4173 bool hadParent = layer->hasParent();
Pablo Gamito11dcc222020-09-12 15:49:39 +00004174 auto parentHandle = (s.parentSurfaceControlForChild)
4175 ? s.parentSurfaceControlForChild->getHandle()
4176 : nullptr;
4177 if (layer->reparent(parentHandle)) {
Vishnu Nair14d76922019-08-05 08:41:20 -07004178 if (!hadParent) {
Vishnu Nair14d218b2021-07-13 13:57:39 -07004179 layer->setIsAtRoot(false);
Vishnu Nair14d76922019-08-05 08:41:20 -07004180 mCurrentState.layersSortedByZ.remove(layer);
4181 }
4182 flags |= eTransactionNeeded | eTraversalNeeded;
4183 }
4184 }
Marissa Walle2ffb422018-10-12 11:33:52 -07004185 std::vector<sp<CallbackHandle>> callbackHandles;
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07004186 if ((what & layer_state_t::eHasListenerCallbacksChanged) && (!filteredListeners.empty())) {
4187 for (auto& [listener, callbackIds] : filteredListeners) {
Marissa Walle2ffb422018-10-12 11:33:52 -07004188 callbackHandles.emplace_back(new CallbackHandle(listener, callbackIds, s.surface));
4189 }
4190 }
Marissa Wall78b72202019-03-15 14:58:34 -07004191 bool bufferChanged = what & layer_state_t::eBufferChanged;
4192 bool cacheIdChanged = what & layer_state_t::eCachedBufferChanged;
Garfield Tan9c9c1912021-07-19 12:02:16 -07004193 bool bufferSizeExceedsLimit = false;
Alec Mouria90a5702021-04-16 16:36:21 +00004194 std::shared_ptr<renderengine::ExternalTexture> buffer;
Alec Mouri4545a8a2019-08-08 20:05:32 -07004195 if (bufferChanged && cacheIdChanged && s.buffer != nullptr) {
Garfield Tan9c9c1912021-07-19 12:02:16 -07004196 bufferSizeExceedsLimit =
4197 exceedsMaxRenderTargetSize(s.buffer->getWidth(), s.buffer->getHeight());
4198 if (!bufferSizeExceedsLimit) {
4199 ClientCache::getInstance().add(s.cachedBuffer, s.buffer);
4200 buffer = ClientCache::getInstance().get(s.cachedBuffer);
4201 }
Marissa Wall78b72202019-03-15 14:58:34 -07004202 } else if (cacheIdChanged) {
Marissa Wall947d34e2019-03-29 14:03:53 -07004203 buffer = ClientCache::getInstance().get(s.cachedBuffer);
Alec Mouria90a5702021-04-16 16:36:21 +00004204 } else if (bufferChanged && s.buffer != nullptr) {
Garfield Tan9c9c1912021-07-19 12:02:16 -07004205 bufferSizeExceedsLimit =
4206 exceedsMaxRenderTargetSize(s.buffer->getWidth(), s.buffer->getHeight());
4207 if (!bufferSizeExceedsLimit) {
4208 buffer = std::make_shared<
4209 renderengine::ExternalTexture>(s.buffer, getRenderEngine(),
4210 renderengine::ExternalTexture::Usage::READABLE);
4211 }
Marissa Wall73411622019-01-25 10:45:41 -08004212 }
Garfield Tan9c9c1912021-07-19 12:02:16 -07004213 ALOGE_IF(bufferSizeExceedsLimit,
4214 "Attempted to create an ExternalTexture for layer %s that exceeds render target size "
4215 "limit.",
4216 layer->getDebugName());
Marissa Wall78b72202019-03-15 14:58:34 -07004217 if (buffer) {
Vishnu Nair6b7c5c92020-09-29 17:27:05 -07004218 const bool frameNumberChanged = what & layer_state_t::eFrameNumberChanged;
4219 const uint64_t frameNumber = frameNumberChanged
4220 ? s.frameNumber
4221 : layer->getHeadFrameNumber(-1 /* expectedPresentTime */) + 1;
4222
Ady Abrahamf0c56492020-12-17 18:04:15 -08004223 if (layer->setBuffer(buffer, s.acquireFence, postTime, desiredPresentTime, isAutoTimestamp,
Ady Abraham8db10102021-03-15 17:19:23 -07004224 s.cachedBuffer, frameNumber, dequeueBufferTimestamp, frameTimelineInfo,
Vishnu Nair1506b182021-02-22 14:35:15 -08004225 s.releaseBufferListener)) {
Valerie Haubc6ddb12019-03-08 11:10:15 -08004226 flags |= eTraversalNeeded;
Valerie Haubc6ddb12019-03-08 11:10:15 -08004227 }
Ady Abraham8db10102021-03-15 17:19:23 -07004228 } else if (frameTimelineInfo.vsyncId != FrameTimelineInfo::INVALID_VSYNC_ID) {
4229 layer->setFrameTimelineVsyncForBufferlessTransaction(frameTimelineInfo, postTime);
Marissa Wallebc2c052019-01-16 19:16:55 -08004230 }
Ady Abraham22c7b5c2020-09-22 19:33:40 -07004231
Marissa Walle2ffb422018-10-12 11:33:52 -07004232 if (layer->setTransactionCompletedListeners(callbackHandles)) flags |= eTraversalNeeded;
4233 // Do not put anything that updates layer state or modifies flags after
4234 // setTransactionCompletedListener
Mathias Agopiane57f2922012-08-09 16:29:12 -07004235 return flags;
4236}
4237
chaviw273171b2018-12-26 11:46:30 -08004238uint32_t SurfaceFlinger::addInputWindowCommands(const InputWindowCommands& inputWindowCommands) {
Arthur Hung58144272021-01-16 03:43:53 +00004239 bool hasChanges = mInputWindowCommands.merge(inputWindowCommands);
Vishnu Naire798b472020-07-23 13:52:21 -07004240 return hasChanges ? eTraversalNeeded : 0;
chaviw273171b2018-12-26 11:46:30 -08004241}
4242
chaviwfe94a222019-08-21 13:52:59 -07004243status_t SurfaceFlinger::mirrorLayer(const sp<Client>& client, const sp<IBinder>& mirrorFromHandle,
Ady Abraham9f0a4002020-10-05 15:47:26 -07004244 sp<IBinder>* outHandle, int32_t* outLayerId) {
chaviwfe94a222019-08-21 13:52:59 -07004245 if (!mirrorFromHandle) {
4246 return NAME_NOT_FOUND;
4247 }
4248
4249 sp<Layer> mirrorLayer;
4250 sp<Layer> mirrorFrom;
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004251 std::string uniqueName = getUniqueLayerName("MirrorRoot");
chaviwfe94a222019-08-21 13:52:59 -07004252
4253 {
4254 Mutex::Autolock _l(mStateLock);
Alec Mouri9a02eda2020-04-21 17:39:34 -07004255 mirrorFrom = fromHandleLocked(mirrorFromHandle).promote();
chaviwfe94a222019-08-21 13:52:59 -07004256 if (!mirrorFrom) {
4257 return NAME_NOT_FOUND;
4258 }
4259
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004260 status_t result = createContainerLayer(client, std::move(uniqueName), -1, -1, 0,
4261 LayerMetadata(), outHandle, &mirrorLayer);
chaviwfe94a222019-08-21 13:52:59 -07004262 if (result != NO_ERROR) {
4263 return result;
4264 }
4265
Robert Carr6a0382d2021-07-01 15:57:17 -07004266 mirrorLayer->setClonedChild(mirrorFrom->createClone());
chaviwfe94a222019-08-21 13:52:59 -07004267 }
4268
Ady Abraham9f0a4002020-10-05 15:47:26 -07004269 *outLayerId = mirrorLayer->sequence;
Vishnu Nair6213bd92020-05-08 17:42:25 -07004270 return addClientLayer(client, *outHandle, nullptr, mirrorLayer, nullptr, nullptr, false,
4271 nullptr /* outTransformHint */);
chaviwfe94a222019-08-21 13:52:59 -07004272}
4273
Marissa Wall2d814fb2019-04-09 18:52:57 +00004274status_t SurfaceFlinger::createLayer(const String8& name, const sp<Client>& client, uint32_t w,
4275 uint32_t h, PixelFormat format, uint32_t flags,
4276 LayerMetadata metadata, sp<IBinder>* handle,
Robert Carrc0df3122019-04-11 13:18:21 -07004277 sp<IGraphicBufferProducer>* gbp,
Ady Abraham9f0a4002020-10-05 15:47:26 -07004278 const sp<IBinder>& parentHandle, int32_t* outLayerId,
4279 const sp<Layer>& parentLayer, uint32_t* outTransformHint) {
Mathias Agopian6e2d6482009-07-09 18:16:43 -07004280 if (int32_t(w|h) < 0) {
Mathias Agopian921e6ac2012-07-23 23:11:29 -07004281 ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
Mathias Agopian6e2d6482009-07-09 18:16:43 -07004282 int(w), int(h));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004283 return BAD_VALUE;
Mathias Agopian6e2d6482009-07-09 18:16:43 -07004284 }
Andreas Huber8b42e8a2010-08-16 08:49:37 -07004285
Robert Carrc0df3122019-04-11 13:18:21 -07004286 ALOG_ASSERT(parentLayer == nullptr || parentHandle == nullptr,
4287 "Expected only one of parentLayer or parentHandle to be non-null. "
4288 "Programmer error?");
4289
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004290 status_t result = NO_ERROR;
4291
4292 sp<Layer> layer;
4293
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004294 std::string uniqueName = getUniqueLayerName(name.string());
Cody Northropbc755282017-03-31 12:00:08 -06004295
Mathias Agopian3165cc22012-08-08 19:42:09 -07004296 switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
Marissa Wall61c58622018-07-18 10:12:20 -07004297 case ISurfaceComposerClient::eFXSurfaceBufferQueue:
Vishnu Nair8eda69e2021-02-26 10:42:10 -08004298 case ISurfaceComposerClient::eFXSurfaceBufferState: {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004299 result = createBufferStateLayer(client, std::move(uniqueName), w, h, flags,
Vishnu Nair6213bd92020-05-08 17:42:25 -07004300 std::move(metadata), handle, &layer);
Vishnu Nair8eda69e2021-02-26 10:42:10 -08004301 std::atomic<int32_t>* pendingBufferCounter = layer->getPendingBufferCounter();
4302 if (pendingBufferCounter) {
4303 std::string counterName = layer->getPendingBufferCounterName();
4304 mBufferCountTracker.add((*handle)->localBinder(), counterName,
4305 pendingBufferCounter);
4306 }
4307 } break;
Vishnu Nairfa247b12020-02-11 08:58:26 -08004308 case ISurfaceComposerClient::eFXSurfaceEffect:
Vishnu Nair88a11f22018-11-28 18:30:57 -08004309 // check if buffer size is set for color layer.
4310 if (w > 0 || h > 0) {
4311 ALOGE("createLayer() failed, w or h cannot be set for color layer (w=%d, h=%d)",
4312 int(w), int(h));
4313 return BAD_VALUE;
4314 }
4315
Vishnu Nairfa247b12020-02-11 08:58:26 -08004316 result = createEffectLayer(client, std::move(uniqueName), w, h, flags,
4317 std::move(metadata), handle, &layer);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004318 break;
Robert Carr6b3f6c52018-08-13 13:05:17 -07004319 case ISurfaceComposerClient::eFXSurfaceContainer:
Vishnu Nair88a11f22018-11-28 18:30:57 -08004320 // check if buffer size is set for container layer.
4321 if (w > 0 || h > 0) {
4322 ALOGE("createLayer() failed, w or h cannot be set for container layer (w=%d, h=%d)",
4323 int(w), int(h));
4324 return BAD_VALUE;
4325 }
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004326 result = createContainerLayer(client, std::move(uniqueName), w, h, flags,
4327 std::move(metadata), handle, &layer);
Robert Carr6b3f6c52018-08-13 13:05:17 -07004328 break;
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004329 default:
4330 result = BAD_VALUE;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004331 break;
4332 }
4333
Dan Stoza7d89d062015-04-30 13:29:25 -07004334 if (result != NO_ERROR) {
4335 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004336 }
Dan Stoza7d89d062015-04-30 13:29:25 -07004337
chaviwe0c7b822021-07-20 10:16:05 -05004338 bool addToRoot = callingThreadHasUnscopedSurfaceFlingerAccess();
4339 result = addClientLayer(client, *handle, *gbp, layer, parentHandle, parentLayer, addToRoot,
4340 outTransformHint);
Dan Stoza7d89d062015-04-30 13:29:25 -07004341 if (result != NO_ERROR) {
4342 return result;
4343 }
Lloyd Pique4dccc412018-01-22 17:21:36 -08004344 mInterceptor->saveSurfaceCreation(layer);
Dan Stoza7d89d062015-04-30 13:29:25 -07004345
4346 setTransactionFlags(eTransactionNeeded);
Ady Abraham9f0a4002020-10-05 15:47:26 -07004347 *outLayerId = layer->sequence;
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004348 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004349}
4350
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004351std::string SurfaceFlinger::getUniqueLayerName(const char* name) {
4352 unsigned dupeCounter = 0;
Cody Northropbc755282017-03-31 12:00:08 -06004353
4354 // Tack on our counter whether there is a hit or not, so everyone gets a tag
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004355 std::string uniqueName = base::StringPrintf("%s#%u", name, dupeCounter);
Cody Northropbc755282017-03-31 12:00:08 -06004356
Dan Stoza436ccf32018-06-21 12:10:12 -07004357 // Grab the state lock since we're accessing mCurrentState
4358 Mutex::Autolock lock(mStateLock);
4359
Cody Northropbc755282017-03-31 12:00:08 -06004360 // Loop over layers until we're sure there is no matching name
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004361 bool matchFound = true;
Cody Northropbc755282017-03-31 12:00:08 -06004362 while (matchFound) {
4363 matchFound = false;
Edgar Arriaga844fa672020-01-16 14:21:42 -08004364 mCurrentState.traverse([&](Layer* layer) {
Cody Northropbc755282017-03-31 12:00:08 -06004365 if (layer->getName() == uniqueName) {
4366 matchFound = true;
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004367 uniqueName = base::StringPrintf("%s#%u", name, ++dupeCounter);
Cody Northropbc755282017-03-31 12:00:08 -06004368 }
4369 });
4370 }
4371
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004372 ALOGV_IF(dupeCounter > 0, "duplicate layer name: changing %s to %s", name, uniqueName.c_str());
Cody Northropbc755282017-03-31 12:00:08 -06004373 return uniqueName;
4374}
4375
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004376status_t SurfaceFlinger::createBufferQueueLayer(const sp<Client>& client, std::string name,
Marissa Wallfd668622018-05-10 10:21:13 -07004377 uint32_t w, uint32_t h, uint32_t flags,
Evan Roskya1f1e152019-01-24 16:17:46 -08004378 LayerMetadata metadata, PixelFormat& format,
4379 sp<IBinder>* handle,
Marissa Wallfd668622018-05-10 10:21:13 -07004380 sp<IGraphicBufferProducer>* gbp,
4381 sp<Layer>* outLayer) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004382 // initialize the surfaces
Mathias Agopian92a979a2012-08-02 18:32:23 -07004383 switch (format) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004384 case PIXEL_FORMAT_TRANSPARENT:
4385 case PIXEL_FORMAT_TRANSLUCENT:
4386 format = PIXEL_FORMAT_RGBA_8888;
4387 break;
4388 case PIXEL_FORMAT_OPAQUE:
Mathias Agopian8f105402010-04-05 18:01:24 -07004389 format = PIXEL_FORMAT_RGBX_8888;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004390 break;
4391 }
4392
chaviwb4c6e582019-08-16 14:35:07 -07004393 sp<BufferQueueLayer> layer;
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004394 LayerCreationArgs args(this, client, std::move(name), w, h, flags, std::move(metadata));
chaviwb4c6e582019-08-16 14:35:07 -07004395 args.textureName = getNewTexture();
4396 {
4397 // Grab the SF state lock during this since it's the only safe way to access
4398 // RenderEngine when creating a BufferLayerConsumer
4399 // TODO: Check if this lock is still needed here
4400 Mutex::Autolock lock(mStateLock);
4401 layer = getFactory().createBufferQueueLayer(args);
4402 }
4403
Marissa Wallfd668622018-05-10 10:21:13 -07004404 status_t err = layer->setDefaultBufferProperties(w, h, format);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004405 if (err == NO_ERROR) {
David Sodman0c69cad2017-08-21 12:12:51 -07004406 *handle = layer->getHandle();
4407 *gbp = layer->getProducer();
4408 *outLayer = layer;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004409 }
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004410
Marissa Wallfd668622018-05-10 10:21:13 -07004411 ALOGE_IF(err, "createBufferQueueLayer() failed (%s)", strerror(-err));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004412 return err;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004413}
4414
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004415status_t SurfaceFlinger::createBufferStateLayer(const sp<Client>& client, std::string name,
Marissa Wall61c58622018-07-18 10:12:20 -07004416 uint32_t w, uint32_t h, uint32_t flags,
Evan Roskya1f1e152019-01-24 16:17:46 -08004417 LayerMetadata metadata, sp<IBinder>* handle,
Vishnu Nair6213bd92020-05-08 17:42:25 -07004418 sp<Layer>* outLayer) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004419 LayerCreationArgs args(this, client, std::move(name), w, h, flags, std::move(metadata));
chaviwb4c6e582019-08-16 14:35:07 -07004420 args.textureName = getNewTexture();
arthurhungdba591c2021-02-08 17:28:49 +08004421 sp<BufferStateLayer> layer = getFactory().createBufferStateLayer(args);
Marissa Wall61c58622018-07-18 10:12:20 -07004422 *handle = layer->getHandle();
4423 *outLayer = layer;
4424
4425 return NO_ERROR;
4426}
4427
Vishnu Nairfa247b12020-02-11 08:58:26 -08004428status_t SurfaceFlinger::createEffectLayer(const sp<Client>& client, std::string name, uint32_t w,
4429 uint32_t h, uint32_t flags, LayerMetadata metadata,
4430 sp<IBinder>* handle, sp<Layer>* outLayer) {
4431 *outLayer = getFactory().createEffectLayer(
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004432 {this, client, std::move(name), w, h, flags, std::move(metadata)});
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004433 *handle = (*outLayer)->getHandle();
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004434 return NO_ERROR;
Mathias Agopian118d0242011-10-13 16:02:48 -07004435}
4436
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004437status_t SurfaceFlinger::createContainerLayer(const sp<Client>& client, std::string name,
Evan Roskya1f1e152019-01-24 16:17:46 -08004438 uint32_t w, uint32_t h, uint32_t flags,
4439 LayerMetadata metadata, sp<IBinder>* handle,
4440 sp<Layer>* outLayer) {
4441 *outLayer = getFactory().createContainerLayer(
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004442 {this, client, std::move(name), w, h, flags, std::move(metadata)});
Robert Carr6b3f6c52018-08-13 13:05:17 -07004443 *handle = (*outLayer)->getHandle();
4444 return NO_ERROR;
4445}
4446
Robert Carr6fb1a7e2018-12-11 12:07:25 -08004447void SurfaceFlinger::markLayerPendingRemovalLocked(const sp<Layer>& layer) {
Robert Carr2e102c92018-10-23 12:11:15 -07004448 mLayersPendingRemoval.add(layer);
4449 mLayersRemoved = true;
4450 setTransactionFlags(eTransactionNeeded);
4451}
4452
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01004453void SurfaceFlinger::onHandleDestroyed(sp<Layer>& layer) {
Robert Carr2e102c92018-10-23 12:11:15 -07004454 Mutex::Autolock lock(mStateLock);
Robert Carr6fb1a7e2018-12-11 12:07:25 -08004455 // If a layer has a parent, we allow it to out-live it's handle
4456 // with the idea that the parent holds a reference and will eventually
4457 // be cleaned up. However no one cleans up the top-level so we do so
4458 // here.
Vishnu Nair14d218b2021-07-13 13:57:39 -07004459 if (layer->isAtRoot()) {
4460 layer->setIsAtRoot(false);
Robert Carr6fb1a7e2018-12-11 12:07:25 -08004461 mCurrentState.layersSortedByZ.remove(layer);
4462 }
4463 markLayerPendingRemovalLocked(layer);
Robert Carrc0df3122019-04-11 13:18:21 -07004464
4465 auto it = mLayersByLocalBinderToken.begin();
4466 while (it != mLayersByLocalBinderToken.end()) {
4467 if (it->second == layer) {
Vishnu Nair8eda69e2021-02-26 10:42:10 -08004468 mBufferCountTracker.remove(it->first->localBinder());
Robert Carrc0df3122019-04-11 13:18:21 -07004469 it = mLayersByLocalBinderToken.erase(it);
4470 } else {
4471 it++;
4472 }
4473 }
4474
Robert Carr695d5282018-12-18 15:27:58 -08004475 layer.clear();
Rob Carr4bba3702018-10-08 21:53:30 +00004476}
4477
Mathias Agopianb60314a2012-04-10 22:09:54 -07004478// ---------------------------------------------------------------------------
4479
Andy McFadden13a082e2012-08-24 10:16:42 -07004480void SurfaceFlinger::onInitializeDisplays() {
Dominik Laskowski83b88212018-12-11 13:34:06 -08004481 const auto display = getDefaultDisplayDeviceLocked();
4482 if (!display) return;
4483
4484 const sp<IBinder> token = display->getDisplayToken().promote();
4485 LOG_ALWAYS_FATAL_IF(token == nullptr);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004486
Jesse Hall01e29052013-02-19 16:13:35 -08004487 // reset screen orientation and use primary layer stack
Andy McFadden13a082e2012-08-24 10:16:42 -07004488 Vector<ComposerState> state;
4489 Vector<DisplayState> displays;
4490 DisplayState d;
Jesse Hall01e29052013-02-19 16:13:35 -08004491 d.what = DisplayState::eDisplayProjectionChanged |
4492 DisplayState::eLayerStackChanged;
Dominik Laskowski83b88212018-12-11 13:34:06 -08004493 d.token = token;
Jesse Hall01e29052013-02-19 16:13:35 -08004494 d.layerStack = 0;
Dominik Laskowski718f9602019-11-09 20:01:35 -08004495 d.orientation = ui::ROTATION_0;
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02004496 d.orientedDisplaySpaceRect.makeInvalid();
4497 d.layerStackSpaceRect.makeInvalid();
Michael Lentine47e45402014-07-18 15:34:25 -07004498 d.width = 0;
4499 d.height = 0;
Andy McFadden13a082e2012-08-24 10:16:42 -07004500 displays.add(d);
Arthur Hung58144272021-01-16 03:43:53 +00004501
Vishnu Nair9a69a042021-06-18 13:19:49 -07004502 nsecs_t now = systemTime();
Arthur Hung58144272021-01-16 03:43:53 +00004503 // It should be on the main thread, apply it directly.
4504 applyTransactionState(FrameTimelineInfo{}, state, displays, 0, mInputWindowCommands,
Vishnu Nair9a69a042021-06-18 13:19:49 -07004505 /* desiredPresentTime */ now, true, {}, /* postTime */ now, true, false,
4506 {}, getpid(), getuid(), 0 /* Undefined transactionId */);
Jamie Gennis6547ff42013-07-16 20:12:42 -07004507
Peiyong Lin65248e02020-04-18 21:15:07 -07004508 setPowerModeInternal(display, hal::PowerMode::ON);
Ady Abraham3efa3942021-06-24 19:01:25 -07004509 const nsecs_t vsyncPeriod =
4510 display->refreshRateConfigs().getCurrentRefreshRate().getVsyncPeriod();
Dominik Laskowski83b88212018-12-11 13:34:06 -08004511 mAnimFrameTracker.setDisplayRefreshPeriod(vsyncPeriod);
arthurhungdba591c2021-02-08 17:28:49 +08004512 mDefaultDisplayTransformHint = display->getTransformHint();
Brian Andersond0010582017-03-07 13:20:31 -08004513 // Use phase of 0 since phase is not known.
4514 // Use latency of 0, which will snap to the ideal latency.
Dominik Laskowski83b88212018-12-11 13:34:06 -08004515 DisplayStatInfo stats{0 /* vsyncTime */, vsyncPeriod};
Ana Krulece588e312018-09-18 12:32:24 -07004516 setCompositorTimingSnapped(stats, 0);
Andy McFadden13a082e2012-08-24 10:16:42 -07004517}
4518
4519void SurfaceFlinger::initializeDisplays() {
Dominik Laskowski8c001672018-05-30 16:52:06 -07004520 // Async since we may be called from the main thread.
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07004521 static_cast<void>(schedule([this]() MAIN_THREAD { onInitializeDisplays(); }));
Andy McFadden13a082e2012-08-24 10:16:42 -07004522}
4523
Evan Rosky2239b372021-05-20 13:43:47 -07004524sp<DisplayDevice> SurfaceFlinger::getDisplayWithInputByLayer(Layer* layer) const {
4525 sp<DisplayDevice> display;
4526 for (const auto& pair : mDisplays) {
4527 const auto& displayDevice = pair.second;
4528 if (!displayDevice->receivesInput() ||
4529 !displayDevice->getCompositionDisplay()
4530 ->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
4531 continue;
4532 }
4533 // Don't return immediately so that we can log duplicates.
4534 if (display) {
4535 ALOGE("Multiple display devices claim to accept input for the same layerstack: %d",
4536 layer->getLayerStack());
4537 continue;
4538 }
4539 display = displayDevice;
4540 }
4541 return display;
4542}
4543
Peiyong Lin65248e02020-04-18 21:15:07 -07004544void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& display, hal::PowerMode mode) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004545 if (display->isVirtual()) {
4546 ALOGE("%s: Invalid operation on virtual display", __FUNCTION__);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004547 return;
4548 }
4549
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02004550 const auto displayId = display->getPhysicalId();
4551 ALOGD("Setting power mode %d on display %s", mode, to_string(displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004552
Peiyong Lin65248e02020-04-18 21:15:07 -07004553 const hal::PowerMode currentMode = display->getPowerMode();
Dominik Laskowski075d3172018-05-24 15:50:06 -07004554 if (mode == currentMode) {
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004555 return;
4556 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004557
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004558 display->setPowerMode(mode);
4559
Lloyd Pique4dccc412018-01-22 17:21:36 -08004560 if (mInterceptor->isEnabled()) {
Peiyong Lin65248e02020-04-18 21:15:07 -07004561 mInterceptor->savePowerModeUpdate(display->getSequenceId(), static_cast<int32_t>(mode));
Irvelffc9efc2016-07-27 15:16:37 -07004562 }
Ady Abraham3efa3942021-06-24 19:01:25 -07004563 const auto vsyncPeriod = display->refreshRateConfigs().getCurrentRefreshRate().getVsyncPeriod();
Peiyong Lin65248e02020-04-18 21:15:07 -07004564 if (currentMode == hal::PowerMode::OFF) {
Ady Abraham7825c682021-05-17 15:12:14 -07004565 const auto activeDisplay = getDisplayDeviceLocked(mActiveDisplayToken);
4566 if (display->isInternal() && (!activeDisplay || !activeDisplay->isPoweredOn())) {
Ady Abrahamdb036a82021-07-16 14:18:34 -07004567 onActiveDisplayChangedLocked(display);
Ady Abraham7825c682021-05-17 15:12:14 -07004568 }
Wei Wang23aa5a62021-06-04 15:56:57 -07004569 // Keep uclamp in a separate syscall and set it before changing to RT due to b/190237315.
4570 // We can merge the syscall later.
4571 if (SurfaceFlinger::setSchedAttr(true) != NO_ERROR) {
4572 ALOGW("Couldn't set uclamp.min on display on: %s\n", strerror(errno));
4573 }
Martin Liu4a322352020-03-24 21:30:38 +08004574 if (SurfaceFlinger::setSchedFifo(true) != NO_ERROR) {
4575 ALOGW("Couldn't set SCHED_FIFO on display on: %s\n", strerror(errno));
4576 }
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02004577 getHwComposer().setPowerMode(displayId, mode);
Ady Abraham7825c682021-05-17 15:12:14 -07004578 if (display->isInternal() && mode != hal::PowerMode::DOZE_SUSPEND) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02004579 getHwComposer().setVsyncEnabled(displayId, mHWCVsyncPendingState);
Ana Krulecc2870422019-01-29 19:00:58 -08004580 mScheduler->onScreenAcquired(mAppConnectionHandle);
Ady Abraham2492a022020-07-24 11:09:55 -07004581 mScheduler->resyncToHardwareVsync(true, vsyncPeriod);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004582 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004583
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004584 mVisibleRegionsDirty = true;
Dan Stozab90cf072015-03-05 11:05:59 -08004585 mHasPoweredOff = true;
Dan Stozac7a25ad2018-04-12 11:45:09 -07004586 repaintEverything();
Peiyong Lin65248e02020-04-18 21:15:07 -07004587 } else if (mode == hal::PowerMode::OFF) {
Tim Murrayf9d4e442016-08-02 15:43:59 -07004588 // Turn off the display
Martin Liu4a322352020-03-24 21:30:38 +08004589 if (SurfaceFlinger::setSchedFifo(false) != NO_ERROR) {
4590 ALOGW("Couldn't set SCHED_OTHER on display off: %s\n", strerror(errno));
Tim Murrayf9d4e442016-08-02 15:43:59 -07004591 }
Wei Wang23aa5a62021-06-04 15:56:57 -07004592 if (SurfaceFlinger::setSchedAttr(false) != NO_ERROR) {
4593 ALOGW("Couldn't set uclamp.min on display off: %s\n", strerror(errno));
4594 }
Ady Abraham7825c682021-05-17 15:12:14 -07004595 if (display->isInternal() && currentMode != hal::PowerMode::DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08004596 mScheduler->disableHardwareVsync(true);
4597 mScheduler->onScreenReleased(mAppConnectionHandle);
Mathias Agopiancde87a32012-09-13 14:09:01 -07004598 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004599
Ady Abraham27c70212019-06-11 10:52:26 -07004600 // Make sure HWVsync is disabled before turning off the display
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02004601 getHwComposer().setVsyncEnabled(displayId, hal::Vsync::DISABLE);
Ady Abraham27c70212019-06-11 10:52:26 -07004602
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02004603 getHwComposer().setPowerMode(displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004604 mVisibleRegionsDirty = true;
4605 // from this point on, SF will stop drawing on this display
Peiyong Lin65248e02020-04-18 21:15:07 -07004606 } else if (mode == hal::PowerMode::DOZE || mode == hal::PowerMode::ON) {
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004607 // Update display while dozing
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02004608 getHwComposer().setPowerMode(displayId, mode);
Ady Abraham7825c682021-05-17 15:12:14 -07004609 if (display->isInternal() && currentMode == hal::PowerMode::DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08004610 mScheduler->onScreenAcquired(mAppConnectionHandle);
Ady Abraham2492a022020-07-24 11:09:55 -07004611 mScheduler->resyncToHardwareVsync(true, vsyncPeriod);
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004612 }
Peiyong Lin65248e02020-04-18 21:15:07 -07004613 } else if (mode == hal::PowerMode::DOZE_SUSPEND) {
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004614 // Leave display going to doze
Ady Abraham7825c682021-05-17 15:12:14 -07004615 if (display->isInternal()) {
Ana Krulecc2870422019-01-29 19:00:58 -08004616 mScheduler->disableHardwareVsync(true);
4617 mScheduler->onScreenReleased(mAppConnectionHandle);
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004618 }
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02004619 getHwComposer().setPowerMode(displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004620 } else {
Matthew Bouyack38d49612017-05-12 12:49:32 -07004621 ALOGE("Attempting to set unknown power mode: %d\n", mode);
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02004622 getHwComposer().setPowerMode(displayId, mode);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004623 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004624
Ady Abraham7825c682021-05-17 15:12:14 -07004625 if (display->isInternal()) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08004626 mTimeStats->setPowerMode(mode);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07004627 mRefreshRateStats->setPowerMode(mode);
Peiyong Lin65248e02020-04-18 21:15:07 -07004628 mScheduler->setDisplayPowerState(mode == hal::PowerMode::ON);
Yiwei Zhang3a226d22018-10-16 09:23:03 -07004629 }
4630
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02004631 ALOGD("Finished setting power mode %d on display %s", mode, to_string(displayId).c_str());
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004632}
4633
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004634void SurfaceFlinger::setPowerMode(const sp<IBinder>& displayToken, int mode) {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07004635 schedule([=]() MAIN_THREAD {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07004636 const auto display = getDisplayDeviceLocked(displayToken);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004637 if (!display) {
4638 ALOGE("Attempt to set power mode %d for invalid display token %p", mode,
4639 displayToken.get());
4640 } else if (display->isVirtual()) {
4641 ALOGW("Attempt to set power mode %d for virtual display", mode);
4642 } else {
Peiyong Lin65248e02020-04-18 21:15:07 -07004643 setPowerModeInternal(display, static_cast<hal::PowerMode>(mode));
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004644 }
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07004645 }).wait();
Mathias Agopianb60314a2012-04-10 22:09:54 -07004646}
4647
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07004648status_t SurfaceFlinger::doDump(int fd, const DumpArgs& args, bool asProto) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004649 std::string result;
Mathias Agopian99b49842011-06-27 16:05:52 -07004650
Mathias Agopianbd115332013-04-18 16:41:04 -07004651 IPCThreadState* ipc = IPCThreadState::self();
4652 const int pid = ipc->getCallingPid();
4653 const int uid = ipc->getCallingUid();
Vishnu Nair6a408532017-10-24 09:11:27 -07004654
Mathias Agopianbd115332013-04-18 16:41:04 -07004655 if ((uid != AID_SHELL) &&
4656 !PermissionCache::checkPermission(sDump, pid, uid)) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004657 StringAppendF(&result, "Permission Denial: can't dump SurfaceFlinger from pid=%d, uid=%d\n",
4658 pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004659 } else {
Dominik Laskowskic2867142019-01-21 11:33:38 -08004660 static const std::unordered_map<std::string, Dumper> dumpers = {
Dominik Laskowskic2867142019-01-21 11:33:38 -08004661 {"--display-id"s, dumper(&SurfaceFlinger::dumpDisplayIdentificationData)},
Ady Abraham8cb21882020-08-26 18:22:05 -07004662 {"--dispsync"s, dumper([this](std::string& s) { mScheduler->dumpVsync(s); })},
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004663 {"--edid"s, argsDumper(&SurfaceFlinger::dumpRawDisplayIdentificationData)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08004664 {"--frame-events"s, dumper(&SurfaceFlinger::dumpFrameEventsLocked)},
4665 {"--latency"s, argsDumper(&SurfaceFlinger::dumpStatsLocked)},
4666 {"--latency-clear"s, argsDumper(&SurfaceFlinger::clearStatsLocked)},
4667 {"--list"s, dumper(&SurfaceFlinger::listLayersLocked)},
Dan Stoza269dc4d2021-01-15 15:07:43 -08004668 {"--planner"s, argsDumper(&SurfaceFlinger::dumpPlannerInfo)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08004669 {"--static-screen"s, dumper(&SurfaceFlinger::dumpStaticScreenStats)},
4670 {"--timestats"s, protoDumper(&SurfaceFlinger::dumpTimeStats)},
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004671 {"--vsync"s, dumper(&SurfaceFlinger::dumpVSync)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08004672 {"--wide-color"s, dumper(&SurfaceFlinger::dumpWideColorInfo)},
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -07004673 {"--frametimeline"s, argsDumper(&SurfaceFlinger::dumpFrameTimeline)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08004674 };
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004675
Dominik Laskowskic2867142019-01-21 11:33:38 -08004676 const auto flag = args.empty() ? ""s : std::string(String8(args[0]));
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004677
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07004678 bool dumpLayers = true;
4679 {
4680 TimedLock lock(mStateLock, s2ns(1), __FUNCTION__);
4681 if (!lock.locked()) {
4682 StringAppendF(&result, "Dumping without lock after timeout: %s (%d)\n",
4683 strerror(-lock.status), lock.status);
4684 }
4685
4686 if (const auto it = dumpers.find(flag); it != dumpers.end()) {
4687 (it->second)(args, asProto, result);
4688 dumpLayers = false;
4689 } else if (!asProto) {
4690 dumpAllLocked(args, result);
4691 }
Mathias Agopian48b888a2011-01-19 16:15:53 -08004692 }
4693
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07004694 if (dumpLayers) {
Dominik Laskowski46470112019-08-02 13:13:11 -07004695 const LayersProto layersProto = dumpProtoFromMainThread();
4696 if (asProto) {
4697 result.append(layersProto.SerializeAsString());
4698 } else {
Vishnu Nair0f085c62019-08-30 08:49:12 -07004699 // Dump info that we need to access from the main thread
Dominik Laskowski46470112019-08-02 13:13:11 -07004700 const auto layerTree = LayerProtoParser::generateLayerTree(layersProto);
4701 result.append(LayerProtoParser::layerTreeToString(layerTree));
4702 result.append("\n");
Vishnu Nair0f085c62019-08-30 08:49:12 -07004703 dumpOffscreenLayers(result);
Dominik Laskowski46470112019-08-02 13:13:11 -07004704 }
Vishnu Nair8406fd72019-07-30 11:29:31 -07004705 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004706 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08004707 write(fd, result.c_str(), result.size());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004708 return NO_ERROR;
4709}
4710
Nataniel Borges8e7dc722019-02-28 15:10:28 -08004711status_t SurfaceFlinger::dumpCritical(int fd, const DumpArgs&, bool asProto) {
4712 if (asProto && mTracing.isEnabled()) {
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07004713 mTracing.writeToFile();
Nataniel Borges8e7dc722019-02-28 15:10:28 -08004714 }
4715
4716 return doDump(fd, DumpArgs(), asProto);
4717}
4718
Dominik Laskowskic2867142019-01-21 11:33:38 -08004719void SurfaceFlinger::listLayersLocked(std::string& result) const {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004720 mCurrentState.traverseInZOrder(
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004721 [&](Layer* layer) { StringAppendF(&result, "%s\n", layer->getDebugName()); });
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004722}
4723
Dominik Laskowskic2867142019-01-21 11:33:38 -08004724void SurfaceFlinger::dumpStatsLocked(const DumpArgs& args, std::string& result) const {
Ady Abraham2492a022020-07-24 11:09:55 -07004725 StringAppendF(&result, "%" PRId64 "\n", getVsyncPeriodFromHWC());
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004726
Dominik Laskowskic2867142019-01-21 11:33:38 -08004727 if (args.size() > 1) {
4728 const auto name = String8(args[1]);
Robert Carr2047fae2016-11-28 14:09:09 -08004729 mCurrentState.traverseInZOrder([&](Layer* layer) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004730 if (layer->getName() == name.string()) {
Svetoslavd85084b2014-03-20 10:28:31 -07004731 layer->dumpFrameStats(result);
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004732 }
Robert Carr2047fae2016-11-28 14:09:09 -08004733 });
Dominik Laskowskic2867142019-01-21 11:33:38 -08004734 } else {
4735 mAnimFrameTracker.dumpStats(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004736 }
4737}
4738
Dominik Laskowskic2867142019-01-21 11:33:38 -08004739void SurfaceFlinger::clearStatsLocked(const DumpArgs& args, std::string&) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004740 const bool clearAll = args.size() < 2;
4741 const auto name = clearAll ? String8() : String8(args[1]);
4742
Edgar Arriaga844fa672020-01-16 14:21:42 -08004743 mCurrentState.traverse([&](Layer* layer) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004744 if (clearAll || layer->getName() == name.string()) {
Svetoslavd85084b2014-03-20 10:28:31 -07004745 layer->clearFrameStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004746 }
Robert Carr2047fae2016-11-28 14:09:09 -08004747 });
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004748
Svetoslavd85084b2014-03-20 10:28:31 -07004749 mAnimFrameTracker.clearStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004750}
4751
Dominik Laskowskic2867142019-01-21 11:33:38 -08004752void SurfaceFlinger::dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const {
4753 mTimeStats->parseArgs(asProto, args, result);
4754}
4755
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -07004756void SurfaceFlinger::dumpFrameTimeline(const DumpArgs& args, std::string& result) const {
4757 mFrameTimeline->parseArgs(args, result);
4758}
4759
Jamie Gennis6547ff42013-07-16 20:12:42 -07004760// This should only be called from the main thread. Otherwise it would need
4761// the lock and should use mCurrentState rather than mDrawingState.
4762void SurfaceFlinger::logFrameStats() {
Edgar Arriaga844fa672020-01-16 14:21:42 -08004763 mDrawingState.traverse([&](Layer* layer) {
Jamie Gennis6547ff42013-07-16 20:12:42 -07004764 layer->logFrameStats();
Robert Carr2047fae2016-11-28 14:09:09 -08004765 });
Jamie Gennis6547ff42013-07-16 20:12:42 -07004766
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004767 mAnimFrameTracker.logAndResetStats("<win-anim>");
Jamie Gennis6547ff42013-07-16 20:12:42 -07004768}
4769
Yiwei Zhang5434a782018-12-05 18:06:32 -08004770void SurfaceFlinger::appendSfConfigString(std::string& result) const {
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004771 result.append(" [sf");
Fabien Sanglardc93afd52017-03-13 13:02:42 -07004772
Yiwei Zhang5434a782018-12-05 18:06:32 -08004773 StringAppendF(&result, " PRESENT_TIME_OFFSET=%" PRId64, dispSyncPresentTimeOffset);
4774 StringAppendF(&result, " FORCE_HWC_FOR_RBG_TO_YUV=%d", useHwcForRgbToYuv);
Dominik Laskowski13948602021-03-08 20:48:28 -08004775 StringAppendF(&result, " MAX_VIRT_DISPLAY_DIM=%zu",
4776 getHwComposer().getMaxVirtualDisplayDimension());
Yiwei Zhang5434a782018-12-05 18:06:32 -08004777 StringAppendF(&result, " RUNNING_WITHOUT_SYNC_FRAMEWORK=%d", !hasSyncFramework);
4778 StringAppendF(&result, " NUM_FRAMEBUFFER_SURFACE_BUFFERS=%" PRId64,
4779 maxFrameBufferAcquiredBuffers);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004780 result.append("]");
Andy McFadden4803b742012-09-24 19:07:20 -07004781}
4782
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004783void SurfaceFlinger::dumpVSync(std::string& result) const {
Dominik Laskowski98041832019-08-01 18:35:59 -07004784 mScheduler->dump(result);
Dominik Laskowski98041832019-08-01 18:35:59 -07004785
Steven Thomas2bbaabe2019-08-28 16:08:35 -07004786 mRefreshRateStats->dump(result);
Dominik Laskowski98041832019-08-01 18:35:59 -07004787 result.append("\n");
4788
Ady Abraham8287e852020-08-12 14:44:58 -07004789 mVsyncConfiguration->dump(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004790 StringAppendF(&result,
Dominik Laskowski98041832019-08-01 18:35:59 -07004791 " present offset: %9" PRId64 " ns\t VSYNC period: %9" PRId64 " ns\n\n",
Ady Abraham2492a022020-07-24 11:09:55 -07004792 dispSyncPresentTimeOffset, getVsyncPeriodFromHWC());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004793
Marin Shalamanova7fe3042021-01-29 21:02:08 +01004794 StringAppendF(&result, "(mode override by backdoor: %s)\n\n",
4795 mDebugDisplayModeSetByBackdoor ? "yes" : "no");
Dominik Laskowski98041832019-08-01 18:35:59 -07004796
Ana Krulecc2870422019-01-29 19:00:58 -08004797 mScheduler->dump(mAppConnectionHandle, result);
Ady Abraham8cb21882020-08-26 18:22:05 -07004798 mScheduler->dumpVsync(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004799}
4800
Dan Stoza269dc4d2021-01-15 15:07:43 -08004801void SurfaceFlinger::dumpPlannerInfo(const DumpArgs& args, std::string& result) const {
4802 for (const auto& [token, display] : mDisplays) {
4803 const auto compositionDisplay = display->getCompositionDisplay();
4804 compositionDisplay->dumpPlannerInfo(args, result);
4805 }
4806}
4807
Yiwei Zhang5434a782018-12-05 18:06:32 -08004808void SurfaceFlinger::dumpStaticScreenStats(std::string& result) const {
4809 result.append("Static screen stats:\n");
David Sodman4a36e932017-11-07 14:29:47 -08004810 for (size_t b = 0; b < SurfaceFlingerBE::NUM_BUCKETS - 1; ++b) {
4811 float bucketTimeSec = getBE().mFrameBuckets[b] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08004812 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08004813 static_cast<float>(getBE().mFrameBuckets[b]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004814 StringAppendF(&result, " < %zd frames: %.3f s (%.1f%%)\n", b + 1, bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08004815 }
David Sodman4a36e932017-11-07 14:29:47 -08004816 float bucketTimeSec = getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08004817 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08004818 static_cast<float>(getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004819 StringAppendF(&result, " %zd+ frames: %.3f s (%.1f%%)\n", SurfaceFlingerBE::NUM_BUCKETS - 1,
4820 bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08004821}
4822
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004823void SurfaceFlinger::recordBufferingStats(const std::string& layerName,
4824 std::vector<OccupancyTracker::Segment>&& history) {
David Sodmancbaf0832017-11-07 14:21:36 -08004825 Mutex::Autolock lock(getBE().mBufferingStatsMutex);
4826 auto& stats = getBE().mBufferingStats[layerName];
Dan Stozae77c7662016-05-13 11:37:28 -07004827 for (const auto& segment : history) {
4828 if (!segment.usedThirdBuffer) {
4829 stats.twoBufferTime += segment.totalTime;
4830 }
4831 if (segment.occupancyAverage < 1.0f) {
4832 stats.doubleBufferedTime += segment.totalTime;
4833 } else if (segment.occupancyAverage < 2.0f) {
4834 stats.tripleBufferedTime += segment.totalTime;
4835 }
4836 ++stats.numSegments;
4837 stats.totalTime += segment.totalTime;
4838 }
4839}
4840
Yiwei Zhang5434a782018-12-05 18:06:32 -08004841void SurfaceFlinger::dumpFrameEventsLocked(std::string& result) {
4842 result.append("Layer frame timestamps:\n");
Josh Chienedaa9132020-12-04 18:30:46 +08004843 // Traverse all layers to dump frame-events for each layer
4844 mCurrentState.traverseInZOrder(
4845 [&] (Layer* layer) { layer->dumpFrameEvents(result); });
Brian Andersond6927fb2016-07-23 23:37:30 -07004846}
4847
Yiwei Zhang5434a782018-12-05 18:06:32 -08004848void SurfaceFlinger::dumpBufferingStats(std::string& result) const {
Dan Stozae77c7662016-05-13 11:37:28 -07004849 result.append("Buffering stats:\n");
4850 result.append(" [Layer name] <Active time> <Two buffer> "
4851 "<Double buffered> <Triple buffered>\n");
David Sodmancbaf0832017-11-07 14:21:36 -08004852 Mutex::Autolock lock(getBE().mBufferingStatsMutex);
Dan Stozae77c7662016-05-13 11:37:28 -07004853 typedef std::tuple<std::string, float, float, float> BufferTuple;
4854 std::map<float, BufferTuple, std::greater<float>> sorted;
David Sodmancbaf0832017-11-07 14:21:36 -08004855 for (const auto& statsPair : getBE().mBufferingStats) {
Dan Stozae77c7662016-05-13 11:37:28 -07004856 const char* name = statsPair.first.c_str();
David Sodmancbaf0832017-11-07 14:21:36 -08004857 const SurfaceFlingerBE::BufferingStats& stats = statsPair.second;
Dan Stozae77c7662016-05-13 11:37:28 -07004858 if (stats.numSegments == 0) {
4859 continue;
4860 }
4861 float activeTime = ns2ms(stats.totalTime) / 1000.0f;
4862 float twoBufferRatio = static_cast<float>(stats.twoBufferTime) /
4863 stats.totalTime;
4864 float doubleBufferRatio = static_cast<float>(
4865 stats.doubleBufferedTime) / stats.totalTime;
4866 float tripleBufferRatio = static_cast<float>(
4867 stats.tripleBufferedTime) / stats.totalTime;
4868 sorted.insert({activeTime, {name, twoBufferRatio,
4869 doubleBufferRatio, tripleBufferRatio}});
4870 }
4871 for (const auto& sortedPair : sorted) {
4872 float activeTime = sortedPair.first;
4873 const BufferTuple& values = sortedPair.second;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004874 StringAppendF(&result, " [%s] %.2f %.3f %.3f %.3f\n", std::get<0>(values).c_str(),
4875 activeTime, std::get<1>(values), std::get<2>(values), std::get<3>(values));
Dan Stozae77c7662016-05-13 11:37:28 -07004876 }
4877 result.append("\n");
4878}
4879
Yiwei Zhang5434a782018-12-05 18:06:32 -08004880void SurfaceFlinger::dumpDisplayIdentificationData(std::string& result) const {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004881 for (const auto& [token, display] : mDisplays) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02004882 const auto displayId = PhysicalDisplayId::tryCast(display->getId());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004883 if (!displayId) {
4884 continue;
4885 }
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02004886 const auto hwcDisplayId = getHwComposer().fromPhysicalDisplayId(*displayId);
Dominik Laskowski7e045462018-05-30 13:02:02 -07004887 if (!hwcDisplayId) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004888 continue;
4889 }
4890
Yiwei Zhang5434a782018-12-05 18:06:32 -08004891 StringAppendF(&result,
4892 "Display %s (HWC display %" PRIu64 "): ", to_string(*displayId).c_str(),
4893 *hwcDisplayId);
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004894 uint8_t port;
4895 DisplayIdentificationData data;
Dominik Laskowski7e045462018-05-30 13:02:02 -07004896 if (!getHwComposer().getDisplayIdentificationData(*hwcDisplayId, &port, &data)) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004897 result.append("no identification data\n");
4898 continue;
4899 }
4900
4901 if (!isEdid(data)) {
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004902 result.append("unknown identification data\n");
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004903 continue;
4904 }
4905
4906 const auto edid = parseEdid(data);
4907 if (!edid) {
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004908 result.append("invalid EDID\n");
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004909 continue;
4910 }
4911
Yiwei Zhang5434a782018-12-05 18:06:32 -08004912 StringAppendF(&result, "port=%u pnpId=%s displayName=\"", port, edid->pnpId.data());
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004913 result.append(edid->displayName.data(), edid->displayName.length());
4914 result.append("\"\n");
4915 }
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004916}
4917
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004918void SurfaceFlinger::dumpRawDisplayIdentificationData(const DumpArgs& args,
4919 std::string& result) const {
Peiyong Line9d809e2020-04-14 13:10:48 -07004920 hal::HWDisplayId hwcDisplayId;
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004921 uint8_t port;
4922 DisplayIdentificationData data;
4923
4924 if (args.size() > 1 && base::ParseUint(String8(args[1]), &hwcDisplayId) &&
4925 getHwComposer().getDisplayIdentificationData(hwcDisplayId, &port, &data)) {
4926 result.append(reinterpret_cast<const char*>(data.data()), data.size());
4927 }
4928}
4929
Yiwei Zhang5434a782018-12-05 18:06:32 -08004930void SurfaceFlinger::dumpWideColorInfo(std::string& result) const {
Peiyong Linff84a152019-05-17 18:36:19 -07004931 StringAppendF(&result, "Device has wide color built-in display: %d\n", hasWideColorDisplay);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004932 StringAppendF(&result, "Device uses color management: %d\n", useColorManagement);
4933 StringAppendF(&result, "DisplayColorSetting: %s\n",
4934 decodeDisplayColorSetting(mDisplayColorSetting).c_str());
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004935
4936 // TODO: print out if wide-color mode is active or not
4937
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004938 for (const auto& [token, display] : mDisplays) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02004939 const auto displayId = PhysicalDisplayId::tryCast(display->getId());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004940 if (!displayId) {
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004941 continue;
4942 }
4943
Yiwei Zhang5434a782018-12-05 18:06:32 -08004944 StringAppendF(&result, "Display %s color modes:\n", to_string(*displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004945 std::vector<ColorMode> modes = getHwComposer().getColorModes(*displayId);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004946 for (auto&& mode : modes) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004947 StringAppendF(&result, " %s (%d)\n", decodeColorMode(mode).c_str(), mode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004948 }
4949
Lloyd Pique32cbe282018-10-19 13:09:22 -07004950 ColorMode currentMode = display->getCompositionDisplay()->getState().colorMode;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004951 StringAppendF(&result, " Current color mode: %s (%d)\n",
4952 decodeColorMode(currentMode).c_str(), currentMode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004953 }
4954 result.append("\n");
4955}
4956
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07004957LayersProto SurfaceFlinger::dumpDrawingStateProto(uint32_t traceFlags) const {
4958 // If context is SurfaceTracing thread, mTracingLock blocks display transactions on main thread.
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07004959 const auto display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked());
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07004960
chaviw1d044282017-09-27 12:19:28 -07004961 LayersProto layersProto;
chaviw08f3cb22020-01-13 13:17:21 -08004962 for (const sp<Layer>& layer : mDrawingState.layersSortedByZ) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -07004963 layer->writeToProto(layersProto, traceFlags, display.get());
chaviw08f3cb22020-01-13 13:17:21 -08004964 }
Alec Mouri6b9e9912020-01-21 10:50:24 -08004965
chaviw1d044282017-09-27 12:19:28 -07004966 return layersProto;
4967}
4968
Alec Mouri6b9e9912020-01-21 10:50:24 -08004969void SurfaceFlinger::dumpHwc(std::string& result) const {
4970 getHwComposer().dump(result);
4971}
4972
Vishnu Nair0f085c62019-08-30 08:49:12 -07004973void SurfaceFlinger::dumpOffscreenLayersProto(LayersProto& layersProto, uint32_t traceFlags) const {
4974 // Add a fake invisible root layer to the proto output and parent all the offscreen layers to
4975 // it.
4976 LayerProto* rootProto = layersProto.add_layers();
4977 const int32_t offscreenRootLayerId = INT32_MAX - 2;
4978 rootProto->set_id(offscreenRootLayerId);
4979 rootProto->set_name("Offscreen Root");
Vishnu Naird5aeb612019-09-20 14:39:39 -07004980 rootProto->set_parent(-1);
Vishnu Nair0f085c62019-08-30 08:49:12 -07004981
4982 for (Layer* offscreenLayer : mOffscreenLayers) {
4983 // Add layer as child of the fake root
4984 rootProto->add_children(offscreenLayer->sequence);
4985
4986 // Add layer
Alec Mouri6b9e9912020-01-21 10:50:24 -08004987 LayerProto* layerProto =
4988 offscreenLayer->writeToProto(layersProto, traceFlags, nullptr /*device*/);
Vishnu Nair0f085c62019-08-30 08:49:12 -07004989 layerProto->set_parent(offscreenRootLayerId);
Vishnu Nair0f085c62019-08-30 08:49:12 -07004990 }
4991}
4992
Vishnu Nair8406fd72019-07-30 11:29:31 -07004993LayersProto SurfaceFlinger::dumpProtoFromMainThread(uint32_t traceFlags) {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07004994 return schedule([=] { return dumpDrawingStateProto(traceFlags); }).get();
Vishnu Nair8406fd72019-07-30 11:29:31 -07004995}
4996
Vishnu Nair0f085c62019-08-30 08:49:12 -07004997void SurfaceFlinger::dumpOffscreenLayers(std::string& result) {
4998 result.append("Offscreen Layers:\n");
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07004999 result.append(schedule([this] {
5000 std::string result;
5001 for (Layer* offscreenLayer : mOffscreenLayers) {
5002 offscreenLayer->traverse(LayerVector::StateSet::Drawing,
5003 [&](Layer* layer) {
5004 layer->dumpCallingUidPid(result);
5005 });
5006 }
5007 return result;
5008 }).get());
Vishnu Nair0f085c62019-08-30 08:49:12 -07005009}
5010
Dominik Laskowskic2867142019-01-21 11:33:38 -08005011void SurfaceFlinger::dumpAllLocked(const DumpArgs& args, std::string& result) const {
5012 const bool colorize = !args.empty() && args[0] == String16("--color");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005013 Colorizer colorizer(colorize);
5014
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005015 // figure out if we're stuck somewhere
5016 const nsecs_t now = systemTime();
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005017 const nsecs_t inTransaction(mDebugInTransaction);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005018 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
5019
5020 /*
Andy McFadden4803b742012-09-24 19:07:20 -07005021 * Dump library configuration.
5022 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005023
5024 colorizer.bold(result);
Andy McFadden4803b742012-09-24 19:07:20 -07005025 result.append("Build configuration:");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005026 colorizer.reset(result);
Andy McFadden4803b742012-09-24 19:07:20 -07005027 appendSfConfigString(result);
Andy McFadden4803b742012-09-24 19:07:20 -07005028 result.append("\n");
5029
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07005030 result.append("\nDisplay identification data:\n");
5031 dumpDisplayIdentificationData(result);
5032
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06005033 result.append("\nWide-Color information:\n");
5034 dumpWideColorInfo(result);
5035
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005036 colorizer.bold(result);
Mathias Agopianca088332013-03-28 17:44:13 -07005037 result.append("Sync configuration: ");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005038 colorizer.reset(result);
Mathias Agopianca088332013-03-28 17:44:13 -07005039 result.append(SyncFeatures::getInstance().toString());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08005040 result.append("\n\n");
Mathias Agopianca088332013-03-28 17:44:13 -07005041
Andy McFadden41d67d72014-04-25 16:58:34 -07005042 colorizer.bold(result);
Dominik Laskowski98041832019-08-01 18:35:59 -07005043 result.append("Scheduler:\n");
Andy McFadden41d67d72014-04-25 16:58:34 -07005044 colorizer.reset(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08005045 dumpVSync(result);
Dan Stozab90cf072015-03-05 11:05:59 -08005046 result.append("\n");
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08005047
Dan Stozab90cf072015-03-05 11:05:59 -08005048 dumpStaticScreenStats(result);
5049 result.append("\n");
5050
Alec Mouri40189b02019-03-05 15:07:54 -08005051 StringAppendF(&result, "Total missed frame count: %u\n", mFrameMissedCount.load());
5052 StringAppendF(&result, "HWC missed frame count: %u\n", mHwcFrameMissedCount.load());
5053 StringAppendF(&result, "GPU missed frame count: %u\n\n", mGpuFrameMissedCount.load());
Marissa Wallcfcdaa52018-05-21 15:45:59 -07005054
Dan Stozae77c7662016-05-13 11:37:28 -07005055 dumpBufferingStats(result);
5056
Andy McFadden4803b742012-09-24 19:07:20 -07005057 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005058 * Dump the visible layer list
5059 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005060 colorizer.bold(result);
chaviweadf0d42019-08-12 13:28:29 -07005061 StringAppendF(&result, "Visible layers (count = %zu)\n", mNumLayers.load());
Yiwei Zhang5434a782018-12-05 18:06:32 -08005062 StringAppendF(&result, "GraphicBufferProducers: %zu, max %zu\n",
5063 mGraphicBufferProducerList.size(), mMaxGraphicBufferProducerListSize);
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005064 colorizer.reset(result);
chaviw1d044282017-09-27 12:19:28 -07005065
Chia-I Wu2f884132018-09-13 15:17:58 -07005066 {
Lloyd Pique207def92019-02-28 16:09:52 -08005067 StringAppendF(&result, "Composition layers\n");
5068 mDrawingState.traverseInZOrder([&](Layer* layer) {
Lloyd Piquede196652020-01-22 17:29:58 -08005069 auto* compositionState = layer->getCompositionState();
Vishnu Nair49529172020-02-25 10:19:44 -08005070 if (!compositionState || !compositionState->isVisible) return;
Lloyd Piquede196652020-01-22 17:29:58 -08005071
5072 android::base::StringAppendF(&result, "* Layer %p (%s)\n", layer,
5073 layer->getDebugName() ? layer->getDebugName()
5074 : "<unknown>");
5075 compositionState->dump(result);
Lloyd Pique207def92019-02-28 16:09:52 -08005076 });
5077 }
5078
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005079 /*
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07005080 * Dump Display state
5081 */
5082
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005083 colorizer.bold(result);
Yiwei Zhang5434a782018-12-05 18:06:32 -08005084 StringAppendF(&result, "Displays (%zu entries)\n", mDisplays.size());
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005085 colorizer.reset(result);
Dominik Laskowski9fae1022018-05-29 13:17:40 -07005086 for (const auto& [token, display] : mDisplays) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005087 display->dump(result);
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07005088 }
Chia-I Wu1e043612018-03-01 09:45:09 -08005089 result.append("\n");
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07005090
5091 /*
Lloyd Piquec3cb7292019-05-17 15:25:14 -07005092 * Dump CompositionEngine state
5093 */
5094
5095 mCompositionEngine->dump(result);
5096
5097 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005098 * Dump SurfaceFlinger global state
5099 */
5100
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005101 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02005102 result.append("SurfaceFlinger global state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005103 colorizer.reset(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005104
Lloyd Piqueb97e04f2018-10-18 17:07:05 -07005105 getRenderEngine().dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005106
Robert Carrbeba6f02021-02-10 21:06:27 -08005107 result.append("ClientCache state:\n");
5108 ClientCache::getInstance().dump(result);
Ady Abrahama3b08ef2019-07-15 18:43:10 -07005109 DebugEGLImageTracker::getInstance()->dump(result);
5110
Dominik Laskowski075d3172018-05-24 15:50:06 -07005111 if (const auto display = getDefaultDisplayDeviceLocked()) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07005112 display->getCompositionDisplay()->getState().undefinedRegion.dump(result,
5113 "undefinedRegion");
Dominik Laskowski718f9602019-11-09 20:01:35 -08005114 StringAppendF(&result, " orientation=%s, isPoweredOn=%d\n",
5115 toCString(display->getOrientation()), display->isPoweredOn());
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08005116 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08005117 StringAppendF(&result,
5118 " transaction-flags : %08x\n"
5119 " gpu_to_cpu_unsupported : %d\n",
5120 mTransactionFlags.load(), !mGpuToCpuSupported);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07005121
Marin Shalamanov045b7002021-01-07 16:56:24 +01005122 if (const auto display = getDefaultDisplayDeviceLocked()) {
Marin Shalamanov9afcbd82020-08-19 12:34:59 +02005123 std::string fps, xDpi, yDpi;
Marin Shalamanov045b7002021-01-07 16:56:24 +01005124 if (const auto activeMode = display->getActiveMode()) {
5125 fps = to_string(activeMode->getFps());
5126 xDpi = base::StringPrintf("%.2f", activeMode->getDpiX());
5127 yDpi = base::StringPrintf("%.2f", activeMode->getDpiY());
Marin Shalamanov9afcbd82020-08-19 12:34:59 +02005128 } else {
5129 fps = "unknown";
5130 xDpi = "unknown";
5131 yDpi = "unknown";
5132 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08005133 StringAppendF(&result,
Marin Shalamanov9afcbd82020-08-19 12:34:59 +02005134 " refresh-rate : %s\n"
5135 " x-dpi : %s\n"
5136 " y-dpi : %s\n",
5137 fps.c_str(), xDpi.c_str(), yDpi.c_str());
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07005138 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005139
Yiwei Zhang5434a782018-12-05 18:06:32 -08005140 StringAppendF(&result, " transaction time: %f us\n", inTransactionDuration / 1000.0);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005141
Dan Stozae22aec72016-08-01 13:20:59 -07005142 /*
Yichi Chenadc69612018-09-15 14:51:18 +08005143 * Tracing state
5144 */
5145 mTracing.dump(result);
5146 result.append("\n");
5147
5148 /*
Dan Stozae22aec72016-08-01 13:20:59 -07005149 * HWC layer minidump
5150 */
Dominik Laskowski9fae1022018-05-29 13:17:40 -07005151 for (const auto& [token, display] : mDisplays) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02005152 const auto displayId = HalDisplayId::tryCast(display->getId());
Dominik Laskowski075d3172018-05-24 15:50:06 -07005153 if (!displayId) {
Dan Stozae22aec72016-08-01 13:20:59 -07005154 continue;
5155 }
5156
Yiwei Zhang5434a782018-12-05 18:06:32 -08005157 StringAppendF(&result, "Display %s HWC layers:\n", to_string(*displayId).c_str());
Dan Stozae22aec72016-08-01 13:20:59 -07005158 Layer::miniDumpHeader(result);
Dominik Laskowskib7251f42020-04-20 17:42:59 -07005159
5160 const DisplayDevice& ref = *display;
5161 mCurrentState.traverseInZOrder([&](Layer* layer) { layer->miniDump(result, ref); });
Dan Stozae22aec72016-08-01 13:20:59 -07005162 result.append("\n");
5163 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005164
Ady Abraham2790e9f2021-04-28 13:14:20 -07005165 {
5166 DumpArgs plannerArgs;
5167 plannerArgs.add(); // first argument is ignored
5168 plannerArgs.add(String16("--layers"));
5169 dumpPlannerInfo(plannerArgs, result);
5170 }
5171
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005172 /*
5173 * Dump HWComposer state
5174 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005175 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02005176 result.append("h/w composer state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005177 colorizer.reset(result);
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005178 bool hwcDisabled = mDebugDisableHWC || mDebugRegion;
Yiwei Zhang5434a782018-12-05 18:06:32 -08005179 StringAppendF(&result, " h/w composer %s\n", hwcDisabled ? "disabled" : "enabled");
Dominik Laskowski075d3172018-05-24 15:50:06 -07005180 getHwComposer().dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005181
5182 /*
5183 * Dump gralloc state
5184 */
5185 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
5186 alloc.dump(result);
Karthik Ravi Shankar171155a2017-06-28 15:40:24 -07005187
Yiwei Zhang7eb58b72019-04-22 19:00:02 -07005188 result.append(mTimeStats->miniDump());
5189 result.append("\n");
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005190}
5191
chaviw17ac24b2021-01-28 18:50:05 -08005192mat4 SurfaceFlinger::calculateColorMatrix(float saturation) {
5193 if (saturation == 1) {
5194 return mat4();
Chia-I Wu28f320b2018-05-03 11:02:56 -07005195 }
5196
chaviw17ac24b2021-01-28 18:50:05 -08005197 float3 luminance{0.213f, 0.715f, 0.072f};
5198 luminance *= 1.0f - saturation;
5199 mat4 saturationMatrix = mat4(vec4{luminance.r + saturation, luminance.r, luminance.r, 0.0f},
5200 vec4{luminance.g, luminance.g + saturation, luminance.g, 0.0f},
5201 vec4{luminance.b, luminance.b, luminance.b + saturation, 0.0f},
5202 vec4{0.0f, 0.0f, 0.0f, 1.0f});
5203 return saturationMatrix;
5204}
5205
5206void SurfaceFlinger::updateColorMatrixLocked() {
5207 mat4 colorMatrix =
5208 mClientColorMatrix * calculateColorMatrix(mGlobalSaturationFactor) * mDaltonizer();
5209
Chia-I Wu28f320b2018-05-03 11:02:56 -07005210 if (mCurrentState.colorMatrix != colorMatrix) {
5211 mCurrentState.colorMatrix = colorMatrix;
5212 mCurrentState.colorMatrixChanged = true;
5213 setTransactionFlags(eTransactionNeeded);
5214 }
5215}
5216
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07005217status_t SurfaceFlinger::CheckTransactCodeCredentials(uint32_t code) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00005218#pragma clang diagnostic push
5219#pragma clang diagnostic error "-Wswitch-enum"
5220 switch (static_cast<ISurfaceComposerTag>(code)) {
Dominik Laskowskif06d68e2021-03-24 19:40:03 -07005221 case ENABLE_VSYNC_INJECTIONS:
5222 case INJECT_VSYNC:
5223 if (!hasMockHwc()) return PERMISSION_DENIED;
5224 [[fallthrough]];
Ana Krulec13be8ad2018-08-21 02:43:56 +00005225 // These methods should at minimum make sure that the client requested
5226 // access to SF.
Dan Stozae3344402018-08-20 19:53:42 +00005227 case BOOT_FINISHED:
5228 case CLEAR_ANIMATION_FRAME_STATS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00005229 case CREATE_DISPLAY:
5230 case DESTROY_DISPLAY:
Ana Krulec13be8ad2018-08-21 02:43:56 +00005231 case GET_ANIMATION_FRAME_STATS:
Kriti Dang49ad4132021-01-08 11:49:56 +01005232 case OVERRIDE_HDR_TYPES:
Ana Krulec13be8ad2018-08-21 02:43:56 +00005233 case GET_HDR_CAPABILITIES:
Marin Shalamanova7fe3042021-01-29 21:02:08 +01005234 case SET_DESIRED_DISPLAY_MODE_SPECS:
5235 case GET_DESIRED_DISPLAY_MODE_SPECS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00005236 case SET_ACTIVE_COLOR_MODE:
Galia Peycheva5492cb52019-10-30 14:13:16 +01005237 case GET_AUTO_LOW_LATENCY_MODE_SUPPORT:
5238 case SET_AUTO_LOW_LATENCY_MODE:
5239 case GET_GAME_CONTENT_TYPE_SUPPORT:
5240 case SET_GAME_CONTENT_TYPE:
Kevin DuBois9c0a1762018-10-16 13:32:31 -07005241 case SET_POWER_MODE:
Kevin DuBois74e53772018-11-19 10:52:38 -08005242 case GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES:
Kevin DuBois1d4249a2018-08-29 10:45:14 -07005243 case SET_DISPLAY_CONTENT_SAMPLING_ENABLED:
Ady Abraham8532d012019-05-08 14:50:56 -07005244 case GET_DISPLAYED_CONTENT_SAMPLE:
Galia Peycheva8f04b302021-04-27 13:25:38 +02005245 case ADD_TUNNEL_MODE_ENABLED_LISTENER:
5246 case REMOVE_TUNNEL_MODE_ENABLED_LISTENER:
Lais Andrade3a6e47d2020-04-02 11:20:16 +01005247 case NOTIFY_POWER_BOOST:
Steven Thomasd4071902020-03-24 16:02:53 -07005248 case SET_GLOBAL_SHADOW_SETTINGS:
5249 case ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN: {
Kriti Dang49ad4132021-01-08 11:49:56 +01005250 // ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN and OVERRIDE_HDR_TYPES are used by CTS tests,
5251 // which acquire the necessary permission dynamically. Don't use the permission cache
5252 // for this check.
5253 bool usePermissionCache =
5254 code != ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN && code != OVERRIDE_HDR_TYPES;
Steven Thomasd4071902020-03-24 16:02:53 -07005255 if (!callingThreadHasUnscopedSurfaceFlingerAccess(usePermissionCache)) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07005256 IPCThreadState* ipc = IPCThreadState::self();
5257 ALOGE("Permission Denial: can't access SurfaceFlinger pid=%d, uid=%d",
5258 ipc->getCallingPid(), ipc->getCallingUid());
Mathias Agopian375f5632009-06-15 18:24:59 -07005259 return PERMISSION_DENIED;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005260 }
Robert Carr1db73f62016-12-21 12:58:51 -08005261 return OK;
5262 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00005263 case GET_LAYER_DEBUG_INFO: {
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07005264 IPCThreadState* ipc = IPCThreadState::self();
5265 const int pid = ipc->getCallingPid();
5266 const int uid = ipc->getCallingUid();
Ana Krulec13be8ad2018-08-21 02:43:56 +00005267 if ((uid != AID_SHELL) && !PermissionCache::checkPermission(sDump, pid, uid)) {
5268 ALOGE("Layer debug info permission denied for pid=%d, uid=%d", pid, uid);
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07005269 return PERMISSION_DENIED;
5270 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00005271 return OK;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005272 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00005273 // Used by apps to hook Choreographer to SurfaceFlinger.
5274 case CREATE_DISPLAY_EVENT_CONNECTION:
5275 // The following calls are currently used by clients that do not
5276 // request necessary permissions. However, they do not expose any secret
5277 // information, so it is OK to pass them.
5278 case AUTHENTICATE_SURFACE:
Peiyong Lind1fedb42019-03-11 17:48:41 -07005279 case GET_ACTIVE_COLOR_MODE:
Marin Shalamanova7fe3042021-01-29 21:02:08 +01005280 case GET_ACTIVE_DISPLAY_MODE:
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08005281 case GET_PHYSICAL_DISPLAY_IDS:
5282 case GET_PHYSICAL_DISPLAY_TOKEN:
Ana Krulec13be8ad2018-08-21 02:43:56 +00005283 case GET_DISPLAY_COLOR_MODES:
Daniel Solomon42d04562019-01-20 21:03:19 -08005284 case GET_DISPLAY_NATIVE_PRIMARIES:
Marin Shalamanov228f46b2021-01-28 21:11:45 +01005285 case GET_STATIC_DISPLAY_INFO:
5286 case GET_DYNAMIC_DISPLAY_INFO:
Marin Shalamanova7fe3042021-01-29 21:02:08 +01005287 case GET_DISPLAY_MODES:
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08005288 case GET_DISPLAY_STATE:
Ana Krulec13be8ad2018-08-21 02:43:56 +00005289 case GET_DISPLAY_STATS:
5290 case GET_SUPPORTED_FRAME_TIMESTAMPS:
5291 // Calling setTransactionState is safe, because you need to have been
5292 // granted a reference to Client* and Handle* to do anything with it.
5293 case SET_TRANSACTION_STATE:
Robert Carrb89ea9d2018-12-10 13:01:14 -08005294 case CREATE_CONNECTION:
Ady Abraham37965d42018-11-01 13:43:32 -07005295 case GET_COLOR_MANAGEMENT:
Peiyong Lin3c2791e2019-01-14 17:05:18 -08005296 case GET_COMPOSITION_PREFERENCE:
Marissa Wallebc2c052019-01-16 19:16:55 -08005297 case GET_PROTECTED_CONTENT_SUPPORT:
Dan Gittik57e63c52019-01-18 16:37:54 +00005298 case IS_WIDE_COLOR_DISPLAY:
Steven Thomas62a4cf82020-01-31 12:04:03 -08005299 // setFrameRate() is deliberately available for apps to call without any
5300 // special permissions.
5301 case SET_FRAME_RATE:
Dan Gittik57e63c52019-01-18 16:37:54 +00005302 case GET_DISPLAY_BRIGHTNESS_SUPPORT:
chaviw4b9d5e12020-08-04 18:30:35 -07005303 // captureLayers and captureDisplay will handle the permission check in the function
5304 case CAPTURE_LAYERS:
5305 case CAPTURE_DISPLAY:
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10005306 case SET_FRAME_TIMELINE_INFO:
Ady Abraham564f9de2021-02-03 18:34:33 -08005307 case GET_GPU_CONTEXT_PRIORITY:
Ady Abraham899dcdb2021-06-15 16:56:21 -07005308 case GET_MAX_ACQUIRED_BUFFER_COUNT: {
Ady Abraham564f9de2021-02-03 18:34:33 -08005309 // This is not sensitive information, so should not require permission control.
Ana Krulec13be8ad2018-08-21 02:43:56 +00005310 return OK;
5311 }
John Reck71da15e2021-03-30 14:58:08 -04005312 case SET_DISPLAY_BRIGHTNESS:
John Reck88270902021-03-18 11:27:35 -04005313 case ADD_HDR_LAYER_INFO_LISTENER:
5314 case REMOVE_HDR_LAYER_INFO_LISTENER: {
John Reck88270902021-03-18 11:27:35 -04005315 IPCThreadState* ipc = IPCThreadState::self();
5316 const int pid = ipc->getCallingPid();
5317 const int uid = ipc->getCallingUid();
5318 if ((uid != AID_GRAPHICS) &&
5319 !PermissionCache::checkPermission(sControlDisplayBrightness, pid, uid)) {
5320 ALOGE("Permission Denial: can't control brightness pid=%d, uid=%d", pid, uid);
5321 return PERMISSION_DENIED;
5322 }
5323 return OK;
5324 }
Alec Mouric8957ee2021-03-01 14:33:19 -08005325 case ADD_FPS_LISTENER:
5326 case REMOVE_FPS_LISTENER:
Dan Stoza84ab9372018-12-17 15:27:57 -08005327 case ADD_REGION_SAMPLING_LISTENER:
5328 case REMOVE_REGION_SAMPLING_LISTENER: {
Ana Krulec13be8ad2018-08-21 02:43:56 +00005329 // codes that require permission check
chaviwa76b2712017-09-20 12:02:26 -07005330 IPCThreadState* ipc = IPCThreadState::self();
5331 const int pid = ipc->getCallingPid();
5332 const int uid = ipc->getCallingUid();
5333 if ((uid != AID_GRAPHICS) &&
5334 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
5335 ALOGE("Permission Denial: can't read framebuffer pid=%d, uid=%d", pid, uid);
5336 return PERMISSION_DENIED;
5337 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00005338 return OK;
5339 }
Pablo Gamito6ee484d2020-07-30 14:26:28 +00005340 case ADD_TRANSACTION_TRACE_LISTENER:
chaviwd2432892020-07-24 17:42:39 -07005341 case CAPTURE_DISPLAY_BY_ID: {
chaviw93df2ea2019-04-30 16:45:12 -07005342 IPCThreadState* ipc = IPCThreadState::self();
5343 const int uid = ipc->getCallingUid();
Peiyong Lin96cfebc2019-05-15 11:36:13 -07005344 if (uid == AID_ROOT || uid == AID_GRAPHICS || uid == AID_SYSTEM || uid == AID_SHELL) {
chaviw93df2ea2019-04-30 16:45:12 -07005345 return OK;
5346 }
5347 return PERMISSION_DENIED;
5348 }
Tej Singhe2751772021-04-06 22:05:29 -07005349 case ON_PULL_ATOM: {
5350 const int uid = IPCThreadState::self()->getCallingUid();
5351 if (uid == AID_SYSTEM) {
5352 return OK;
5353 }
5354 return PERMISSION_DENIED;
5355 }
chaviw60c9d3e2021-06-04 12:52:17 -05005356 case ADD_WINDOW_INFOS_LISTENER:
5357 case REMOVE_WINDOW_INFOS_LISTENER: {
5358 const int uid = IPCThreadState::self()->getCallingUid();
5359 if (uid == AID_SYSTEM || uid == AID_GRAPHICS) {
5360 return OK;
5361 }
5362 return PERMISSION_DENIED;
5363 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005364 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00005365
5366 // These codes are used for the IBinder protocol to either interrogate the recipient
5367 // side of the transaction for its canonical interface descriptor or to dump its state.
5368 // We let them pass by default.
5369 if (code == IBinder::INTERFACE_TRANSACTION || code == IBinder::DUMP_TRANSACTION ||
5370 code == IBinder::PING_TRANSACTION || code == IBinder::SHELL_COMMAND_TRANSACTION ||
5371 code == IBinder::SYSPROPS_TRANSACTION) {
5372 return OK;
5373 }
Alec Mouri023c1882021-05-08 16:36:33 -07005374 // Numbers from 1000 to 1040 are currently used for backdoors. The code
Ana Krulec13be8ad2018-08-21 02:43:56 +00005375 // in onTransact verifies that the user is root, and has access to use SF.
Alec Mouri023c1882021-05-08 16:36:33 -07005376 if (code >= 1000 && code <= 1040) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00005377 ALOGV("Accessing SurfaceFlinger through backdoor code: %u", code);
5378 return OK;
5379 }
5380 ALOGE("Permission Denial: SurfaceFlinger did not recognize request code: %u", code);
5381 return PERMISSION_DENIED;
5382#pragma clang diagnostic pop
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07005383}
5384
Ana Krulec13be8ad2018-08-21 02:43:56 +00005385status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
5386 uint32_t flags) {
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07005387 status_t credentialCheck = CheckTransactCodeCredentials(code);
5388 if (credentialCheck != OK) {
5389 return credentialCheck;
5390 }
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07005391
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005392 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
5393 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
Mathias Agopianb8a55602009-06-26 19:06:36 -07005394 CHECK_INTERFACE(ISurfaceComposer, data, reply);
Romain Guy8c6bbd62017-06-05 13:51:43 -07005395 IPCThreadState* ipc = IPCThreadState::self();
5396 const int uid = ipc->getCallingUid();
5397 if (CC_UNLIKELY(uid != AID_SYSTEM
5398 && !PermissionCache::checkCallingPermission(sHardwareTest))) {
Mathias Agopian375f5632009-06-15 18:24:59 -07005399 const int pid = ipc->getCallingPid();
Steve Blocke6f43dd2012-01-06 19:20:56 +00005400 ALOGE("Permission Denial: "
Mathias Agopian375f5632009-06-15 18:24:59 -07005401 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005402 return PERMISSION_DENIED;
5403 }
5404 int n;
5405 switch (code) {
Mathias Agopian01b76682009-04-16 20:04:08 -07005406 case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
Mathias Agopian35b48d12010-09-13 22:57:58 -07005407 case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005408 return NO_ERROR;
5409 case 1002: // SHOW_UPDATES
5410 n = data.readInt32();
5411 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
Mathias Agopian53331da2011-08-22 21:44:41 -07005412 invalidateHwcGeometry();
5413 repaintEverything();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005414 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005415 case 1004:{ // repaint everything
Mathias Agopian53331da2011-08-22 21:44:41 -07005416 repaintEverything();
Mathias Agopiancbb288b2009-09-07 16:32:45 -07005417 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005418 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -07005419 case 1005:{ // force transaction
Steven Thomas6d8110b2017-08-31 18:24:21 -07005420 Mutex::Autolock _l(mStateLock);
Mathias Agopiane57f2922012-08-09 16:29:12 -07005421 setTransactionFlags(
5422 eTransactionNeeded|
5423 eDisplayTransactionNeeded|
5424 eTraversalNeeded);
Mathias Agopiancbb288b2009-09-07 16:32:45 -07005425 return NO_ERROR;
5426 }
Mathias Agopian4d143ee2012-02-23 20:05:39 -08005427 case 1006:{ // send empty update
5428 signalRefresh();
5429 return NO_ERROR;
5430 }
Mathias Agopian53331da2011-08-22 21:44:41 -07005431 case 1008: // toggle use of hw composer
5432 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005433 mDebugDisableHWC = n != 0;
Mathias Agopian53331da2011-08-22 21:44:41 -07005434 invalidateHwcGeometry();
5435 repaintEverything();
5436 return NO_ERROR;
Mathias Agopiana4583642011-08-23 18:03:18 -07005437 case 1009: // toggle use of transform hint
5438 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005439 mDebugDisableTransformHint = n != 0;
Mathias Agopiana4583642011-08-23 18:03:18 -07005440 invalidateHwcGeometry();
5441 repaintEverything();
5442 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005443 case 1010: // interrogate.
Mathias Agopian01b76682009-04-16 20:04:08 -07005444 reply->writeInt32(0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005445 reply->writeInt32(0);
5446 reply->writeInt32(mDebugRegion);
Mathias Agopianb9494d52012-04-18 02:28:45 -07005447 reply->writeInt32(0);
Dianne Hackborn12839be2012-02-06 21:21:05 -08005448 reply->writeInt32(mDebugDisableHWC);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005449 return NO_ERROR;
5450 case 1013: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005451 const auto display = getDefaultDisplayDevice();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07005452 if (!display) {
5453 return NAME_NOT_FOUND;
5454 }
5455
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005456 reply->writeInt32(display->getPageFlipCount());
Mathias Agopianff2ed702013-09-01 21:36:12 -07005457 return NO_ERROR;
5458 }
5459 case 1014: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005460 Mutex::Autolock _l(mStateLock);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005461 // daltonize
5462 n = data.readInt32();
5463 switch (n % 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005464 case 1:
5465 mDaltonizer.setType(ColorBlindnessType::Protanomaly);
5466 break;
5467 case 2:
5468 mDaltonizer.setType(ColorBlindnessType::Deuteranomaly);
5469 break;
5470 case 3:
5471 mDaltonizer.setType(ColorBlindnessType::Tritanomaly);
5472 break;
5473 default:
5474 mDaltonizer.setType(ColorBlindnessType::None);
5475 break;
Mathias Agopianff2ed702013-09-01 21:36:12 -07005476 }
5477 if (n >= 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005478 mDaltonizer.setMode(ColorBlindnessMode::Correction);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005479 } else {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005480 mDaltonizer.setMode(ColorBlindnessMode::Simulation);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005481 }
Chia-I Wu28f320b2018-05-03 11:02:56 -07005482
5483 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005484 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005485 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005486 case 1015: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005487 Mutex::Autolock _l(mStateLock);
Alan Viverette9c5a3332013-09-12 20:04:35 -07005488 // apply a color matrix
5489 n = data.readInt32();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005490 if (n) {
Romain Guy0147a172017-06-01 13:53:56 -07005491 // color matrix is sent as a column-major mat4 matrix
Alan Viverette794c5ba2013-10-03 16:40:52 -07005492 for (size_t i = 0 ; i < 4; i++) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005493 for (size_t j = 0; j < 4; j++) {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005494 mClientColorMatrix[i][j] = data.readFloat();
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005495 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005496 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005497 } else {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005498 mClientColorMatrix = mat4();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005499 }
Romain Guy88d37dd2017-05-26 17:57:05 -07005500
5501 // Check that supplied matrix's last row is {0,0,0,1} so we can avoid
5502 // the division by w in the fragment shader
Chia-I Wu28f320b2018-05-03 11:02:56 -07005503 float4 lastRow(transpose(mClientColorMatrix)[3]);
Romain Guy88d37dd2017-05-26 17:57:05 -07005504 if (any(greaterThan(abs(lastRow - float4{0, 0, 0, 1}), float4{1e-4f}))) {
5505 ALOGE("The color transform's last row must be (0, 0, 0, 1)");
5506 }
5507
Chia-I Wu28f320b2018-05-03 11:02:56 -07005508 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005509 return NO_ERROR;
5510 }
Dominik Laskowski8d32ddc2019-08-07 11:25:35 -07005511 case 1016: { // Unused.
5512 return NAME_NOT_FOUND;
Ruchi Kandoif52b3c82014-04-24 16:42:35 -07005513 }
Dan Stozaee44edd2015-03-23 15:50:23 -07005514 case 1017: {
5515 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005516 mForceFullDamage = n != 0;
Dan Stozaee44edd2015-03-23 15:50:23 -07005517 return NO_ERROR;
5518 }
Ady Abraham9c53ee72020-07-22 21:16:18 -07005519 case 1018: { // Modify Choreographer's duration
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005520 n = data.readInt32();
Ady Abraham9c53ee72020-07-22 21:16:18 -07005521 mScheduler->setDuration(mAppConnectionHandle, std::chrono::nanoseconds(n), 0ns);
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005522 return NO_ERROR;
5523 }
Ady Abraham9c53ee72020-07-22 21:16:18 -07005524 case 1019: { // Modify SurfaceFlinger's duration
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005525 n = data.readInt32();
Ady Abraham9c53ee72020-07-22 21:16:18 -07005526 mScheduler->setDuration(mSfConnectionHandle, std::chrono::nanoseconds(n), 0ns);
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005527 return NO_ERROR;
5528 }
Irvel468051e2016-06-13 16:44:44 -07005529 case 1020: { // Layer updates interceptor
5530 n = data.readInt32();
5531 if (n) {
5532 ALOGV("Interceptor enabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08005533 mInterceptor->enable(mDrawingState.layersSortedByZ, mDrawingState.displays);
Irvel468051e2016-06-13 16:44:44 -07005534 }
5535 else{
5536 ALOGV("Interceptor disabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08005537 mInterceptor->disable();
Irvel468051e2016-06-13 16:44:44 -07005538 }
5539 return NO_ERROR;
5540 }
Dan Stoza8cf150a2016-08-02 10:27:31 -07005541 case 1021: { // Disable HWC virtual displays
Dominik Laskowski13948602021-03-08 20:48:28 -08005542 const bool enable = data.readInt32() != 0;
5543 static_cast<void>(schedule([this, enable] { enableHalVirtualDisplays(enable); }));
Dan Stoza8cf150a2016-08-02 10:27:31 -07005544 return NO_ERROR;
5545 }
Romain Guy0147a172017-06-01 13:53:56 -07005546 case 1022: { // Set saturation boost
Chia-I Wu28f320b2018-05-03 11:02:56 -07005547 Mutex::Autolock _l(mStateLock);
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005548 mGlobalSaturationFactor = std::max(0.0f, std::min(data.readFloat(), 2.0f));
Romain Guy0147a172017-06-01 13:53:56 -07005549
Chia-I Wu28f320b2018-05-03 11:02:56 -07005550 updateColorMatrixLocked();
Romain Guy0147a172017-06-01 13:53:56 -07005551 return NO_ERROR;
5552 }
Romain Guy54f154a2017-10-24 21:40:32 +01005553 case 1023: { // Set native mode
Daniel Solomon7c7ede22019-07-11 16:35:40 -07005554 int32_t colorMode;
5555
Chia-I Wu0d711262018-05-21 15:19:35 -07005556 mDisplayColorSetting = static_cast<DisplayColorSetting>(data.readInt32());
Daniel Solomon7c7ede22019-07-11 16:35:40 -07005557 if (data.readInt32(&colorMode) == NO_ERROR) {
5558 mForceColorMode = static_cast<ColorMode>(colorMode);
5559 }
Romain Guy54f154a2017-10-24 21:40:32 +01005560 invalidateHwcGeometry();
5561 repaintEverything();
5562 return NO_ERROR;
5563 }
Peiyong Lin4bac91c2018-10-25 09:48:33 -07005564 // Deprecate, use 1030 to check whether the device is color managed.
5565 case 1024: {
5566 return NAME_NOT_FOUND;
Romain Guy54f154a2017-10-24 21:40:32 +01005567 }
Vishnu Nair87704c92018-01-08 15:32:57 -08005568 case 1025: { // Set layer tracing
Adrian Roos1e1a1282017-11-01 19:05:31 +01005569 n = data.readInt32();
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07005570 bool tracingEnabledChanged;
Adrian Roos1e1a1282017-11-01 19:05:31 +01005571 if (n) {
Yichi Chenadc69612018-09-15 14:51:18 +08005572 ALOGD("LayerTracing enabled");
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07005573 tracingEnabledChanged = mTracing.enable();
5574 if (tracingEnabledChanged) {
5575 schedule([&]() MAIN_THREAD { mTracing.notify("start"); }).wait();
5576 }
Adrian Roos1e1a1282017-11-01 19:05:31 +01005577 } else {
Yichi Chenadc69612018-09-15 14:51:18 +08005578 ALOGD("LayerTracing disabled");
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07005579 tracingEnabledChanged = mTracing.disable();
Adrian Roos1e1a1282017-11-01 19:05:31 +01005580 }
Vishnu Nair31a8dbc2020-10-27 17:37:49 -07005581 mTracingEnabledChanged = tracingEnabledChanged;
5582 reply->writeInt32(NO_ERROR);
Adrian Roos1e1a1282017-11-01 19:05:31 +01005583 return NO_ERROR;
5584 }
Vishnu Nair87704c92018-01-08 15:32:57 -08005585 case 1026: { // Get layer tracing status
5586 reply->writeBool(mTracing.isEnabled());
5587 return NO_ERROR;
5588 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005589 // Is a DisplayColorSetting supported?
5590 case 1027: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005591 const auto display = getDefaultDisplayDevice();
5592 if (!display) {
Chia-I Wu0d711262018-05-21 15:19:35 -07005593 return NAME_NOT_FOUND;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005594 }
Chia-I Wu0d711262018-05-21 15:19:35 -07005595
5596 DisplayColorSetting setting = static_cast<DisplayColorSetting>(data.readInt32());
5597 switch (setting) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -08005598 case DisplayColorSetting::kManaged:
Peiyong Lin13effd12018-07-24 17:01:47 -07005599 reply->writeBool(useColorManagement);
Chia-I Wu0d711262018-05-21 15:19:35 -07005600 break;
Lloyd Pique6a3b4462019-03-07 20:58:12 -08005601 case DisplayColorSetting::kUnmanaged:
Chia-I Wu0d711262018-05-21 15:19:35 -07005602 reply->writeBool(true);
5603 break;
Lloyd Pique6a3b4462019-03-07 20:58:12 -08005604 case DisplayColorSetting::kEnhanced:
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005605 reply->writeBool(display->hasRenderIntent(RenderIntent::ENHANCE));
Chia-I Wu0d711262018-05-21 15:19:35 -07005606 break;
5607 default: // vendor display color setting
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005608 reply->writeBool(
5609 display->hasRenderIntent(static_cast<RenderIntent>(setting)));
Chia-I Wu0d711262018-05-21 15:19:35 -07005610 break;
5611 }
5612 return NO_ERROR;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005613 }
Alec Mouri9c58bcd2020-09-09 18:57:07 -07005614 case 1028: { // Unused.
5615 return NAME_NOT_FOUND;
Steven Thomas97f1f4c2018-06-01 12:04:16 -07005616 }
Nataniel Borges2b796da2019-02-15 13:32:18 -08005617 // Set buffer size for SF tracing (value in KB)
5618 case 1029: {
5619 n = data.readInt32();
5620 if (n <= 0 || n > MAX_TRACING_MEMORY) {
5621 ALOGW("Invalid buffer size: %d KB", n);
5622 reply->writeInt32(BAD_VALUE);
5623 return BAD_VALUE;
5624 }
5625
5626 ALOGD("Updating trace buffer to %d KB", n);
5627 mTracing.setBufferSize(n * 1024);
5628 reply->writeInt32(NO_ERROR);
5629 return NO_ERROR;
5630 }
Peiyong Lin13effd12018-07-24 17:01:47 -07005631 // Is device color managed?
5632 case 1030: {
5633 reply->writeBool(useColorManagement);
5634 return NO_ERROR;
5635 }
Peiyong Lin9d846a52018-11-05 13:18:20 -08005636 // Override default composition data space
5637 // adb shell service call SurfaceFlinger 1031 i32 1 DATASPACE_NUMBER DATASPACE_NUMBER \
5638 // && adb shell stop zygote && adb shell start zygote
5639 // to restore: adb shell service call SurfaceFlinger 1031 i32 0 && \
5640 // adb shell stop zygote && adb shell start zygote
5641 case 1031: {
5642 Mutex::Autolock _l(mStateLock);
5643 n = data.readInt32();
5644 if (n) {
5645 n = data.readInt32();
5646 if (n) {
5647 Dataspace dataspace = static_cast<Dataspace>(n);
5648 if (!validateCompositionDataspace(dataspace)) {
5649 return BAD_VALUE;
5650 }
5651 mDefaultCompositionDataspace = dataspace;
5652 }
5653 n = data.readInt32();
5654 if (n) {
5655 Dataspace dataspace = static_cast<Dataspace>(n);
5656 if (!validateCompositionDataspace(dataspace)) {
5657 return BAD_VALUE;
5658 }
5659 mWideColorGamutCompositionDataspace = dataspace;
5660 }
5661 } else {
5662 // restore composition data space.
5663 mDefaultCompositionDataspace = defaultCompositionDataspace;
5664 mWideColorGamutCompositionDataspace = wideColorGamutCompositionDataspace;
5665 }
5666 return NO_ERROR;
5667 }
Vishnu Nair9245d3b2019-03-22 13:38:56 -07005668 // Set trace flags
5669 case 1033: {
5670 n = data.readUint32();
5671 ALOGD("Updating trace flags to 0x%x", n);
5672 mTracing.setTraceFlags(n);
5673 reply->writeInt32(NO_ERROR);
5674 return NO_ERROR;
5675 }
Ady Abraham03b02dd2019-03-21 15:40:11 -07005676 case 1034: {
Ady Abraham1b11bc62021-06-03 19:51:19 -07005677 schedule([&] {
5678 switch (n = data.readInt32()) {
5679 case 0:
5680 case 1:
5681 ON_MAIN_THREAD(enableRefreshRateOverlay(static_cast<bool>(n)));
5682 break;
5683 default: {
5684 reply->writeBool(ON_MAIN_THREAD(isRefreshRateOverlayEnabled()));
5685 }
Dominik Laskowski20134642020-04-20 22:36:44 -07005686 }
Ady Abraham1b11bc62021-06-03 19:51:19 -07005687 }).get();
Ady Abraham03b02dd2019-03-21 15:40:11 -07005688 return NO_ERROR;
5689 }
Ady Abraham34392f72019-04-10 11:29:27 -07005690 case 1035: {
Marin Shalamanov5801c942020-12-17 17:00:13 +01005691 const int modeId = data.readInt32();
Marin Shalamanova7fe3042021-01-29 21:02:08 +01005692 mDebugDisplayModeSetByBackdoor = false;
Marin Shalamanov5801c942020-12-17 17:00:13 +01005693
Ady Abrahamfb853662021-04-09 11:46:40 -07005694 const auto displayId = [&]() -> std::optional<PhysicalDisplayId> {
5695 uint64_t inputDisplayId = 0;
5696 if (data.readUint64(&inputDisplayId) == NO_ERROR) {
5697 const auto token = getPhysicalDisplayToken(
5698 static_cast<PhysicalDisplayId>(inputDisplayId));
5699 if (!token) {
5700 ALOGE("No display with id: %" PRIu64, inputDisplayId);
5701 return std::nullopt;
5702 }
5703
5704 return std::make_optional<PhysicalDisplayId>(inputDisplayId);
5705 }
5706
Ady Abraham7825c682021-05-17 15:12:14 -07005707 return getDefaultDisplayDevice()->getPhysicalId();
Ady Abrahamfb853662021-04-09 11:46:40 -07005708 }();
5709
Marin Shalamanovea25ddf2020-12-10 15:44:51 +01005710 if (!displayId) {
Ady Abrahamfb853662021-04-09 11:46:40 -07005711 ALOGE("No display found");
Marin Shalamanovea25ddf2020-12-10 15:44:51 +01005712 return NO_ERROR;
5713 }
Marin Shalamanov5801c942020-12-17 17:00:13 +01005714
Marin Shalamanova7fe3042021-01-29 21:02:08 +01005715 status_t result = setActiveMode(getPhysicalDisplayToken(*displayId), modeId);
Marin Shalamanov5801c942020-12-17 17:00:13 +01005716 if (result != NO_ERROR) {
5717 return result;
Ady Abraham34392f72019-04-10 11:29:27 -07005718 }
Marin Shalamanov5801c942020-12-17 17:00:13 +01005719
Marin Shalamanova7fe3042021-01-29 21:02:08 +01005720 mDebugDisplayModeSetByBackdoor = true;
Marin Shalamanov5801c942020-12-17 17:00:13 +01005721
Ady Abraham34392f72019-04-10 11:29:27 -07005722 return NO_ERROR;
5723 }
Ady Abraham07e54702020-04-16 15:05:37 -07005724 case 1036: {
5725 if (data.readInt32() > 0) {
5726 status_t result =
5727 acquireFrameRateFlexibilityToken(&mDebugFrameRateFlexibilityToken);
5728 if (result != NO_ERROR) {
5729 return result;
5730 }
5731 } else {
5732 mDebugFrameRateFlexibilityToken = nullptr;
5733 }
5734 return NO_ERROR;
5735 }
Marin Shalamanove6332b02020-09-03 11:30:37 +02005736 // Inject a hotplug connected event for the primary display. This will deallocate and
5737 // reallocate the display state including framebuffers.
5738 case 1037: {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02005739 std::optional<hal::HWDisplayId> hwcId;
Marin Shalamanove6332b02020-09-03 11:30:37 +02005740 {
5741 Mutex::Autolock lock(mStateLock);
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02005742 hwcId = getHwComposer().getInternalHwcDisplayId();
Marin Shalamanove6332b02020-09-03 11:30:37 +02005743 }
Dominik Laskowskiebc8d3a2021-04-16 23:18:31 -07005744 onComposerHalHotplug(*hwcId, hal::Connection::CONNECTED);
Marin Shalamanove6332b02020-09-03 11:30:37 +02005745 return NO_ERROR;
5746 }
Adithya Srinivasan2d736322020-10-01 16:53:48 -07005747 // Modify the max number of display frames stored within FrameTimeline
5748 case 1038: {
5749 n = data.readInt32();
5750 if (n < 0 || n > MAX_ALLOWED_DISPLAY_FRAMES) {
5751 ALOGW("Invalid max size. Maximum allowed is %d", MAX_ALLOWED_DISPLAY_FRAMES);
5752 return BAD_VALUE;
5753 }
5754 if (n == 0) {
5755 // restore to default
5756 mFrameTimeline->reset();
5757 return NO_ERROR;
5758 }
5759 mFrameTimeline->setMaxDisplayFrames(n);
5760 return NO_ERROR;
5761 }
Ady Abraham0bb6a472020-10-12 10:22:13 -07005762 case 1039: {
Ady Abraham62f216c2020-10-13 19:07:23 -07005763 PhysicalDisplayId displayId = [&]() {
5764 Mutex::Autolock lock(mStateLock);
5765 return getDefaultDisplayDeviceLocked()->getPhysicalId();
5766 }();
5767
5768 auto inUid = static_cast<uid_t>(data.readInt32());
5769 const auto refreshRate = data.readFloat();
Ady Abraham62a0be22020-12-08 16:54:10 -08005770 mScheduler->setPreferredRefreshRateForUid(FrameRateOverride{inUid, refreshRate});
5771 mScheduler->onFrameRateOverridesChanged(mAppConnectionHandle, displayId);
Ady Abraham0bb6a472020-10-12 10:22:13 -07005772 return NO_ERROR;
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -08005773 }
Alec Mouri023c1882021-05-08 16:36:33 -07005774 // Toggle caching feature
5775 // First argument is an int32 - nonzero enables caching and zero disables caching
5776 // Second argument is an optional uint64 - if present, then limits enabling/disabling
5777 // caching to a particular physical display
5778 case 1040: {
Alec Mouric773472b2021-05-19 14:29:05 -07005779 status_t error =
5780 schedule([&] {
5781 n = data.readInt32();
5782 std::optional<PhysicalDisplayId> inputId = std::nullopt;
5783 if (uint64_t inputDisplayId;
5784 data.readUint64(&inputDisplayId) == NO_ERROR) {
5785 const auto token = getPhysicalDisplayToken(
5786 static_cast<PhysicalDisplayId>(inputDisplayId));
5787 if (!token) {
5788 ALOGE("No display with id: %" PRIu64, inputDisplayId);
5789 return NAME_NOT_FOUND;
5790 }
Alec Mouri023c1882021-05-08 16:36:33 -07005791
Alec Mouric773472b2021-05-19 14:29:05 -07005792 inputId = std::make_optional<PhysicalDisplayId>(inputDisplayId);
5793 }
5794 {
5795 Mutex::Autolock lock(mStateLock);
5796 mLayerCachingEnabled = n != 0;
5797 for (const auto& [_, display] : mDisplays) {
5798 if (!inputId || *inputId == display->getPhysicalId()) {
5799 display->enableLayerCaching(mLayerCachingEnabled);
5800 }
5801 }
5802 }
5803 return OK;
5804 }).get();
5805
5806 if (error != OK) {
5807 return error;
Alec Mouri023c1882021-05-08 16:36:33 -07005808 }
5809 invalidateHwcGeometry();
5810 repaintEverything();
5811 return NO_ERROR;
5812 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005813 }
5814 }
5815 return err;
5816}
5817
Steven Thomas6d8110b2017-08-31 18:24:21 -07005818void SurfaceFlinger::repaintEverything() {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07005819 mRepaintEverything = true;
Zhuoyao Zhang3d3540d2021-01-14 05:14:54 +00005820 signalTransaction();
Steven Thomas6d8110b2017-08-31 18:24:21 -07005821}
5822
Ana Krulec7d1d6832018-12-27 11:10:09 -08005823void SurfaceFlinger::repaintEverythingForHWC() {
5824 mRepaintEverything = true;
Dan Stoza030fbc12020-02-19 15:32:01 -08005825 mPowerAdvisor.notifyDisplayUpdateImminent();
Ady Abraham8532d012019-05-08 14:50:56 -07005826 mEventQueue->invalidate();
Ana Krulec7d1d6832018-12-27 11:10:09 -08005827}
5828
Ady Abrahama09852a2020-02-20 14:23:42 -08005829void SurfaceFlinger::kernelTimerChanged(bool expired) {
5830 static bool updateOverlay =
5831 property_get_bool("debug.sf.kernel_idle_timer_update_overlay", true);
Dominik Laskowski20134642020-04-20 22:36:44 -07005832 if (!updateOverlay) return;
Ady Abraham1b11bc62021-06-03 19:51:19 -07005833 if (Mutex::Autolock lock(mStateLock); !isRefreshRateOverlayEnabled()) return;
Ady Abrahama09852a2020-02-20 14:23:42 -08005834
5835 // Update the overlay on the main thread to avoid race conditions with
5836 // mRefreshRateConfigs->getCurrentRefreshRate()
Dominik Laskowski20134642020-04-20 22:36:44 -07005837 static_cast<void>(schedule([=] {
Ady Abraham3efa3942021-06-24 19:01:25 -07005838 const auto display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked());
5839 if (!display) {
5840 ALOGW("%s: default display is null", __func__);
5841 return;
5842 }
Ady Abrahamb4937392021-06-23 18:05:03 -07005843
5844 const auto desiredActiveMode = display->getDesiredActiveMode();
5845 const std::optional<DisplayModeId> desiredModeId = desiredActiveMode
5846 ? std::make_optional(desiredActiveMode->mode->getId())
5847 : std::nullopt;
5848
5849 const bool timerExpired = mKernelIdleTimerEnabled && expired;
5850
Ady Abraham1b11bc62021-06-03 19:51:19 -07005851 if (display->onKernelTimerChanged(desiredModeId, timerExpired)) {
Dominik Laskowski20134642020-04-20 22:36:44 -07005852 mEventQueue->invalidate();
Ady Abrahama09852a2020-02-20 14:23:42 -08005853 }
5854 }));
5855}
5856
Ana Krulecb9afd792020-06-11 13:16:15 -07005857void SurfaceFlinger::toggleKernelIdleTimer() {
5858 using KernelIdleTimerAction = scheduler::RefreshRateConfigs::KernelIdleTimerAction;
5859
5860 // If the support for kernel idle timer is disabled in SF code, don't do anything.
5861 if (!mSupportKernelIdleTimer) {
5862 return;
5863 }
Ady Abraham3efa3942021-06-24 19:01:25 -07005864 const auto display = getDefaultDisplayDeviceLocked();
5865 if (!display) {
5866 ALOGW("%s: default display is null", __func__);
5867 return;
5868 }
Ana Krulecb9afd792020-06-11 13:16:15 -07005869
Ady Abraham3efa3942021-06-24 19:01:25 -07005870 const KernelIdleTimerAction action = display->refreshRateConfigs().getIdleTimerAction();
Ana Krulecb9afd792020-06-11 13:16:15 -07005871 switch (action) {
5872 case KernelIdleTimerAction::TurnOff:
5873 if (mKernelIdleTimerEnabled) {
5874 ATRACE_INT("KernelIdleTimer", 0);
5875 base::SetProperty(KERNEL_IDLE_TIMER_PROP, "false");
5876 mKernelIdleTimerEnabled = false;
5877 }
5878 break;
5879 case KernelIdleTimerAction::TurnOn:
5880 if (!mKernelIdleTimerEnabled) {
5881 ATRACE_INT("KernelIdleTimer", 1);
5882 base::SetProperty(KERNEL_IDLE_TIMER_PROP, "true");
5883 mKernelIdleTimerEnabled = true;
5884 }
5885 break;
Ana Krulecb9afd792020-06-11 13:16:15 -07005886 }
5887}
5888
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005889// A simple RAII class to disconnect from an ANativeWindow* when it goes out of scope
5890class WindowDisconnector {
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005891public:
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005892 WindowDisconnector(ANativeWindow* window, int api) : mWindow(window), mApi(api) {}
5893 ~WindowDisconnector() {
5894 native_window_api_disconnect(mWindow, mApi);
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005895 }
5896
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005897private:
5898 ANativeWindow* mWindow;
5899 const int mApi;
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005900};
5901
chaviw93df2ea2019-04-30 16:45:12 -07005902static Dataspace pickDataspaceFromColorMode(const ColorMode colorMode) {
5903 switch (colorMode) {
5904 case ColorMode::DISPLAY_P3:
5905 case ColorMode::BT2100_PQ:
5906 case ColorMode::BT2100_HLG:
5907 case ColorMode::DISPLAY_BT2020:
5908 return Dataspace::DISPLAY_P3;
5909 default:
5910 return Dataspace::V0_SRGB;
5911 }
5912}
5913
chaviwf5bb97b2021-04-28 15:35:37 -05005914static bool hasCaptureBlackoutContentPermission() {
5915 IPCThreadState* ipc = IPCThreadState::self();
5916 const int pid = ipc->getCallingPid();
5917 const int uid = ipc->getCallingUid();
5918 return uid == AID_GRAPHICS || uid == AID_SYSTEM ||
5919 PermissionCache::checkPermission(sCaptureBlackoutContent, pid, uid);
5920}
5921
chaviw4b9d5e12020-08-04 18:30:35 -07005922static status_t validateScreenshotPermissions(const CaptureArgs& captureArgs) {
5923 IPCThreadState* ipc = IPCThreadState::self();
5924 const int pid = ipc->getCallingPid();
5925 const int uid = ipc->getCallingUid();
5926 if (uid == AID_GRAPHICS || PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
5927 return OK;
5928 }
5929
5930 // If the caller doesn't have the correct permissions but is only attempting to screenshot
5931 // itself, we allow it to continue.
5932 if (captureArgs.uid == uid) {
5933 return OK;
5934 }
5935
5936 ALOGE("Permission Denial: can't take screenshot pid=%d, uid=%d", pid, uid);
5937 return PERMISSION_DENIED;
5938}
5939
Peiyong Lin05cc0112020-10-14 16:16:37 -07005940status_t SurfaceFlinger::setSchedFifo(bool enabled) {
5941 static constexpr int kFifoPriority = 2;
5942 static constexpr int kOtherPriority = 0;
5943
5944 struct sched_param param = {0};
5945 int sched_policy;
5946 if (enabled) {
5947 sched_policy = SCHED_FIFO;
5948 param.sched_priority = kFifoPriority;
5949 } else {
5950 sched_policy = SCHED_OTHER;
5951 param.sched_priority = kOtherPriority;
5952 }
5953
5954 if (sched_setscheduler(0, sched_policy, &param) != 0) {
5955 return -errno;
5956 }
Wei Wang23aa5a62021-06-04 15:56:57 -07005957
5958 return NO_ERROR;
5959}
5960
5961status_t SurfaceFlinger::setSchedAttr(bool enabled) {
5962 static const unsigned int kUclampMin =
5963 base::GetUintProperty<unsigned int>("ro.surface_flinger.uclamp.min", 0U);
5964
5965 if (!kUclampMin) {
5966 // uclamp.min set to 0 (default), skip setting
5967 return NO_ERROR;
5968 }
5969
5970 // Currently, there is no wrapper in bionic: b/183240349.
5971 struct sched_attr {
5972 uint32_t size;
5973 uint32_t sched_policy;
5974 uint64_t sched_flags;
5975 int32_t sched_nice;
5976 uint32_t sched_priority;
5977 uint64_t sched_runtime;
5978 uint64_t sched_deadline;
5979 uint64_t sched_period;
5980 uint32_t sched_util_min;
5981 uint32_t sched_util_max;
5982 };
5983
5984 sched_attr attr = {};
5985 attr.size = sizeof(attr);
5986
5987 attr.sched_flags = (SCHED_FLAG_KEEP_ALL | SCHED_FLAG_UTIL_CLAMP);
5988 attr.sched_util_min = enabled ? kUclampMin : 0;
5989 attr.sched_util_max = 1024;
5990
5991 if (syscall(__NR_sched_setattr, 0, &attr, 0)) {
5992 return -errno;
5993 }
5994
Peiyong Lin05cc0112020-10-14 16:16:37 -07005995 return NO_ERROR;
5996}
5997
chaviwd2432892020-07-24 17:42:39 -07005998status_t SurfaceFlinger::captureDisplay(const DisplayCaptureArgs& args,
chaviw8ffc7b82020-08-18 11:25:37 -07005999 const sp<IScreenCaptureListener>& captureListener) {
chaviwd2432892020-07-24 17:42:39 -07006000 ATRACE_CALL();
6001
chaviw4b9d5e12020-08-04 18:30:35 -07006002 status_t validate = validateScreenshotPermissions(args);
6003 if (validate != OK) {
6004 return validate;
6005 }
6006
chaviwd2432892020-07-24 17:42:39 -07006007 if (!args.displayToken) return BAD_VALUE;
6008
Dominik Laskowski0bb9e652021-03-18 12:21:29 -07006009 wp<const DisplayDevice> displayWeak;
chaviwd2432892020-07-24 17:42:39 -07006010 ui::LayerStack layerStack;
6011 ui::Size reqSize(args.width, args.height);
6012 ui::Dataspace dataspace;
6013 {
6014 Mutex::Autolock lock(mStateLock);
6015 sp<DisplayDevice> display = getDisplayDeviceLocked(args.displayToken);
6016 if (!display) return NAME_NOT_FOUND;
6017 displayWeak = display;
6018 layerStack = display->getLayerStack();
6019
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02006020 // set the requested width/height to the logical display layer stack rect size by default
chaviwd2432892020-07-24 17:42:39 -07006021 if (args.width == 0 || args.height == 0) {
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02006022 reqSize = display->getLayerStackSpaceRect().getSize();
chaviwd2432892020-07-24 17:42:39 -07006023 }
6024
arthurhung79e81aa2020-08-28 00:09:19 +08006025 // The dataspace is depended on the color mode of display, that could use non-native mode
6026 // (ex. displayP3) to enhance the content, but some cases are checking native RGB in bytes,
6027 // and failed if display is not in native mode. This provide a way to force using native
6028 // colors when capture.
Peiyong Lincd261472020-10-06 18:05:25 -07006029 dataspace = args.dataspace;
6030 if (dataspace == ui::Dataspace::UNKNOWN) {
arthurhung79e81aa2020-08-28 00:09:19 +08006031 const ui::ColorMode colorMode = display->getCompositionDisplay()->getState().colorMode;
6032 dataspace = pickDataspaceFromColorMode(colorMode);
6033 }
chaviwd2432892020-07-24 17:42:39 -07006034 }
6035
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -08006036 RenderAreaFuture renderAreaFuture = ftl::defer([=] {
chaviwd2432892020-07-24 17:42:39 -07006037 return DisplayRenderArea::create(displayWeak, args.sourceCrop, reqSize, dataspace,
chaviwc6ad8af2020-08-03 11:33:30 -07006038 args.useIdentityTransform, args.captureSecureLayers);
chaviwd2432892020-07-24 17:42:39 -07006039 });
6040
chaviw4b9d5e12020-08-04 18:30:35 -07006041 auto traverseLayers = [this, args, layerStack](const LayerVector::Visitor& visitor) {
6042 traverseLayersInLayerStack(layerStack, args.uid, visitor);
chaviwd2432892020-07-24 17:42:39 -07006043 };
chaviw03900772020-08-18 12:34:51 -07006044
6045 return captureScreenCommon(std::move(renderAreaFuture), traverseLayers, reqSize,
chaviw17ac24b2021-01-28 18:50:05 -08006046 args.pixelFormat, args.allowProtected, args.grayscale,
6047 captureListener);
chaviw93df2ea2019-04-30 16:45:12 -07006048}
6049
Dominik Laskowski0bb9e652021-03-18 12:21:29 -07006050status_t SurfaceFlinger::captureDisplay(uint64_t displayIdOrLayerStack,
chaviw8ffc7b82020-08-18 11:25:37 -07006051 const sp<IScreenCaptureListener>& captureListener) {
Marin Shalamanov1c434292020-06-12 01:47:29 +02006052 ui::LayerStack layerStack;
Dominik Laskowski0bb9e652021-03-18 12:21:29 -07006053 wp<const DisplayDevice> displayWeak;
Marin Shalamanov1c434292020-06-12 01:47:29 +02006054 ui::Size size;
chaviw426b5c02020-07-27 11:20:15 -07006055 ui::Dataspace dataspace;
chaviw93df2ea2019-04-30 16:45:12 -07006056 {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07006057 Mutex::Autolock lock(mStateLock);
Dominik Laskowski0bb9e652021-03-18 12:21:29 -07006058 auto display = getDisplayDeviceLocked(PhysicalDisplayId{displayIdOrLayerStack});
6059
6060 // Fall back to first display whose layer stack matches.
6061 if (!display) {
6062 const auto layerStack = static_cast<ui::LayerStack>(displayIdOrLayerStack);
6063 display = findDisplay(WithLayerStack(layerStack));
6064 }
6065
chaviw93df2ea2019-04-30 16:45:12 -07006066 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07006067 return NAME_NOT_FOUND;
chaviw93df2ea2019-04-30 16:45:12 -07006068 }
Dominik Laskowski0bb9e652021-03-18 12:21:29 -07006069
Marin Shalamanov1c434292020-06-12 01:47:29 +02006070 layerStack = display->getLayerStack();
6071 displayWeak = display;
chaviw93df2ea2019-04-30 16:45:12 -07006072
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02006073 size = display->getLayerStackSpaceRect().getSize();
chaviw93df2ea2019-04-30 16:45:12 -07006074
chaviw426b5c02020-07-27 11:20:15 -07006075 dataspace =
chaviw93df2ea2019-04-30 16:45:12 -07006076 pickDataspaceFromColorMode(display->getCompositionDisplay()->getState().colorMode);
6077 }
6078
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -08006079 RenderAreaFuture renderAreaFuture = ftl::defer([=] {
chaviw8ffc7b82020-08-18 11:25:37 -07006080 return DisplayRenderArea::create(displayWeak, Rect(), size, dataspace,
chaviwc6ad8af2020-08-03 11:33:30 -07006081 false /* useIdentityTransform */,
chaviwd2432892020-07-24 17:42:39 -07006082 false /* captureSecureLayers */);
Marin Shalamanov1c434292020-06-12 01:47:29 +02006083 });
chaviw93df2ea2019-04-30 16:45:12 -07006084
Marin Shalamanov1c434292020-06-12 01:47:29 +02006085 auto traverseLayers = [this, layerStack](const LayerVector::Visitor& visitor) {
chaviw4b9d5e12020-08-04 18:30:35 -07006086 traverseLayersInLayerStack(layerStack, CaptureArgs::UNSET_UID, visitor);
Marin Shalamanov1c434292020-06-12 01:47:29 +02006087 };
6088
chaviw03900772020-08-18 12:34:51 -07006089 return captureScreenCommon(std::move(renderAreaFuture), traverseLayers, size,
Peiyong Lin05cc0112020-10-14 16:16:37 -07006090 ui::PixelFormat::RGBA_8888, false /* allowProtected */,
chaviw17ac24b2021-01-28 18:50:05 -08006091 false /* grayscale */, captureListener);
chaviw93df2ea2019-04-30 16:45:12 -07006092}
6093
chaviw3efadb12020-07-27 10:07:15 -07006094status_t SurfaceFlinger::captureLayers(const LayerCaptureArgs& args,
chaviw8ffc7b82020-08-18 11:25:37 -07006095 const sp<IScreenCaptureListener>& captureListener) {
chaviwa76b2712017-09-20 12:02:26 -07006096 ATRACE_CALL();
6097
chaviw4b9d5e12020-08-04 18:30:35 -07006098 status_t validate = validateScreenshotPermissions(args);
6099 if (validate != OK) {
6100 return validate;
6101 }
6102
Marin Shalamanov1c434292020-06-12 01:47:29 +02006103 ui::Size reqSize;
Robert Carrc0df3122019-04-11 13:18:21 -07006104 sp<Layer> parent;
chaviw3efadb12020-07-27 10:07:15 -07006105 Rect crop(args.sourceCrop);
Robert Carrc0df3122019-04-11 13:18:21 -07006106 std::unordered_set<sp<Layer>, ISurfaceComposer::SpHash<Layer>> excludeLayers;
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02006107 Rect layerStackSpaceRect;
chaviw3efadb12020-07-27 10:07:15 -07006108 ui::Dataspace dataspace;
chaviw70cb6a42020-07-30 13:57:36 -07006109 bool captureSecureLayers;
chaviwf5bb97b2021-04-28 15:35:37 -05006110
6111 // Call this before holding mStateLock to avoid any deadlocking.
6112 bool canCaptureBlackoutContent = hasCaptureBlackoutContentPermission();
6113
Robert Carrc0df3122019-04-11 13:18:21 -07006114 {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07006115 Mutex::Autolock lock(mStateLock);
chaviw7206d492017-11-10 16:16:12 -08006116
chaviw3efadb12020-07-27 10:07:15 -07006117 parent = fromHandleLocked(args.layerHandle).promote();
Robert Carrc0df3122019-04-11 13:18:21 -07006118 if (parent == nullptr || parent->isRemovedFromCurrentState()) {
6119 ALOGE("captureLayers called with an invalid or removed parent");
6120 return NAME_NOT_FOUND;
6121 }
6122
chaviwf5bb97b2021-04-28 15:35:37 -05006123 if (!canCaptureBlackoutContent &&
Robert Carr6a160312021-05-17 12:08:20 -07006124 parent->getDrawingState().flags & layer_state_t::eLayerSecure) {
Robert Carrc0df3122019-04-11 13:18:21 -07006125 ALOGW("Attempting to capture secure layer: PERMISSION_DENIED");
6126 return PERMISSION_DENIED;
6127 }
6128
Robert Carr6a160312021-05-17 12:08:20 -07006129 Rect parentSourceBounds = parent->getCroppedBufferSize(parent->getDrawingState());
chaviw3efadb12020-07-27 10:07:15 -07006130 if (args.sourceCrop.width() <= 0) {
Robert Carrc0df3122019-04-11 13:18:21 -07006131 crop.left = 0;
Vishnu Nairefc42e22019-12-03 17:36:12 -08006132 crop.right = parentSourceBounds.getWidth();
Robert Carrc0df3122019-04-11 13:18:21 -07006133 }
6134
chaviw3efadb12020-07-27 10:07:15 -07006135 if (args.sourceCrop.height() <= 0) {
Robert Carrc0df3122019-04-11 13:18:21 -07006136 crop.top = 0;
Vishnu Nairefc42e22019-12-03 17:36:12 -08006137 crop.bottom = parentSourceBounds.getHeight();
6138 }
6139
chaviw17ac24b2021-01-28 18:50:05 -08006140 if (crop.isEmpty() || args.frameScaleX <= 0.0f || args.frameScaleY <= 0.0f) {
Vishnu Nairefc42e22019-12-03 17:36:12 -08006141 // Error out if the layer has no source bounds (i.e. they are boundless) and a source
6142 // crop was not specified, or an invalid frame scale was provided.
6143 return BAD_VALUE;
Robert Carrc0df3122019-04-11 13:18:21 -07006144 }
chaviw17ac24b2021-01-28 18:50:05 -08006145 reqSize = ui::Size(crop.width() * args.frameScaleX, crop.height() * args.frameScaleY);
Robert Carrc0df3122019-04-11 13:18:21 -07006146
chaviw3efadb12020-07-27 10:07:15 -07006147 for (const auto& handle : args.excludeHandles) {
Alec Mouri9a02eda2020-04-21 17:39:34 -07006148 sp<Layer> excludeLayer = fromHandleLocked(handle).promote();
Robert Carrc0df3122019-04-11 13:18:21 -07006149 if (excludeLayer != nullptr) {
6150 excludeLayers.emplace(excludeLayer);
6151 } else {
6152 ALOGW("Invalid layer handle passed as excludeLayer to captureLayers");
6153 return NAME_NOT_FOUND;
6154 }
6155 }
Vishnu Nair3a7346c2019-12-04 08:09:09 -08006156
Dominik Laskowski0bb9e652021-03-18 12:21:29 -07006157 const auto display = findDisplay(WithLayerStack(parent->getLayerStack()));
Vishnu Nair3a7346c2019-12-04 08:09:09 -08006158 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07006159 return NAME_NOT_FOUND;
Vishnu Nair3a7346c2019-12-04 08:09:09 -08006160 }
6161
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02006162 layerStackSpaceRect = display->getLayerStackSpaceRect();
chaviw3efadb12020-07-27 10:07:15 -07006163
arthurhung79e81aa2020-08-28 00:09:19 +08006164 // The dataspace is depended on the color mode of display, that could use non-native mode
6165 // (ex. displayP3) to enhance the content, but some cases are checking native RGB in bytes,
6166 // and failed if display is not in native mode. This provide a way to force using native
6167 // colors when capture.
Peiyong Lincd261472020-10-06 18:05:25 -07006168 dataspace = args.dataspace;
6169 if (dataspace == ui::Dataspace::UNKNOWN) {
arthurhung79e81aa2020-08-28 00:09:19 +08006170 const ui::ColorMode colorMode = display->getCompositionDisplay()->getState().colorMode;
6171 dataspace = pickDataspaceFromColorMode(colorMode);
6172 }
chaviw70cb6a42020-07-30 13:57:36 -07006173
6174 captureSecureLayers = args.captureSecureLayers && display->isSecure();
Robert Carrc0df3122019-04-11 13:18:21 -07006175 } // mStateLock
chaviw7206d492017-11-10 16:16:12 -08006176
Chia-I Wu20261cb2018-08-23 12:55:44 -07006177 // really small crop or frameScale
Marin Shalamanov1c434292020-06-12 01:47:29 +02006178 if (reqSize.width <= 0) {
6179 reqSize.width = 1;
Chia-I Wu20261cb2018-08-23 12:55:44 -07006180 }
Marin Shalamanov1c434292020-06-12 01:47:29 +02006181 if (reqSize.height <= 0) {
6182 reqSize.height = 1;
Chia-I Wu20261cb2018-08-23 12:55:44 -07006183 }
6184
chaviw3efadb12020-07-27 10:07:15 -07006185 bool childrenOnly = args.childrenOnly;
Dominik Laskowski4e2b71f2020-11-10 15:05:32 -08006186 RenderAreaFuture renderAreaFuture = ftl::defer([=]() -> std::unique_ptr<RenderArea> {
chaviw3efadb12020-07-27 10:07:15 -07006187 return std::make_unique<LayerRenderArea>(*this, parent, crop, reqSize, dataspace,
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02006188 childrenOnly, layerStackSpaceRect,
chaviw70cb6a42020-07-30 13:57:36 -07006189 captureSecureLayers);
Marin Shalamanov1c434292020-06-12 01:47:29 +02006190 });
6191
chaviw03900772020-08-18 12:34:51 -07006192 auto traverseLayers = [parent, args, excludeLayers](const LayerVector::Visitor& visitor) {
chaviwa76b2712017-09-20 12:02:26 -07006193 parent->traverseChildrenInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
6194 if (!layer->isVisible()) {
6195 return;
chaviw4b9d5e12020-08-04 18:30:35 -07006196 } else if (args.childrenOnly && layer == parent.get()) {
6197 return;
6198 } else if (args.uid != CaptureArgs::UNSET_UID && args.uid != layer->getOwnerUid()) {
Robert Carr578038f2018-03-09 12:25:24 -08006199 return;
chaviwa76b2712017-09-20 12:02:26 -07006200 }
Robert Carr866455f2019-04-02 16:28:26 -07006201
6202 sp<Layer> p = layer;
6203 while (p != nullptr) {
6204 if (excludeLayers.count(p) != 0) {
6205 return;
6206 }
6207 p = p->getParent();
6208 }
6209
chaviwa76b2712017-09-20 12:02:26 -07006210 visitor(layer);
6211 });
6212 };
Robert Carr108b2c72019-04-02 16:32:58 -07006213
chaviw03900772020-08-18 12:34:51 -07006214 return captureScreenCommon(std::move(renderAreaFuture), traverseLayers, reqSize,
chaviw17ac24b2021-01-28 18:50:05 -08006215 args.pixelFormat, args.allowProtected, args.grayscale,
6216 captureListener);
chaviwa76b2712017-09-20 12:02:26 -07006217}
6218
Marin Shalamanov1c434292020-06-12 01:47:29 +02006219status_t SurfaceFlinger::captureScreenCommon(RenderAreaFuture renderAreaFuture,
chaviwa76b2712017-09-20 12:02:26 -07006220 TraverseLayersFunction traverseLayers,
chaviw426b5c02020-07-27 11:20:15 -07006221 ui::Size bufferSize, ui::PixelFormat reqPixelFormat,
chaviw17ac24b2021-01-28 18:50:05 -08006222 bool allowProtected, bool grayscale,
chaviw03900772020-08-18 12:34:51 -07006223 const sp<IScreenCaptureListener>& captureListener) {
chaviwa76b2712017-09-20 12:02:26 -07006224 ATRACE_CALL();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08006225
Garfield Tan9c9c1912021-07-19 12:02:16 -07006226 if (exceedsMaxRenderTargetSize(bufferSize.getWidth(), bufferSize.getHeight())) {
6227 ALOGE("Attempted to capture screen with size (%" PRId32 ", %" PRId32
6228 ") that exceeds render target size limit.",
6229 bufferSize.getWidth(), bufferSize.getHeight());
6230 return BAD_VALUE;
6231 }
6232
Peiyong Lin05cc0112020-10-14 16:16:37 -07006233 // Loop over all visible layers to see whether there's any protected layer. A protected layer is
6234 // typically a layer with DRM contents, or have the GRALLOC_USAGE_PROTECTED set on the buffer.
6235 // A protected layer has no implication on whether it's secure, which is explicitly set by
6236 // application to avoid being screenshot or drawn via unsecure display.
6237 const bool supportsProtected = getRenderEngine().supportsProtectedContent();
6238 bool hasProtectedLayer = false;
6239 if (allowProtected && supportsProtected) {
Peiyong Lin56802272020-11-13 16:53:31 -08006240 hasProtectedLayer = schedule([=]() {
6241 bool protectedLayerFound = false;
6242 traverseLayers([&](Layer* layer) {
6243 protectedLayerFound = protectedLayerFound ||
6244 (layer->isVisible() && layer->isProtected());
6245 });
6246 return protectedLayerFound;
6247 }).get();
Peiyong Lin05cc0112020-10-14 16:16:37 -07006248 }
6249
Richard Liucbcb8952020-04-08 10:51:55 +00006250 const uint32_t usage = GRALLOC_USAGE_HW_COMPOSER | GRALLOC_USAGE_HW_RENDER |
6251 GRALLOC_USAGE_HW_TEXTURE |
Peiyong Lin05cc0112020-10-14 16:16:37 -07006252 (hasProtectedLayer && allowProtected && supportsProtected
6253 ? GRALLOC_USAGE_PROTECTED
6254 : GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);
chaviw426b5c02020-07-27 11:20:15 -07006255 sp<GraphicBuffer> buffer =
6256 getFactory().createGraphicBuffer(bufferSize.getWidth(), bufferSize.getHeight(),
6257 static_cast<android_pixel_format>(reqPixelFormat),
6258 1 /* layerCount */, usage, "screenshot");
Alec Mouri7013b6f2021-02-12 11:16:54 -08006259
6260 const status_t bufferStatus = buffer->initCheck();
6261 LOG_ALWAYS_FATAL_IF(bufferStatus != OK, "captureScreenCommon: Buffer failed to allocate: %d",
6262 bufferStatus);
Alec Mouria90a5702021-04-16 16:36:21 +00006263 const auto texture = std::make_shared<
6264 renderengine::ExternalTexture>(buffer, getRenderEngine(),
6265 renderengine::ExternalTexture::Usage::WRITEABLE);
6266 return captureScreenCommon(std::move(renderAreaFuture), traverseLayers, texture,
Derek Sollenberger34257882021-04-06 18:32:34 +00006267 false /* regionSampling */, grayscale, captureListener);
Dan Stozaec460082018-12-17 15:35:09 -08006268}
6269
Alec Mouria90a5702021-04-16 16:36:21 +00006270status_t SurfaceFlinger::captureScreenCommon(
6271 RenderAreaFuture renderAreaFuture, TraverseLayersFunction traverseLayers,
6272 const std::shared_ptr<renderengine::ExternalTexture>& buffer, bool regionSampling,
6273 bool grayscale, const sp<IScreenCaptureListener>& captureListener) {
chaviw03900772020-08-18 12:34:51 -07006274 ATRACE_CALL();
6275
6276 if (captureListener == nullptr) {
6277 ALOGE("capture screen must provide a capture listener callback");
6278 return BAD_VALUE;
6279 }
6280
chaviwf5bb97b2021-04-28 15:35:37 -05006281 bool canCaptureBlackoutContent = hasCaptureBlackoutContentPermission();
Robert Carr03480e22018-01-04 16:02:06 -08006282
chaviw03900772020-08-18 12:34:51 -07006283 static_cast<void>(schedule([=, renderAreaFuture = std::move(renderAreaFuture)]() mutable {
6284 if (mRefreshPending) {
6285 ALOGW("Skipping screenshot for now");
6286 captureScreenCommon(std::move(renderAreaFuture), traverseLayers, buffer, regionSampling,
chaviw17ac24b2021-01-28 18:50:05 -08006287 grayscale, captureListener);
chaviw03900772020-08-18 12:34:51 -07006288 return;
6289 }
6290 ScreenCaptureResults captureResults;
6291 std::unique_ptr<RenderArea> renderArea = renderAreaFuture.get();
6292 if (!renderArea) {
6293 ALOGW("Skipping screen capture because of invalid render area.");
6294 captureResults.result = NO_MEMORY;
Ady Abraham99599942021-01-27 20:27:23 -08006295 captureListener->onScreenCaptureCompleted(captureResults);
chaviw03900772020-08-18 12:34:51 -07006296 return;
6297 }
Dan Stoza2b6d38e2017-06-01 16:40:30 -07006298
chaviw03900772020-08-18 12:34:51 -07006299 status_t result = NO_ERROR;
chaviw03900772020-08-18 12:34:51 -07006300 renderArea->render([&] {
chaviwf5bb97b2021-04-28 15:35:37 -05006301 result = renderScreenImplLocked(*renderArea, traverseLayers, buffer,
6302 canCaptureBlackoutContent, regionSampling, grayscale,
6303 captureResults);
chaviw03900772020-08-18 12:34:51 -07006304 });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07006305
chaviw03900772020-08-18 12:34:51 -07006306 captureResults.result = result;
Ady Abraham99599942021-01-27 20:27:23 -08006307 captureListener->onScreenCaptureCompleted(captureResults);
chaviw03900772020-08-18 12:34:51 -07006308 }));
Dan Stoza2b6d38e2017-06-01 16:40:30 -07006309
chaviw03900772020-08-18 12:34:51 -07006310 return NO_ERROR;
Mathias Agopian2a9fc492013-03-01 13:42:57 -08006311}
6312
Alec Mouria90a5702021-04-16 16:36:21 +00006313status_t SurfaceFlinger::renderScreenImplLocked(
6314 const RenderArea& renderArea, TraverseLayersFunction traverseLayers,
chaviwf5bb97b2021-04-28 15:35:37 -05006315 const std::shared_ptr<renderengine::ExternalTexture>& buffer,
6316 bool canCaptureBlackoutContent, bool regionSampling, bool grayscale,
6317 ScreenCaptureResults& captureResults) {
Mathias Agopian180f10d2013-04-10 22:55:41 -07006318 ATRACE_CALL();
chaviwa76b2712017-09-20 12:02:26 -07006319
chaviw426b5c02020-07-27 11:20:15 -07006320 traverseLayers([&](Layer* layer) {
6321 captureResults.capturedSecureLayers =
6322 captureResults.capturedSecureLayers || (layer->isVisible() && layer->isSecure());
6323 });
6324
Alec Mouria90a5702021-04-16 16:36:21 +00006325 const bool useProtected = buffer->getBuffer()->getUsage() & GRALLOC_USAGE_PROTECTED;
Peiyong Lin05cc0112020-10-14 16:16:37 -07006326
chaviw426b5c02020-07-27 11:20:15 -07006327 // We allow the system server to take screenshots of secure layers for
6328 // use in situations like the Screen-rotation animation and place
6329 // the impetus on WindowManager to not persist them.
chaviwf5bb97b2021-04-28 15:35:37 -05006330 if (captureResults.capturedSecureLayers && !canCaptureBlackoutContent) {
chaviw426b5c02020-07-27 11:20:15 -07006331 ALOGW("FB is protected: PERMISSION_DENIED");
6332 return PERMISSION_DENIED;
6333 }
6334
Alec Mouria90a5702021-04-16 16:36:21 +00006335 captureResults.buffer = buffer->getBuffer();
chaviw426b5c02020-07-27 11:20:15 -07006336 captureResults.capturedDataspace = renderArea.getReqDataSpace();
6337
chaviwa76b2712017-09-20 12:02:26 -07006338 const auto reqWidth = renderArea.getReqWidth();
6339 const auto reqHeight = renderArea.getReqHeight();
Alec Mouriadb75f42019-03-28 21:42:24 -07006340 const auto sourceCrop = renderArea.getSourceCrop();
Alec Mouri5a6d8572020-03-23 23:56:15 -07006341 const auto transform = renderArea.getTransform();
6342 const auto rotation = renderArea.getRotationFlags();
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02006343 const auto& layerStackSpaceRect = renderArea.getLayerStackSpaceRect();
Dan Stozac1879002014-05-22 15:59:05 -07006344
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006345 renderengine::DisplaySettings clientCompositionDisplay;
Vishnu Nair9b079a22020-01-21 14:36:08 -08006346 std::vector<compositionengine::LayerFE::LayerSettings> clientCompositionLayers;
Romain Guy88d37dd2017-05-26 17:57:05 -07006347
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006348 // assume that bounds are never offset, and that they are the same as the
6349 // buffer bounds.
6350 clientCompositionDisplay.physicalDisplay = Rect(reqWidth, reqHeight);
Alec Mouriadb75f42019-03-28 21:42:24 -07006351 clientCompositionDisplay.clip = sourceCrop;
Alec Mouri5a6d8572020-03-23 23:56:15 -07006352 clientCompositionDisplay.orientation = rotation;
Alec Mouriadb75f42019-03-28 21:42:24 -07006353
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006354 clientCompositionDisplay.outputDataspace = renderArea.getReqDataSpace();
6355 clientCompositionDisplay.maxLuminance = DisplayDevice::sDefaultMaxLumiance;
Mathias Agopian180f10d2013-04-10 22:55:41 -07006356
chaviw17ac24b2021-01-28 18:50:05 -08006357 const float colorSaturation = grayscale ? 0 : 1;
6358 clientCompositionDisplay.colorTransform = calculateColorMatrix(colorSaturation);
6359
chaviw50da5042018-04-09 13:49:37 -07006360 const float alpha = RenderArea::getCaptureFillValue(renderArea.getCaptureFill());
Mathias Agopian180f10d2013-04-10 22:55:41 -07006361
Vishnu Nair9b079a22020-01-21 14:36:08 -08006362 compositionengine::LayerFE::LayerSettings fillLayer;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006363 fillLayer.source.buffer.buffer = nullptr;
6364 fillLayer.source.solidColor = half3(0.0, 0.0, 0.0);
Alec Mouri5a6d8572020-03-23 23:56:15 -07006365 fillLayer.geometry.boundaries =
6366 FloatRect(sourceCrop.left, sourceCrop.top, sourceCrop.right, sourceCrop.bottom);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006367 fillLayer.alpha = half(alpha);
6368 clientCompositionLayers.push_back(fillLayer);
6369
Dominik Laskowskib7251f42020-04-20 17:42:59 -07006370 const auto display = renderArea.getDisplayDevice();
Yichi Chen40773d92020-04-01 10:10:18 +08006371 std::vector<Layer*> renderedLayers;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006372 Region clearRegion = Region::INVALID_REGION;
Galia Peycheva66eaf4a2020-11-09 13:17:57 +01006373 bool disableBlurs = false;
chaviwa76b2712017-09-20 12:02:26 -07006374 traverseLayers([&](Layer* layer) {
Robert Carr6a160312021-05-17 12:08:20 -07006375 disableBlurs |= layer->getDrawingState().sidebandStream != nullptr;
Galia Peycheva66eaf4a2020-11-09 13:17:57 +01006376
Lloyd Piquef16688f2019-02-19 17:47:57 -08006377 Region clip(renderArea.getBounds());
6378 compositionengine::LayerFE::ClientCompositionTargetSettings targetSettings{
6379 clip,
Dominik Laskowskib7251f42020-04-20 17:42:59 -07006380 layer->needsFilteringForScreenshots(display.get(), transform) ||
Alec Mouri5a6d8572020-03-23 23:56:15 -07006381 renderArea.needsFiltering(),
Lloyd Piquef16688f2019-02-19 17:47:57 -08006382 renderArea.isSecure(),
Peiyong Lin05cc0112020-10-14 16:16:37 -07006383 useProtected,
Lloyd Piquef16688f2019-02-19 17:47:57 -08006384 clearRegion,
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02006385 layerStackSpaceRect,
Vishnu Nairb87d94f2020-02-13 09:17:36 -08006386 clientCompositionDisplay.outputDataspace,
Alec Mourif54453c2021-05-13 16:28:28 -07006387 true, /* realContentIsVisible */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08006388 false, /* clearContent */
Alec Mourif54453c2021-05-13 16:28:28 -07006389 disableBlurs ? compositionengine::LayerFE::ClientCompositionTargetSettings::
6390 BlurSetting::Disabled
6391 : compositionengine::LayerFE::ClientCompositionTargetSettings::
6392 BlurSetting::Enabled,
Lloyd Piquef16688f2019-02-19 17:47:57 -08006393 };
Vishnu Nairb87d94f2020-02-13 09:17:36 -08006394 std::vector<compositionengine::LayerFE::LayerSettings> results =
6395 layer->prepareClientCompositionList(targetSettings);
Yichi Chen40773d92020-04-01 10:10:18 +08006396 if (results.size() > 0) {
Alec Mouri5a6d8572020-03-23 23:56:15 -07006397 for (auto& settings : results) {
6398 settings.geometry.positionTransform =
6399 transform.asMatrix4() * settings.geometry.positionTransform;
Lucas Dupin9d763b72020-04-20 18:42:31 -07006400 // There's no need to process blurs when we're executing region sampling,
6401 // we're just trying to understand what we're drawing, and doing so without
6402 // blurs is already a pretty good approximation.
6403 if (regionSampling) {
6404 settings.backgroundBlurRadius = 0;
6405 }
Alec Mouri5a6d8572020-03-23 23:56:15 -07006406 }
Galia Peycheva66eaf4a2020-11-09 13:17:57 +01006407
Yichi Chen40773d92020-04-01 10:10:18 +08006408 clientCompositionLayers.insert(clientCompositionLayers.end(),
6409 std::make_move_iterator(results.begin()),
6410 std::make_move_iterator(results.end()));
6411 renderedLayers.push_back(layer);
6412 }
Galia Peycheva66eaf4a2020-11-09 13:17:57 +01006413
chaviwa76b2712017-09-20 12:02:26 -07006414 });
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006415
Yichi Chen40773d92020-04-01 10:10:18 +08006416 std::vector<const renderengine::LayerSettings*> clientCompositionLayerPointers(
6417 clientCompositionLayers.size());
Vishnu Nair9b079a22020-01-21 14:36:08 -08006418 std::transform(clientCompositionLayers.begin(), clientCompositionLayers.end(),
Yichi Chen40773d92020-04-01 10:10:18 +08006419 clientCompositionLayerPointers.begin(),
6420 std::pointer_traits<renderengine::LayerSettings*>::pointer_to);
Vishnu Nair9b079a22020-01-21 14:36:08 -08006421
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006422 clientCompositionDisplay.clearRegion = clearRegion;
Alec Mouri6338c9d2019-02-07 16:57:51 -08006423 // Use an empty fence for the buffer fence, since we just created the buffer so
6424 // there is no need for synchronization with the GPU.
6425 base::unique_fd bufferFence;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006426 base::unique_fd drawFence;
Peiyong Lin05cc0112020-10-14 16:16:37 -07006427 getRenderEngine().useProtectedContext(useProtected);
Alec Mouri0d995102021-02-24 16:53:38 -08006428
Alec Mouria90a5702021-04-16 16:36:21 +00006429 const constexpr bool kUseFramebufferCache = false;
Vishnu Nair9b079a22020-01-21 14:36:08 -08006430 getRenderEngine().drawLayers(clientCompositionDisplay, clientCompositionLayerPointers, buffer,
Alec Mouria90a5702021-04-16 16:36:21 +00006431 kUseFramebufferCache, std::move(bufferFence), &drawFence);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006432
Ady Abraham99599942021-01-27 20:27:23 -08006433 if (drawFence >= 0) {
6434 sp<Fence> releaseFence = new Fence(dup(drawFence));
Yichi Chen40773d92020-04-01 10:10:18 +08006435 for (auto* layer : renderedLayers) {
6436 layer->onLayerDisplayed(releaseFence);
6437 }
6438 }
Ady Abraham99599942021-01-27 20:27:23 -08006439
6440 captureResults.fence = new Fence(drawFence.release());
Peiyong Lin05cc0112020-10-14 16:16:37 -07006441 // Always switch back to unprotected context.
6442 getRenderEngine().useProtectedContext(false);
Mathias Agopian180f10d2013-04-10 22:55:41 -07006443
Dan Stoza2b6d38e2017-06-01 16:40:30 -07006444 return NO_ERROR;
Mathias Agopian74c40c02010-09-29 13:02:36 -07006445}
6446
chaviw95ef3c42019-02-14 10:55:09 -08006447void SurfaceFlinger::setInputWindowsFinished() {
6448 Mutex::Autolock _l(mStateLock);
Arthur Hung2274a312021-04-28 15:13:06 +00006449 signalSynchronousTransactions(CountDownLatch::eSyncInputWindows);
chaviw95ef3c42019-02-14 10:55:09 -08006450}
chaviw5f21a5e2019-02-14 10:00:34 -08006451
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07006452// ---------------------------------------------------------------------------
6453
Edgar Arriaga844fa672020-01-16 14:21:42 -08006454void SurfaceFlinger::State::traverse(const LayerVector::Visitor& visitor) const {
6455 layersSortedByZ.traverse(visitor);
6456}
6457
Dan Stoza412903f2017-04-27 13:42:17 -07006458void SurfaceFlinger::State::traverseInZOrder(const LayerVector::Visitor& visitor) const {
6459 layersSortedByZ.traverseInZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07006460}
6461
Dan Stoza412903f2017-04-27 13:42:17 -07006462void SurfaceFlinger::State::traverseInReverseZOrder(const LayerVector::Visitor& visitor) const {
6463 layersSortedByZ.traverseInReverseZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07006464}
6465
chaviw4b9d5e12020-08-04 18:30:35 -07006466void SurfaceFlinger::traverseLayersInLayerStack(ui::LayerStack layerStack, const int32_t uid,
Marin Shalamanov1c434292020-06-12 01:47:29 +02006467 const LayerVector::Visitor& visitor) {
chaviwa76b2712017-09-20 12:02:26 -07006468 // We loop through the first level of layers without traversing,
chaviw0e3479f2018-09-10 16:49:30 -07006469 // as we need to determine which layers belong to the requested display.
chaviwa76b2712017-09-20 12:02:26 -07006470 for (const auto& layer : mDrawingState.layersSortedByZ) {
chaviw4b9d5e12020-08-04 18:30:35 -07006471 if (!layer->belongsToDisplay(layerStack)) {
chaviwa76b2712017-09-20 12:02:26 -07006472 continue;
6473 }
Chia-I Wuec2d9852017-11-21 09:21:01 -08006474 // relative layers are traversed in Layer::traverseInZOrder
chaviwa76b2712017-09-20 12:02:26 -07006475 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
chaviw4b9d5e12020-08-04 18:30:35 -07006476 if (layer->getPrimaryDisplayOnly()) {
Adrian Roos8acf5a02018-01-17 21:28:19 +01006477 return;
6478 }
chaviwa76b2712017-09-20 12:02:26 -07006479 if (!layer->isVisible()) {
6480 return;
6481 }
chaviw4b9d5e12020-08-04 18:30:35 -07006482 if (uid != CaptureArgs::UNSET_UID && layer->getOwnerUid() != uid) {
6483 return;
6484 }
chaviwa76b2712017-09-20 12:02:26 -07006485 visitor(layer);
6486 });
6487 }
6488}
6489
Marin Shalamanova7fe3042021-01-29 21:02:08 +01006490status_t SurfaceFlinger::setDesiredDisplayModeSpecsInternal(
Steven Thomasd4071902020-03-24 16:02:53 -07006491 const sp<DisplayDevice>& display,
6492 const std::optional<scheduler::RefreshRateConfigs::Policy>& policy, bool overridePolicy) {
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006493 Mutex::Autolock lock(mStateLock);
6494
Ady Abrahamfb853662021-04-09 11:46:40 -07006495 if (mDebugDisplayModeSetByBackdoor) {
6496 // ignore this request as mode is overridden by backdoor
6497 return NO_ERROR;
6498 }
6499
Ady Abraham3efa3942021-06-24 19:01:25 -07006500 status_t setPolicyResult = overridePolicy
6501 ? display->refreshRateConfigs().setOverridePolicy(policy)
6502 : display->refreshRateConfigs().setDisplayManagerPolicy(*policy);
6503 if (setPolicyResult < 0) {
6504 return BAD_VALUE;
6505 }
6506 if (setPolicyResult == scheduler::RefreshRateConfigs::CURRENT_POLICY_UNCHANGED) {
6507 return NO_ERROR;
6508 }
6509
Ady Abraham3efa3942021-06-24 19:01:25 -07006510 scheduler::RefreshRateConfigs::Policy currentPolicy =
6511 display->refreshRateConfigs().getCurrentPolicy();
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006512
Marin Shalamanova7fe3042021-01-29 21:02:08 +01006513 ALOGV("Setting desired display mode specs: %s", currentPolicy.toString().c_str());
Adrian Salidoab6ef6c2019-08-28 10:02:49 -07006514
Ana Krulecb9afd792020-06-11 13:16:15 -07006515 // TODO(b/140204874): Leave the event in until we do proper testing with all apps that might
6516 // be depending in this callback.
Marin Shalamanova7fe3042021-01-29 21:02:08 +01006517 const auto activeMode = display->getActiveMode();
Ady Abrahamb4937392021-06-23 18:05:03 -07006518 if (isDisplayActiveLocked(display)) {
6519 mScheduler->onPrimaryDisplayModeChanged(mAppConnectionHandle, activeMode);
6520 toggleKernelIdleTimer();
6521 } else {
6522 mScheduler->onNonPrimaryDisplayModeChanged(mAppConnectionHandle, activeMode);
6523 }
Ady Abraham838de062019-02-04 10:24:03 -08006524
Ady Abrahamb4937392021-06-23 18:05:03 -07006525 const DisplayModePtr preferredDisplayMode = [&] {
6526 const auto schedulerMode = mScheduler->getPreferredDisplayMode();
6527 if (schedulerMode && schedulerMode->getPhysicalDisplayId() == display->getPhysicalId()) {
6528 return schedulerMode;
6529 }
6530
6531 return display->getMode(currentPolicy.defaultMode);
6532 }();
6533
Marin Shalamanov228f46b2021-01-28 21:11:45 +01006534 ALOGV("trying to switch to Scheduler preferred mode %d (%s)",
Ady Abrahamb4937392021-06-23 18:05:03 -07006535 preferredDisplayMode->getId().value(), to_string(preferredDisplayMode->getFps()).c_str());
Ana Krulec3f6a2062020-01-23 15:48:01 -08006536
Ady Abrahamb4937392021-06-23 18:05:03 -07006537 if (display->refreshRateConfigs().isModeAllowed(preferredDisplayMode->getId())) {
Marin Shalamanov228f46b2021-01-28 21:11:45 +01006538 ALOGV("switching to Scheduler preferred display mode %d",
Ady Abrahamb4937392021-06-23 18:05:03 -07006539 preferredDisplayMode->getId().value());
6540 setDesiredActiveMode({preferredDisplayMode, Scheduler::ModeEvent::Changed});
Ady Abraham2139f732019-11-13 18:56:40 -08006541 } else {
Marin Shalamanov228f46b2021-01-28 21:11:45 +01006542 LOG_ALWAYS_FATAL("Desired display mode not allowed: %d",
Ady Abrahamb4937392021-06-23 18:05:03 -07006543 preferredDisplayMode->getId().value());
Dominik Laskowski4f1dd8c2019-04-17 15:54:30 -07006544 }
6545
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08006546 return NO_ERROR;
6547}
6548
Marin Shalamanov228f46b2021-01-28 21:11:45 +01006549status_t SurfaceFlinger::setDesiredDisplayModeSpecs(
6550 const sp<IBinder>& displayToken, ui::DisplayModeId defaultMode, bool allowGroupSwitching,
6551 float primaryRefreshRateMin, float primaryRefreshRateMax, float appRequestRefreshRateMin,
6552 float appRequestRefreshRateMax) {
Ana Krulec0782b882019-10-15 17:34:54 -07006553 ATRACE_CALL();
6554
6555 if (!displayToken) {
6556 return BAD_VALUE;
6557 }
6558
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006559 auto future = schedule([=]() -> status_t {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07006560 const auto display = ON_MAIN_THREAD(getDisplayDeviceLocked(displayToken));
Ana Krulec234bb162019-11-10 22:55:55 +01006561 if (!display) {
Marin Shalamanova7fe3042021-01-29 21:02:08 +01006562 ALOGE("Attempt to set desired display modes for invalid display token %p",
Ana Krulec234bb162019-11-10 22:55:55 +01006563 displayToken.get());
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006564 return NAME_NOT_FOUND;
Ana Krulec234bb162019-11-10 22:55:55 +01006565 } else if (display->isVirtual()) {
Marin Shalamanova7fe3042021-01-29 21:02:08 +01006566 ALOGW("Attempt to set desired display modes for virtual display");
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006567 return INVALID_OPERATION;
Ana Krulec234bb162019-11-10 22:55:55 +01006568 } else {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006569 using Policy = scheduler::RefreshRateConfigs::Policy;
Marin Shalamanova7fe3042021-01-29 21:02:08 +01006570 const Policy policy{DisplayModeId(defaultMode),
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +02006571 allowGroupSwitching,
Marin Shalamanove8a663d2020-11-24 17:48:00 +01006572 {Fps(primaryRefreshRateMin), Fps(primaryRefreshRateMax)},
6573 {Fps(appRequestRefreshRateMin), Fps(appRequestRefreshRateMax)}};
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006574 constexpr bool kOverridePolicy = false;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006575
Marin Shalamanova7fe3042021-01-29 21:02:08 +01006576 return setDesiredDisplayModeSpecsInternal(display, policy, kOverridePolicy);
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006577 }
6578 });
6579
6580 return future.get();
Ana Krulec234bb162019-11-10 22:55:55 +01006581}
6582
Marin Shalamanov228f46b2021-01-28 21:11:45 +01006583status_t SurfaceFlinger::getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
6584 ui::DisplayModeId* outDefaultMode,
6585 bool* outAllowGroupSwitching,
6586 float* outPrimaryRefreshRateMin,
6587 float* outPrimaryRefreshRateMax,
6588 float* outAppRequestRefreshRateMin,
6589 float* outAppRequestRefreshRateMax) {
Ana Krulec234bb162019-11-10 22:55:55 +01006590 ATRACE_CALL();
6591
Marin Shalamanova7fe3042021-01-29 21:02:08 +01006592 if (!displayToken || !outDefaultMode || !outPrimaryRefreshRateMin ||
Steven Thomasf734df42020-04-13 21:09:28 -07006593 !outPrimaryRefreshRateMax || !outAppRequestRefreshRateMin || !outAppRequestRefreshRateMax) {
Ana Krulec234bb162019-11-10 22:55:55 +01006594 return BAD_VALUE;
6595 }
6596
6597 Mutex::Autolock lock(mStateLock);
6598 const auto display = getDisplayDeviceLocked(displayToken);
6599 if (!display) {
6600 return NAME_NOT_FOUND;
6601 }
6602
Ady Abraham3efa3942021-06-24 19:01:25 -07006603 if (display->isVirtual()) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07006604 return INVALID_OPERATION;
Ana Krulec234bb162019-11-10 22:55:55 +01006605 }
Ady Abraham3efa3942021-06-24 19:01:25 -07006606
6607 scheduler::RefreshRateConfigs::Policy policy =
6608 display->refreshRateConfigs().getDisplayManagerPolicy();
6609 *outDefaultMode = policy.defaultMode.value();
6610 *outAllowGroupSwitching = policy.allowGroupSwitching;
6611 *outPrimaryRefreshRateMin = policy.primaryRange.min.getValue();
6612 *outPrimaryRefreshRateMax = policy.primaryRange.max.getValue();
6613 *outAppRequestRefreshRateMin = policy.appRequestRange.min.getValue();
6614 *outAppRequestRefreshRateMax = policy.appRequestRange.max.getValue();
6615 return NO_ERROR;
Ana Krulec0782b882019-10-15 17:34:54 -07006616}
6617
Alec Mouri9a02eda2020-04-21 17:39:34 -07006618wp<Layer> SurfaceFlinger::fromHandle(const sp<IBinder>& handle) {
6619 Mutex::Autolock _l(mStateLock);
6620 return fromHandleLocked(handle);
6621}
6622
Vishnu Nair83df0342021-03-30 11:50:44 -07006623wp<Layer> SurfaceFlinger::fromHandleLocked(const sp<IBinder>& handle) const {
Valerie Hau09e60052019-12-15 14:51:15 -08006624 BBinder* b = nullptr;
6625 if (handle) {
6626 b = handle->localBinder();
6627 }
Robert Carrc0df3122019-04-11 13:18:21 -07006628 if (b == nullptr) {
6629 return nullptr;
6630 }
6631 auto it = mLayersByLocalBinderToken.find(b);
6632 if (it != mLayersByLocalBinderToken.end()) {
Alec Mouri9a02eda2020-04-21 17:39:34 -07006633 return it->second;
Robert Carrc0df3122019-04-11 13:18:21 -07006634 }
6635 return nullptr;
6636}
6637
Dominik Laskowski75848362019-11-11 17:57:20 -08006638void SurfaceFlinger::onLayerFirstRef(Layer* layer) {
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -07006639 mNumLayers++;
Ady Abrahambe09aad2021-05-03 18:59:38 -07006640 if (!layer->isRemovedFromCurrentState()) {
6641 mScheduler->registerLayer(layer);
6642 }
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -07006643}
6644
6645void SurfaceFlinger::onLayerDestroyed(Layer* layer) {
6646 mNumLayers--;
Robert Carr867be372021-06-29 17:36:02 -07006647 removeHierarchyFromOffscreenLayers(layer);
Ady Abrahambe09aad2021-05-03 18:59:38 -07006648 if (!layer->isRemovedFromCurrentState()) {
6649 mScheduler->deregisterLayer(layer);
6650 }
Valerie Hauc5686802019-11-22 14:18:09 -08006651}
6652
6653// WARNING: ONLY CALL THIS FROM LAYER DTOR
6654// Here we add children in the current state to offscreen layers and remove the
6655// layer itself from the offscreen layer list. Since
6656// this is the dtor, it is safe to access the current state. This keeps us
6657// from dangling children layers such that they are not reachable from the
6658// Drawing state nor the offscreen layer list
6659// See b/141111965
Robert Carr867be372021-06-29 17:36:02 -07006660void SurfaceFlinger::removeHierarchyFromOffscreenLayers(Layer* layer) {
Valerie Hauc5686802019-11-22 14:18:09 -08006661 for (auto& child : layer->getCurrentChildren()) {
6662 mOffscreenLayers.emplace(child.get());
6663 }
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -07006664 mOffscreenLayers.erase(layer);
6665}
6666
Robert Carr867be372021-06-29 17:36:02 -07006667void SurfaceFlinger::removeFromOffscreenLayers(Layer* layer) {
6668 mOffscreenLayers.erase(layer);
6669}
6670
Vishnu Nair08f6eae2019-11-26 14:01:39 -08006671status_t SurfaceFlinger::setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
6672 float lightPosY, float lightPosZ,
6673 float lightRadius) {
6674 Mutex::Autolock _l(mStateLock);
6675 mCurrentState.globalShadowSettings.ambientColor = vec4(ambientColor);
6676 mCurrentState.globalShadowSettings.spotColor = vec4(spotColor);
6677 mCurrentState.globalShadowSettings.lightPos.y = lightPosY;
6678 mCurrentState.globalShadowSettings.lightPos.z = lightPosZ;
6679 mCurrentState.globalShadowSettings.lightRadius = lightRadius;
6680
6681 // these values are overridden when calculating the shadow settings for a layer.
6682 mCurrentState.globalShadowSettings.lightPos.x = 0.f;
6683 mCurrentState.globalShadowSettings.length = 0.f;
Vishnu Nairb13bb952019-11-15 10:24:08 -08006684 return NO_ERROR;
6685}
6686
Lloyd Pique8d9f8362020-02-11 19:13:09 -08006687const std::unordered_map<std::string, uint32_t>& SurfaceFlinger::getGenericLayerMetadataKeyMap()
6688 const {
6689 // TODO(b/149500060): Remove this fixed/static mapping. Please prefer taking
6690 // on the work to remove the table in that bug rather than adding more to
6691 // it.
6692 static const std::unordered_map<std::string, uint32_t> genericLayerMetadataKeyMap{
Lloyd Pique8d9f8362020-02-11 19:13:09 -08006693 {"org.chromium.arc.V1_0.TaskId", METADATA_TASK_ID},
6694 {"org.chromium.arc.V1_0.CursorInfo", METADATA_MOUSE_CURSOR},
6695 };
6696 return genericLayerMetadataKeyMap;
6697}
6698
Steven Thomas62a4cf82020-01-31 12:04:03 -08006699status_t SurfaceFlinger::setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,
Marin Shalamanovc5986772021-03-16 16:09:49 +01006700 int8_t compatibility, int8_t changeFrameRateStrategy) {
6701 if (!ValidateFrameRate(frameRate, compatibility, changeFrameRateStrategy,
6702 "SurfaceFlinger::setFrameRate")) {
Steven Thomas62a4cf82020-01-31 12:04:03 -08006703 return BAD_VALUE;
6704 }
6705
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07006706 static_cast<void>(schedule([=] {
Ady Abraham60e42ea2020-03-09 19:17:31 -07006707 Mutex::Autolock lock(mStateLock);
6708 if (authenticateSurfaceTextureLocked(surface)) {
6709 sp<Layer> layer = (static_cast<MonitoredProducer*>(surface.get()))->getLayer();
Ady Abraham162f6432020-10-08 18:40:47 +00006710 if (layer == nullptr) {
6711 ALOGE("Attempt to set frame rate on a layer that no longer exists");
6712 return BAD_VALUE;
6713 }
Marin Shalamanovc5986772021-03-16 16:09:49 +01006714 const auto strategy =
6715 Layer::FrameRate::convertChangeFrameRateStrategy(changeFrameRateStrategy);
Ady Abraham60e42ea2020-03-09 19:17:31 -07006716 if (layer->setFrameRate(
Marin Shalamanove8a663d2020-11-24 17:48:00 +01006717 Layer::FrameRate(Fps{frameRate},
Marin Shalamanov46084422020-10-13 12:33:42 +02006718 Layer::FrameRate::convertCompatibility(compatibility),
Marin Shalamanovc5986772021-03-16 16:09:49 +01006719 strategy))) {
Ady Abraham60e42ea2020-03-09 19:17:31 -07006720 setTransactionFlags(eTraversalNeeded);
6721 }
6722 } else {
6723 ALOGE("Attempt to set frame rate on an unrecognized IGraphicBufferProducer");
6724 return BAD_VALUE;
Steven Thomas62a4cf82020-01-31 12:04:03 -08006725 }
Ady Abraham60e42ea2020-03-09 19:17:31 -07006726 return NO_ERROR;
6727 }));
6728
Steven Thomas62a4cf82020-01-31 12:04:03 -08006729 return NO_ERROR;
6730}
6731
Steven Thomasd4071902020-03-24 16:02:53 -07006732status_t SurfaceFlinger::acquireFrameRateFlexibilityToken(sp<IBinder>* outToken) {
6733 if (!outToken) {
6734 return BAD_VALUE;
6735 }
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006736
6737 auto future = schedule([this] {
6738 status_t result = NO_ERROR;
6739 sp<IBinder> token;
6740
Steven Thomasd4071902020-03-24 16:02:53 -07006741 if (mFrameRateFlexibilityTokenCount == 0) {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07006742 const auto display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked());
Steven Thomasd4071902020-03-24 16:02:53 -07006743
6744 // This is a little racy, but not in a way that hurts anything. As we grab the
Marin Shalamanova7fe3042021-01-29 21:02:08 +01006745 // defaultMode from the display manager policy, we could be setting a new display
6746 // manager policy, leaving us using a stale defaultMode. The defaultMode doesn't
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +02006747 // matter for the override policy though, since we set allowGroupSwitching to
6748 // true, so it's not a problem.
Steven Thomasd4071902020-03-24 16:02:53 -07006749 scheduler::RefreshRateConfigs::Policy overridePolicy;
Ady Abraham3efa3942021-06-24 19:01:25 -07006750 overridePolicy.defaultMode =
6751 display->refreshRateConfigs().getDisplayManagerPolicy().defaultMode;
Steven Thomasd4071902020-03-24 16:02:53 -07006752 overridePolicy.allowGroupSwitching = true;
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006753 constexpr bool kOverridePolicy = true;
Marin Shalamanova7fe3042021-01-29 21:02:08 +01006754 result = setDesiredDisplayModeSpecsInternal(display, overridePolicy, kOverridePolicy);
Steven Thomasd4071902020-03-24 16:02:53 -07006755 }
6756
6757 if (result == NO_ERROR) {
6758 mFrameRateFlexibilityTokenCount++;
6759 // Handing out a reference to the SurfaceFlinger object, as we're doing in the line
6760 // below, is something to consider carefully. The lifetime of the
6761 // FrameRateFlexibilityToken isn't tied to SurfaceFlinger object lifetime, so if this
6762 // SurfaceFlinger object were to be destroyed while the token still exists, the token
6763 // destructor would be accessing a stale SurfaceFlinger reference, and crash. This is ok
6764 // in this case, for two reasons:
6765 // 1. Once SurfaceFlinger::run() is called by main_surfaceflinger.cpp, the only way
6766 // the program exits is via a crash. So we won't have a situation where the
6767 // SurfaceFlinger object is dead but the process is still up.
6768 // 2. The frame rate flexibility token is acquired/released only by CTS tests, so even
6769 // if condition 1 were changed, the problem would only show up when running CTS tests,
6770 // not on end user devices, so we could spot it and fix it without serious impact.
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006771 token = new FrameRateFlexibilityToken(
Steven Thomasd4071902020-03-24 16:02:53 -07006772 [this]() { onFrameRateFlexibilityTokenReleased(); });
6773 ALOGD("Frame rate flexibility token acquired. count=%d",
6774 mFrameRateFlexibilityTokenCount);
6775 }
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006776
6777 return std::make_pair(result, token);
6778 });
6779
6780 status_t result;
6781 std::tie(result, *outToken) = future.get();
Steven Thomasd4071902020-03-24 16:02:53 -07006782 return result;
6783}
6784
6785void SurfaceFlinger::onFrameRateFlexibilityTokenReleased() {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006786 static_cast<void>(schedule([this] {
Steven Thomasd4071902020-03-24 16:02:53 -07006787 LOG_ALWAYS_FATAL_IF(mFrameRateFlexibilityTokenCount == 0,
6788 "Failed tracking frame rate flexibility tokens");
6789 mFrameRateFlexibilityTokenCount--;
6790 ALOGD("Frame rate flexibility token released. count=%d", mFrameRateFlexibilityTokenCount);
6791 if (mFrameRateFlexibilityTokenCount == 0) {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07006792 const auto display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked());
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006793 constexpr bool kOverridePolicy = true;
Marin Shalamanova7fe3042021-01-29 21:02:08 +01006794 status_t result = setDesiredDisplayModeSpecsInternal(display, {}, kOverridePolicy);
Steven Thomasd4071902020-03-24 16:02:53 -07006795 LOG_ALWAYS_FATAL_IF(result < 0, "Failed releasing frame rate flexibility token");
6796 }
6797 }));
6798}
6799
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10006800status_t SurfaceFlinger::setFrameTimelineInfo(const sp<IGraphicBufferProducer>& surface,
6801 const FrameTimelineInfo& frameTimelineInfo) {
Ady Abraham74e17562020-08-24 18:18:19 -07006802 Mutex::Autolock lock(mStateLock);
6803 if (!authenticateSurfaceTextureLocked(surface)) {
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10006804 ALOGE("Attempt to set frame timeline info on an unrecognized IGraphicBufferProducer");
Ady Abraham74e17562020-08-24 18:18:19 -07006805 return BAD_VALUE;
6806 }
6807
6808 sp<Layer> layer = (static_cast<MonitoredProducer*>(surface.get()))->getLayer();
Ady Abrahamfdf1bff2020-09-28 11:27:30 -07006809 if (layer == nullptr) {
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10006810 ALOGE("Attempt to set frame timeline info on a layer that no longer exists");
Ady Abrahamfdf1bff2020-09-28 11:27:30 -07006811 return BAD_VALUE;
6812 }
6813
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10006814 layer->setFrameTimelineInfoForBuffer(frameTimelineInfo);
Ady Abraham74e17562020-08-24 18:18:19 -07006815 return NO_ERROR;
6816}
6817
Dominik Laskowski20134642020-04-20 22:36:44 -07006818void SurfaceFlinger::enableRefreshRateOverlay(bool enable) {
Ady Abraham1b11bc62021-06-03 19:51:19 -07006819 for (const auto& [ignored, display] : mDisplays) {
6820 if (display->isInternal()) {
6821 display->enableRefreshRateOverlay(enable, mRefreshRateOverlaySpinner);
Dominik Laskowski20134642020-04-20 22:36:44 -07006822 }
Ady Abraham1b11bc62021-06-03 19:51:19 -07006823 }
Dominik Laskowski20134642020-04-20 22:36:44 -07006824}
6825
Pablo Gamito6ee484d2020-07-30 14:26:28 +00006826status_t SurfaceFlinger::addTransactionTraceListener(
6827 const sp<gui::ITransactionTraceListener>& listener) {
6828 if (!listener) {
6829 return BAD_VALUE;
6830 }
6831
6832 mInterceptor->addTransactionTraceListener(listener);
6833
6834 return NO_ERROR;
6835}
6836
Ana Krulec31f2b3c2020-12-14 14:30:09 -08006837int SurfaceFlinger::getGPUContextPriority() {
Alec Mourid6f09462020-12-07 11:18:17 -08006838 return getRenderEngine().getContextPriority();
Ana Krulec31f2b3c2020-12-14 14:30:09 -08006839}
6840
Ady Abraham899dcdb2021-06-15 16:56:21 -07006841int SurfaceFlinger::calculateMaxAcquiredBufferCount(Fps refreshRate,
6842 std::chrono::nanoseconds presentLatency) {
6843 auto pipelineDepth = presentLatency.count() / refreshRate.getPeriodNsecs();
6844 if (presentLatency.count() % refreshRate.getPeriodNsecs()) {
Ady Abraham564f9de2021-02-03 18:34:33 -08006845 pipelineDepth++;
6846 }
Ady Abraham899dcdb2021-06-15 16:56:21 -07006847 return std::max(1ll, pipelineDepth - 1);
Ady Abraham564f9de2021-02-03 18:34:33 -08006848}
6849
Ady Abraham899dcdb2021-06-15 16:56:21 -07006850status_t SurfaceFlinger::getMaxAcquiredBufferCount(int* buffers) const {
Ady Abraham3efa3942021-06-24 19:01:25 -07006851 const auto maxSupportedRefreshRate = [&] {
6852 const auto display = getDefaultDisplayDevice();
6853 if (display) {
6854 return display->refreshRateConfigs().getSupportedRefreshRateRange().max;
6855 }
6856 ALOGW("%s: default display is null", __func__);
6857 return Fps(60);
6858 }();
Ady Abraham899dcdb2021-06-15 16:56:21 -07006859 *buffers = getMaxAcquiredBufferCountForRefreshRate(maxSupportedRefreshRate);
Ady Abraham564f9de2021-02-03 18:34:33 -08006860 return NO_ERROR;
6861}
6862
Ady Abraham899dcdb2021-06-15 16:56:21 -07006863int SurfaceFlinger::getMaxAcquiredBufferCountForCurrentRefreshRate(uid_t uid) const {
6864 const auto refreshRate = [&] {
6865 const auto frameRateOverride = mScheduler->getFrameRateOverride(uid);
6866 if (frameRateOverride.has_value()) {
6867 return frameRateOverride.value();
6868 }
Ady Abraham3efa3942021-06-24 19:01:25 -07006869
6870 const auto display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked());
6871 if (display) {
6872 return display->refreshRateConfigs().getCurrentRefreshRate().getFps();
6873 }
6874
6875 ALOGW("%s: default display is null", __func__);
6876 return Fps(60);
Ady Abraham899dcdb2021-06-15 16:56:21 -07006877 }();
6878 return getMaxAcquiredBufferCountForRefreshRate(refreshRate);
6879}
6880
6881int SurfaceFlinger::getMaxAcquiredBufferCountForRefreshRate(Fps refreshRate) const {
6882 const auto vsyncConfig = mVsyncConfiguration->getConfigsForRefreshRate(refreshRate).late;
6883 const auto presentLatency = vsyncConfig.appWorkDuration + vsyncConfig.sfWorkDuration;
6884 return calculateMaxAcquiredBufferCount(refreshRate, presentLatency);
6885}
6886
Vishnu Nair83df0342021-03-30 11:50:44 -07006887void SurfaceFlinger::TransactionState::traverseStatesWithBuffers(
6888 std::function<void(const layer_state_t&)> visitor) {
6889 for (const auto& state : states) {
Ady Abraham6e8e3642021-07-08 19:44:07 -07006890 if (state.state.hasBufferChanges() && state.state.hasValidBuffer() && state.state.surface) {
Vishnu Nair83df0342021-03-30 11:50:44 -07006891 visitor(state.state);
6892 }
6893 }
6894}
6895
arthurhungdba591c2021-02-08 17:28:49 +08006896void SurfaceFlinger::setLayerCreatedState(const sp<IBinder>& handle, const wp<Layer>& layer,
6897 const wp<IBinder>& parent, const wp<Layer> parentLayer,
chaviwe0c7b822021-07-20 10:16:05 -05006898 const wp<IBinder>& producer, bool addToRoot) {
arthurhungdba591c2021-02-08 17:28:49 +08006899 Mutex::Autolock lock(mCreatedLayersLock);
6900 mCreatedLayers[handle->localBinder()] =
chaviwe0c7b822021-07-20 10:16:05 -05006901 std::make_unique<LayerCreatedState>(layer, parent, parentLayer, producer, addToRoot);
arthurhungdba591c2021-02-08 17:28:49 +08006902}
6903
6904auto SurfaceFlinger::getLayerCreatedState(const sp<IBinder>& handle) {
6905 Mutex::Autolock lock(mCreatedLayersLock);
6906 BBinder* b = nullptr;
6907 if (handle) {
6908 b = handle->localBinder();
6909 }
6910
6911 if (b == nullptr) {
6912 return std::unique_ptr<LayerCreatedState>(nullptr);
6913 }
6914
6915 auto it = mCreatedLayers.find(b);
6916 if (it == mCreatedLayers.end()) {
6917 ALOGE("Can't find layer from handle %p", handle.get());
6918 return std::unique_ptr<LayerCreatedState>(nullptr);
6919 }
6920
6921 auto state = std::move(it->second);
6922 mCreatedLayers.erase(it);
6923 return state;
6924}
6925
chaviwe0c7b822021-07-20 10:16:05 -05006926sp<Layer> SurfaceFlinger::handleLayerCreatedLocked(const sp<IBinder>& handle) {
arthurhungdba591c2021-02-08 17:28:49 +08006927 const auto& state = getLayerCreatedState(handle);
6928 if (!state) {
6929 return nullptr;
6930 }
6931
6932 sp<Layer> layer = state->layer.promote();
6933 if (!layer) {
6934 ALOGE("Invalid layer %p", state->layer.unsafe_get());
6935 return nullptr;
6936 }
6937
6938 sp<Layer> parent;
chaviwe0c7b822021-07-20 10:16:05 -05006939 bool allowAddRoot = state->addToRoot;
arthurhungdba591c2021-02-08 17:28:49 +08006940 if (state->initialParent != nullptr) {
6941 parent = fromHandleLocked(state->initialParent.promote()).promote();
6942 if (parent == nullptr) {
6943 ALOGE("Invalid parent %p", state->initialParent.unsafe_get());
6944 allowAddRoot = false;
6945 }
6946 } else if (state->initialParentLayer != nullptr) {
6947 parent = state->initialParentLayer.promote();
6948 allowAddRoot = false;
6949 }
6950
6951 if (parent == nullptr && allowAddRoot) {
Vishnu Nair14d218b2021-07-13 13:57:39 -07006952 layer->setIsAtRoot(true);
arthurhungdba591c2021-02-08 17:28:49 +08006953 mCurrentState.layersSortedByZ.add(layer);
6954 } else if (parent == nullptr) {
6955 layer->onRemovedFromCurrentState();
6956 } else if (parent->isRemovedFromCurrentState()) {
6957 parent->addChild(layer);
6958 layer->onRemovedFromCurrentState();
6959 } else {
6960 parent->addChild(layer);
6961 }
6962
Arthur Hungb6aa9a02021-06-09 14:23:01 +08006963 layer->updateTransformHint(mDefaultDisplayTransformHint);
6964
arthurhungdba591c2021-02-08 17:28:49 +08006965 if (state->initialProducer != nullptr) {
6966 mGraphicBufferProducerList.insert(state->initialProducer);
6967 LOG_ALWAYS_FATAL_IF(mGraphicBufferProducerList.size() > mMaxGraphicBufferProducerListSize,
6968 "Suspected IGBP leak: %zu IGBPs (%zu max), %zu Layers",
6969 mGraphicBufferProducerList.size(), mMaxGraphicBufferProducerListSize,
6970 mNumLayers.load());
6971 if (mGraphicBufferProducerList.size() > mGraphicBufferProducerListSizeLogThreshold) {
6972 ALOGW("Suspected IGBP leak: %zu IGBPs (%zu max), %zu Layers",
6973 mGraphicBufferProducerList.size(), mMaxGraphicBufferProducerListSize,
6974 mNumLayers.load());
6975 }
6976 }
6977
6978 return layer;
6979}
Ady Abraham562c2712021-05-07 15:10:42 -07006980
6981void SurfaceFlinger::scheduleRegionSamplingThread() {
6982 static_cast<void>(schedule([&] { notifyRegionSamplingThread(); }));
6983}
6984
6985void SurfaceFlinger::notifyRegionSamplingThread() {
6986 if (!mLumaSampling || !mRegionSamplingThread) {
6987 return;
6988 }
6989
6990 mRegionSamplingThread->onCompositionComplete(mEventQueue->nextExpectedInvalidate());
6991}
6992
Ady Abraham7825c682021-05-17 15:12:14 -07006993void SurfaceFlinger::onActiveDisplaySizeChanged(const sp<DisplayDevice>& activeDisplay) {
6994 mScheduler->onActiveDisplayAreaChanged(activeDisplay->getWidth() * activeDisplay->getHeight());
6995 getRenderEngine().onActiveDisplaySizeChanged(activeDisplay->getSize());
6996}
6997
6998void SurfaceFlinger::onActiveDisplayChangedLocked(const sp<DisplayDevice>& activeDisplay) {
6999 ATRACE_CALL();
7000
Ady Abrahamdb036a82021-07-16 14:18:34 -07007001 if (const auto display = getDisplayDeviceLocked(mActiveDisplayToken)) {
7002 display->getCompositionDisplay()->setLayerCachingTexturePoolEnabled(false);
7003 }
7004
Ady Abraham7825c682021-05-17 15:12:14 -07007005 if (!activeDisplay) {
7006 ALOGE("%s: activeDisplay is null", __func__);
7007 return;
7008 }
Ady Abrahamdb036a82021-07-16 14:18:34 -07007009 mActiveDisplayToken = activeDisplay->getDisplayToken();
7010
7011 activeDisplay->getCompositionDisplay()->setLayerCachingTexturePoolEnabled(true);
Ady Abraham3efa3942021-06-24 19:01:25 -07007012 updateInternalDisplayVsyncLocked(activeDisplay);
Ady Abrahamb4937392021-06-23 18:05:03 -07007013 mScheduler->setModeChangePending(false);
Ady Abraham3efa3942021-06-24 19:01:25 -07007014 mScheduler->setRefreshRateConfigs(activeDisplay->holdRefreshRateConfigs());
Ady Abraham7825c682021-05-17 15:12:14 -07007015 onActiveDisplaySizeChanged(activeDisplay);
Ady Abraham7825c682021-05-17 15:12:14 -07007016}
7017
chaviw60c9d3e2021-06-04 12:52:17 -05007018status_t SurfaceFlinger::addWindowInfosListener(
7019 const sp<IWindowInfosListener>& windowInfosListener) const {
7020 mWindowInfosListenerInvoker->addWindowInfosListener(windowInfosListener);
7021 return NO_ERROR;
7022}
7023
7024status_t SurfaceFlinger::removeWindowInfosListener(
7025 const sp<IWindowInfosListener>& windowInfosListener) const {
7026 mWindowInfosListenerInvoker->removeWindowInfosListener(windowInfosListener);
7027 return NO_ERROR;
7028}
7029
Dominik Laskowski9dab3432019-03-27 13:21:10 -07007030} // namespace android
Lloyd Pique074e8122018-07-26 12:57:23 -07007031
Mathias Agopian3f844832013-08-07 21:24:32 -07007032#if defined(__gl_h_)
7033#error "don't include gl/gl.h in this file"
7034#endif
7035
7036#if defined(__gl2_h_)
7037#error "don't include gl2/gl2.h in this file"
Chia-I Wu767fcf72017-11-30 22:07:38 -08007038#endif
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08007039
7040// TODO(b/129481165): remove the #pragma below and fix conversion issues
Marin Shalamanovbed7fd32020-12-21 20:02:20 +01007041#pragma clang diagnostic pop // ignored "-Wconversion -Wextra"