blob: 82d8f089eefb20c017abd544e72b90805f89d1af [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"
20
Alec Mourie7d1d4a2019-02-05 01:13:46 +000021//#define LOG_NDEBUG 0
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080022#define ATRACE_TAG ATRACE_TAG_GRAPHICS
23
Alec Mouri989ddbe2020-02-06 09:26:19 -080024#include "SurfaceFlinger.h"
Dominik Laskowski83b88212018-12-11 13:34:06 -080025
Alec Mouri989ddbe2020-02-06 09:26:19 -080026#include <android/configuration.h>
27#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
28#include <android/hardware/configstore/1.1/ISurfaceFlingerConfigs.h>
29#include <android/hardware/configstore/1.1/types.h>
30#include <android/hardware/power/1.0/IPower.h>
Steven Thomas62a4cf82020-01-31 12:04:03 -080031#include <android/native_window.h>
Mathias Agopianc5b2c0b2009-05-19 19:08:10 -070032#include <binder/IPCThreadState.h>
33#include <binder/IServiceManager.h>
Mathias Agopian99b49842011-06-27 16:05:52 -070034#include <binder/PermissionCache.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070035#include <compositionengine/CompositionEngine.h>
Lloyd Piqueab039b52019-02-13 14:22:42 -080036#include <compositionengine/CompositionRefreshArgs.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070037#include <compositionengine/Display.h>
Lloyd Pique3d0c02e2018-10-19 18:38:12 -070038#include <compositionengine/DisplayColorProfile.h>
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -070039#include <compositionengine/DisplayCreationArgs.h>
Lloyd Piquede196652020-01-22 17:29:58 -080040#include <compositionengine/LayerFECompositionState.h>
Lloyd Piquecc01a452018-12-04 17:24:00 -080041#include <compositionengine/OutputLayer.h>
Lloyd Pique31cb2942018-10-19 17:23:03 -070042#include <compositionengine/RenderSurface.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070043#include <compositionengine/impl/OutputCompositionState.h>
Alec Mouri989ddbe2020-02-06 09:26:19 -080044#include <configstore/Utils.h>
45#include <cutils/compiler.h>
46#include <cutils/properties.h>
47#include <dlfcn.h>
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -080048#include <dvr/vr_flinger.h>
Alec Mouri989ddbe2020-02-06 09:26:19 -080049#include <errno.h>
Jamie Gennis1a4d8832012-08-02 20:11:05 -070050#include <gui/BufferQueue.h>
Ady Abrahama3b08ef2019-07-15 18:43:10 -070051#include <gui/DebugEGLImageTracker.h>
Andy McFadden4803b742012-09-24 19:07:20 -070052#include <gui/GuiConfig.h>
Jamie Gennis1a4d8832012-08-02 20:11:05 -070053#include <gui/IDisplayEventConnection.h>
Alec Mouri0a9c7b82018-11-16 13:05:25 -080054#include <gui/IProducerListener.h>
Kalle Raitaa099a242017-01-11 11:17:29 -080055#include <gui/LayerDebugInfo.h>
Lloyd Pique4603f3c2020-02-11 12:06:56 -080056#include <gui/LayerMetadata.h>
Steven Thomas62a4cf82020-01-31 12:04:03 -080057#include <gui/LayerState.h>
Mathias Agopiane3c697f2013-02-14 17:11:02 -080058#include <gui/Surface.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070059#include <input/IInputFlinger.h>
Alec Mouri989ddbe2020-02-06 09:26:19 -080060#include <layerproto/LayerProtoParser.h>
61#include <log/log.h>
62#include <private/android_filesystem_config.h>
63#include <private/gui/SyncFeatures.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070064#include <renderengine/RenderEngine.h>
Alec Mouri989ddbe2020-02-06 09:26:19 -080065#include <statslog.h>
66#include <sys/types.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070067#include <ui/ColorSpace.h>
68#include <ui/DebugUtils.h>
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -080069#include <ui/DisplayConfig.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070070#include <ui/DisplayInfo.h>
71#include <ui/DisplayStatInfo.h>
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -080072#include <ui/DisplayState.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070073#include <ui/GraphicBufferAllocator.h>
74#include <ui/PixelFormat.h>
Andy McFadden4803b742012-09-24 19:07:20 -070075#include <ui/UiConfig.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080076#include <utils/StopWatch.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070077#include <utils/String16.h>
78#include <utils/String8.h>
Yusuke Sato0a688f52015-07-30 23:05:39 -070079#include <utils/Timers.h>
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080080#include <utils/Trace.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070081#include <utils/misc.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080082
Alec Mouri989ddbe2020-02-06 09:26:19 -080083#include <algorithm>
84#include <cinttypes>
85#include <cmath>
86#include <cstdint>
87#include <functional>
88#include <mutex>
89#include <optional>
90#include <unordered_map>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080091
Robert Carr578038f2018-03-09 12:25:24 -080092#include "BufferLayer.h"
Marissa Wallfd668622018-05-10 10:21:13 -070093#include "BufferQueueLayer.h"
Marissa Wall61c58622018-07-18 10:12:20 -070094#include "BufferStateLayer.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +020095#include "Client.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +020096#include "Colorizer.h"
Robert Carr578038f2018-03-09 12:25:24 -080097#include "ContainerLayer.h"
Robert Carr578038f2018-03-09 12:25:24 -080098#include "DisplayDevice.h"
Steven Thomasb02664d2017-07-26 18:48:28 -070099#include "DisplayHardware/ComposerHal.h"
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700100#include "DisplayHardware/DisplayIdentification.h"
Mathias Agopiana4912602012-07-12 14:25:33 -0700101#include "DisplayHardware/FramebufferSurface.h"
Mathias Agopiana350ff92010-08-10 17:14:02 -0700102#include "DisplayHardware/HWComposer.h"
Jesse Hall99c7dbb2013-03-14 14:29:29 -0700103#include "DisplayHardware/VirtualDisplaySurface.h"
Alec Mouri989ddbe2020-02-06 09:26:19 -0800104#include "EffectLayer.h"
Mathias Agopianff2ed702013-09-01 21:36:12 -0700105#include "Effects/Daltonizer.h"
Mikael Pessa90092f42019-08-26 17:22:04 -0700106#include "FrameTracer/FrameTracer.h"
Alec Mouri989ddbe2020-02-06 09:26:19 -0800107#include "Layer.h"
108#include "LayerVector.h"
109#include "MonitoredProducer.h"
110#include "NativeWindowSurface.h"
Dominik Laskowski5690bde2020-04-23 19:04:22 -0700111#include "Promise.h"
Alec Mouri989ddbe2020-02-06 09:26:19 -0800112#include "RefreshRateOverlay.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700113#include "RegionSamplingThread.h"
Ana Krulecfefcb582018-08-07 14:22:37 -0700114#include "Scheduler/DispSync.h"
Ana Krulec241cf832018-08-10 15:03:23 -0700115#include "Scheduler/DispSyncSource.h"
Ana Krulecfefcb582018-08-07 14:22:37 -0700116#include "Scheduler/EventControlThread.h"
117#include "Scheduler/EventThread.h"
Ady Abraham5def7332020-05-29 16:13:47 -0700118#include "Scheduler/LayerHistory.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -0700119#include "Scheduler/MessageQueue.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700120#include "Scheduler/PhaseOffsets.h"
Ana Krulec98b5b242018-08-10 15:03:23 -0700121#include "Scheduler/Scheduler.h"
Alec Mouri989ddbe2020-02-06 09:26:19 -0800122#include "StartPropertySetThread.h"
123#include "SurfaceFlingerProperties.h"
124#include "SurfaceInterceptor.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800125#include "TimeStats/TimeStats.h"
Dominik Laskowskib6e54372019-09-04 14:06:28 -0700126#include "android-base/parseint.h"
David Sodman7e4ae112018-02-09 15:02:28 -0800127#include "android-base/stringprintf.h"
128
Dominik Laskowskia19f4b62020-04-21 00:27:31 -0700129#define MAIN_THREAD ACQUIRE(mStateLock) RELEASE(mStateLock)
130
131#define ON_MAIN_THREAD(expr) \
132 [&] { \
133 LOG_FATAL_IF(std::this_thread::get_id() != mMainThreadId); \
134 UnnecessaryLock lock(mStateLock); \
135 return (expr); \
136 }()
137
138#undef NO_THREAD_SAFETY_ANALYSIS
139#define NO_THREAD_SAFETY_ANALYSIS \
140 _Pragma("GCC error \"Prefer MAIN_THREAD macros or {Conditional,Timed,Unnecessary}Lock.\"")
141
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800142namespace android {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700143
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700144using namespace std::string_literals;
145
Jaesoo Lee43518572017-01-23 19:03:16 +0900146using namespace android::hardware::configstore;
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900147using namespace android::hardware::configstore::V1_0;
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900148using namespace android::sysprop;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -0800149
Ady Abraham8532d012019-05-08 14:50:56 -0700150using android::hardware::power::V1_0::PowerHint;
Yiwei Zhang5434a782018-12-05 18:06:32 -0800151using base::StringAppendF;
Peiyong Lin9f034472018-03-28 15:29:00 -0700152using ui::ColorMode;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700153using ui::Dataspace;
Daniel Solomon42d04562019-01-20 21:03:19 -0800154using ui::DisplayPrimaries;
Peiyong Lin62665892018-04-16 11:07:44 -0700155using ui::Hdr;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700156using ui::RenderIntent;
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900157
Peiyong Line9d809e2020-04-14 13:10:48 -0700158namespace hal = android::hardware::graphics::composer::hal;
159
Steven Thomasb02664d2017-07-26 18:48:28 -0700160namespace {
Peiyong Linfca547f2018-07-09 13:03:33 -0700161
162#pragma clang diagnostic push
163#pragma clang diagnostic error "-Wswitch-enum"
164
165bool isWideColorMode(const ColorMode colorMode) {
166 switch (colorMode) {
167 case ColorMode::DISPLAY_P3:
168 case ColorMode::ADOBE_RGB:
169 case ColorMode::DCI_P3:
170 case ColorMode::BT2020:
Valerie Hau9758ae02018-10-09 16:05:09 -0700171 case ColorMode::DISPLAY_BT2020:
Peiyong Linfca547f2018-07-09 13:03:33 -0700172 case ColorMode::BT2100_PQ:
173 case ColorMode::BT2100_HLG:
174 return true;
175 case ColorMode::NATIVE:
176 case ColorMode::STANDARD_BT601_625:
177 case ColorMode::STANDARD_BT601_625_UNADJUSTED:
178 case ColorMode::STANDARD_BT601_525:
179 case ColorMode::STANDARD_BT601_525_UNADJUSTED:
180 case ColorMode::STANDARD_BT709:
181 case ColorMode::SRGB:
182 return false;
183 }
184 return false;
185}
186
187#pragma clang diagnostic pop
188
Dominik Laskowski542c9dc2020-04-10 12:42:02 -0700189template <typename Mutex>
Dominik Laskowskia19f4b62020-04-21 00:27:31 -0700190struct SCOPED_CAPABILITY ConditionalLockGuard {
191 ConditionalLockGuard(Mutex& mutex, bool lock) ACQUIRE(mutex) : mutex(mutex), lock(lock) {
Dominik Laskowski542c9dc2020-04-10 12:42:02 -0700192 if (lock) mutex.lock();
Steven Thomasb02664d2017-07-26 18:48:28 -0700193 }
Dominik Laskowski542c9dc2020-04-10 12:42:02 -0700194
Dominik Laskowskia19f4b62020-04-21 00:27:31 -0700195 ~ConditionalLockGuard() RELEASE() {
Dominik Laskowski542c9dc2020-04-10 12:42:02 -0700196 if (lock) mutex.unlock();
197 }
198
199 Mutex& mutex;
200 const bool lock;
Steven Thomasb02664d2017-07-26 18:48:28 -0700201};
Peiyong Linfca547f2018-07-09 13:03:33 -0700202
Dominik Laskowski542c9dc2020-04-10 12:42:02 -0700203using ConditionalLock = ConditionalLockGuard<Mutex>;
204
Dominik Laskowskia19f4b62020-04-21 00:27:31 -0700205struct SCOPED_CAPABILITY TimedLock {
206 TimedLock(Mutex& mutex, nsecs_t timeout, const char* whence) ACQUIRE(mutex)
207 : mutex(mutex), status(mutex.timedLock(timeout)) {
208 ALOGE_IF(!locked(), "%s timed out locking: %s (%d)", whence, strerror(-status), status);
209 }
210
211 ~TimedLock() RELEASE() {
212 if (locked()) mutex.unlock();
213 }
214
215 bool locked() const { return status == NO_ERROR; }
216
217 Mutex& mutex;
218 const status_t status;
219};
220
221struct SCOPED_CAPABILITY UnnecessaryLock {
222 explicit UnnecessaryLock(Mutex& mutex) ACQUIRE(mutex) {}
223 ~UnnecessaryLock() RELEASE() {}
224};
225
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800226// TODO(b/141333600): Consolidate with HWC2::Display::Config::Builder::getDefaultDensity.
Dominik Laskowskid125d0e2020-05-08 12:36:39 -0700227constexpr float FALLBACK_DENSITY = ACONFIGURATION_DENSITY_TV;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800228
229float getDensityFromProperty(const char* property, bool required) {
230 char value[PROPERTY_VALUE_MAX];
231 const float density = property_get(property, value, nullptr) > 0 ? std::atof(value) : 0.f;
232 if (!density && required) {
233 ALOGE("%s must be defined as a build property", property);
234 return FALLBACK_DENSITY;
235 }
Dominik Laskowskid125d0e2020-05-08 12:36:39 -0700236 return density;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800237}
238
Peiyong Lin9d846a52018-11-05 13:18:20 -0800239// Currently we only support V0_SRGB and DISPLAY_P3 as composition preference.
240bool validateCompositionDataspace(Dataspace dataspace) {
241 return dataspace == Dataspace::V0_SRGB || dataspace == Dataspace::DISPLAY_P3;
242}
243
Steven Thomasd4071902020-03-24 16:02:53 -0700244class FrameRateFlexibilityToken : public BBinder {
245public:
246 FrameRateFlexibilityToken(std::function<void()> callback) : mCallback(callback) {}
247 virtual ~FrameRateFlexibilityToken() { mCallback(); }
248
249private:
250 std::function<void()> mCallback;
251};
252
Steven Thomasb02664d2017-07-26 18:48:28 -0700253} // namespace anonymous
254
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800255// ---------------------------------------------------------------------------
256
Mathias Agopian99b49842011-06-27 16:05:52 -0700257const String16 sHardwareTest("android.permission.HARDWARE_TEST");
258const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER");
259const String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER");
260const String16 sDump("android.permission.DUMP");
Ady Abrahama09852a2020-02-20 14:23:42 -0800261const char* KERNEL_IDLE_TIMER_PROP = "vendor.display.enable_kernel_idle_timer";
Mathias Agopian99b49842011-06-27 16:05:52 -0700262
263// ---------------------------------------------------------------------------
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700264int64_t SurfaceFlinger::dispSyncPresentTimeOffset;
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700265bool SurfaceFlinger::useHwcForRgbToYuv;
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800266uint64_t SurfaceFlinger::maxVirtualDisplaySize;
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800267bool SurfaceFlinger::hasSyncFramework;
Steven Thomas050b2c82017-03-06 11:45:16 -0800268bool SurfaceFlinger::useVrFlinger;
Fabien Sanglard1971b632017-03-10 14:50:03 -0800269int64_t SurfaceFlinger::maxFrameBufferAcquiredBuffers;
Brian Lindahla13f2d52020-03-05 11:54:17 +0100270uint32_t SurfaceFlinger::maxGraphicsWidth;
271uint32_t SurfaceFlinger::maxGraphicsHeight;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600272bool SurfaceFlinger::hasWideColorDisplay;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800273ui::Rotation SurfaceFlinger::internalDisplayOrientation = ui::ROTATION_0;
Peiyong Lin13effd12018-07-24 17:01:47 -0700274bool SurfaceFlinger::useColorManagement;
Peiyong Linb3839ad2018-09-05 15:37:19 -0700275bool SurfaceFlinger::useContextPriority;
Peiyong Linc6780972018-10-28 15:24:08 -0700276Dataspace SurfaceFlinger::defaultCompositionDataspace = Dataspace::V0_SRGB;
277ui::PixelFormat SurfaceFlinger::defaultCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
278Dataspace SurfaceFlinger::wideColorGamutCompositionDataspace = Dataspace::V0_SRGB;
279ui::PixelFormat SurfaceFlinger::wideColorGamutCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
Ana Krulec3803b8d2020-02-03 16:35:46 -0800280bool SurfaceFlinger::useFrameRateApi;
Mathias Agopian99b49842011-06-27 16:05:52 -0700281
Kalle Raitaa099a242017-01-11 11:17:29 -0800282std::string getHwcServiceName() {
283 char value[PROPERTY_VALUE_MAX] = {};
284 property_get("debug.sf.hwc_service_name", value, "default");
285 ALOGI("Using HWComposer service: '%s'", value);
286 return std::string(value);
287}
288
289bool useTrebleTestingOverride() {
290 char value[PROPERTY_VALUE_MAX] = {};
291 property_get("debug.sf.treble_testing_override", value, "false");
292 ALOGI("Treble testing override: '%s'", value);
293 return std::string(value) == "true";
294}
295
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800296std::string decodeDisplayColorSetting(DisplayColorSetting displayColorSetting) {
297 switch(displayColorSetting) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800298 case DisplayColorSetting::kManaged:
Chia-I Wu0d711262018-05-21 15:19:35 -0700299 return std::string("Managed");
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800300 case DisplayColorSetting::kUnmanaged:
Chia-I Wu0d711262018-05-21 15:19:35 -0700301 return std::string("Unmanaged");
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800302 case DisplayColorSetting::kEnhanced:
Chia-I Wu0d711262018-05-21 15:19:35 -0700303 return std::string("Enhanced");
304 default:
305 return std::string("Unknown ") +
306 std::to_string(static_cast<int>(displayColorSetting));
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800307 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800308}
309
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700310SurfaceFlingerBE::SurfaceFlingerBE() : mHwcServiceName(getHwcServiceName()) {}
David Sodmanbc815282017-11-05 18:57:52 -0800311
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700312SurfaceFlinger::SurfaceFlinger(Factory& factory, SkipInitializationTag)
313 : mFactory(factory),
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700314 mInterceptor(mFactory.createSurfaceInterceptor(this)),
Yiwei Zhangf0229a72019-09-09 19:28:02 -0700315 mTimeStats(std::make_shared<impl::TimeStats>()),
Mikael Pessa90092f42019-08-26 17:22:04 -0700316 mFrameTracer(std::make_unique<FrameTracer>()),
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700317 mEventQueue(mFactory.createMessageQueue()),
Dominik Laskowskieddeda12019-07-19 11:54:13 -0700318 mCompositionEngine(mFactory.createCompositionEngine()),
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800319 mInternalDisplayDensity(getDensityFromProperty("ro.sf.lcd_density", true)),
320 mEmulatedDisplayDensity(getDensityFromProperty("qemu.sf.lcd_density", false)) {}
Lloyd Piqueac648ee2018-01-17 13:42:24 -0800321
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700322SurfaceFlinger::SurfaceFlinger(Factory& factory) : SurfaceFlinger(factory, SkipInitialization) {
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800323 ALOGI("SurfaceFlinger is starting");
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800324
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900325 hasSyncFramework = running_without_sync_framework(true);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800326
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900327 dispSyncPresentTimeOffset = present_time_offset_from_vsync_ns(0);
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700328
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900329 useHwcForRgbToYuv = force_hwc_copy_for_virtual_displays(false);
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700330
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900331 maxVirtualDisplaySize = max_virtual_display_dimension(0);
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800332
Steven Thomas050b2c82017-03-06 11:45:16 -0800333 // Vr flinger is only enabled on Daydream ready devices.
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900334 useVrFlinger = use_vr_flinger(false);
Steven Thomas050b2c82017-03-06 11:45:16 -0800335
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900336 maxFrameBufferAcquiredBuffers = max_frame_buffer_acquired_buffers(2);
Fabien Sanglard1971b632017-03-10 14:50:03 -0800337
Brian Lindahla13f2d52020-03-05 11:54:17 +0100338 maxGraphicsWidth = std::max(max_graphics_width(0), 0);
339 maxGraphicsHeight = std::max(max_graphics_height(0), 0);
340
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900341 hasWideColorDisplay = has_wide_color_display(false);
Peiyong Lin0256f722018-08-31 15:45:10 -0700342
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900343 useColorManagement = use_color_management(false);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600344
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900345 mDefaultCompositionDataspace =
346 static_cast<ui::Dataspace>(default_composition_dataspace(Dataspace::V0_SRGB));
Peiyong Lin8cabfc32019-06-14 14:25:43 -0700347 mWideColorGamutCompositionDataspace = static_cast<ui::Dataspace>(wcg_composition_dataspace(
348 hasWideColorDisplay ? Dataspace::DISPLAY_P3 : Dataspace::V0_SRGB));
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900349 defaultCompositionDataspace = mDefaultCompositionDataspace;
350 wideColorGamutCompositionDataspace = mWideColorGamutCompositionDataspace;
351 defaultCompositionPixelFormat = static_cast<ui::PixelFormat>(
352 default_composition_pixel_format(ui::PixelFormat::RGBA_8888));
353 wideColorGamutCompositionPixelFormat =
354 static_cast<ui::PixelFormat>(wcg_composition_pixel_format(ui::PixelFormat::RGBA_8888));
Peiyong Linb3839ad2018-09-05 15:37:19 -0700355
Yichi Chenda901bf2019-06-28 14:58:27 +0800356 mColorSpaceAgnosticDataspace =
357 static_cast<ui::Dataspace>(color_space_agnostic_dataspace(Dataspace::UNKNOWN));
358
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900359 useContextPriority = use_context_priority(true);
Iris Chang7501ed62018-04-30 14:45:42 +0800360
Dominik Laskowski718f9602019-11-09 20:01:35 -0800361 using Values = SurfaceFlingerProperties::primary_display_orientation_values;
362 switch (primary_display_orientation(Values::ORIENTATION_0)) {
363 case Values::ORIENTATION_0:
Iris Chang7501ed62018-04-30 14:45:42 +0800364 break;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800365 case Values::ORIENTATION_90:
366 internalDisplayOrientation = ui::ROTATION_90;
Iris Chang7501ed62018-04-30 14:45:42 +0800367 break;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800368 case Values::ORIENTATION_180:
369 internalDisplayOrientation = ui::ROTATION_180;
Iris Chang7501ed62018-04-30 14:45:42 +0800370 break;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800371 case Values::ORIENTATION_270:
372 internalDisplayOrientation = ui::ROTATION_270;
Iris Chang7501ed62018-04-30 14:45:42 +0800373 break;
374 }
Dominik Laskowski718f9602019-11-09 20:01:35 -0800375 ALOGV("Internal Display Orientation: %s", toCString(internalDisplayOrientation));
Iris Chang7501ed62018-04-30 14:45:42 +0800376
Sundong Ahn85131bd2019-02-18 15:51:53 +0900377 mInternalDisplayPrimaries = sysprop::getDisplayNativePrimaries();
Daniel Solomon42d04562019-01-20 21:03:19 -0800378
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800379 // debugging stuff...
380 char value[PROPERTY_VALUE_MAX];
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700381
Mathias Agopianb4b17302013-03-20 18:36:41 -0700382 property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");
Mathias Agopian50210b92013-03-21 21:13:21 -0700383 mGpuToCpuSupported = !atoi(value);
Mathias Agopianb4b17302013-03-20 18:36:41 -0700384
Alec Mouri989ddbe2020-02-06 09:26:19 -0800385 property_get("ro.build.type", value, "user");
386 mIsUserBuild = strcmp(value, "user") == 0;
387
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800388 property_get("debug.sf.showupdates", value, "0");
389 mDebugRegion = atoi(value);
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700390
Mathias Agopianc1d359d2012-08-04 20:09:03 -0700391 ALOGI_IF(mDebugRegion, "showupdates enabled");
Orion Hodson34397da2019-02-04 09:36:10 +0000392
393 // DDMS debugging deprecated (b/120782499)
394 property_get("debug.sf.ddms", value, "0");
395 int debugDdms = atoi(value);
396 ALOGI_IF(debugDdms, "DDMS debugging not supported");
Dan Stozac5da2712016-07-20 15:38:12 -0700397
398 property_get("debug.sf.disable_backpressure", value, "0");
399 mPropagateBackpressure = !atoi(value);
400 ALOGI_IF(!mPropagateBackpressure, "Disabling backpressure propagation");
Dan Stoza8cf150a2016-08-02 10:27:31 -0700401
Ady Abrahamadb9a992019-09-19 21:21:55 +0000402 property_get("debug.sf.enable_gl_backpressure", value, "0");
403 mPropagateBackpressureClientComposition = atoi(value);
404 ALOGI_IF(mPropagateBackpressureClientComposition,
405 "Enabling backpressure propagation for Client Composition");
406
Fabien Sanglard642b23d2017-02-09 12:29:39 -0800407 property_get("debug.sf.enable_hwc_vds", value, "0");
408 mUseHwcVirtualDisplays = atoi(value);
Chia-I Wu11d10612018-06-21 15:41:13 +0800409 ALOGI_IF(mUseHwcVirtualDisplays, "Enabling HWC virtual displays");
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800410
Yiwei Zhangb770ed32018-12-17 17:44:28 -0800411 property_get("ro.sf.disable_triple_buffer", value, "0");
Fabien Sanglardc65dafa2017-02-07 14:06:39 -0800412 mLayerTripleBufferingDisabled = atoi(value);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800413 ALOGI_IF(mLayerTripleBufferingDisabled, "Disabling Triple Buffering");
Romain Guy3054f002017-06-05 18:38:53 -0700414
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800415 property_get("ro.surface_flinger.supports_background_blur", value, "0");
416 bool supportsBlurs = atoi(value);
Lucas Dupin00f16422020-03-11 11:33:04 -0700417 mSupportsBlur = supportsBlurs;
418 ALOGI_IF(!mSupportsBlur, "Disabling blur effects, they are not supported.");
Lucas Dupin2dd6f392020-02-18 17:43:36 -0800419 property_get("ro.sf.blurs_are_expensive", value, "0");
420 mBlursAreExpensive = atoi(value);
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800421
Ady Abraham0a525092020-03-03 12:51:24 -0800422 const size_t defaultListSize = ISurfaceComposer::MAX_LAYERS;
Dan Stoza0a0158c2018-03-16 13:38:54 -0700423 auto listSize = property_get_int32("debug.sf.max_igbp_list_size", int32_t(defaultListSize));
424 mMaxGraphicBufferProducerListSize = (listSize > 0) ? size_t(listSize) : defaultListSize;
425
Dan Stozaec460082018-12-17 15:35:09 -0800426 property_get("debug.sf.luma_sampling", value, "1");
427 mLumaSampling = atoi(value);
428
Vishnu Nairb2a999b2020-01-23 13:43:02 -0800429 property_get("debug.sf.disable_client_composition_cache", value, "0");
Vishnu Nair9b079a22020-01-21 14:36:08 -0800430 mDisableClientCompositionCache = atoi(value);
431
Romain Guy11d63f42017-07-20 12:47:14 -0700432 // We should be reading 'persist.sys.sf.color_saturation' here
433 // but since /data may be encrypted, we need to wait until after vold
434 // comes online to attempt to read the property. The property is
435 // instead read after the boot animation
Kalle Raitaa099a242017-01-11 11:17:29 -0800436
437 if (useTrebleTestingOverride()) {
438 // Without the override SurfaceFlinger cannot connect to HIDL
439 // services that are not listed in the manifests. Considered
440 // deriving the setting from the set service name, but it
441 // would be brittle if the name that's not 'default' is used
442 // for production purposes later on.
443 setenv("TREBLE_TESTING_OVERRIDE", "true", true);
444 }
Ana Krulec3803b8d2020-02-03 16:35:46 -0800445
446 useFrameRateApi = use_frame_rate_api(true);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800447}
448
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700449SurfaceFlinger::~SurfaceFlinger() = default;
450
451void SurfaceFlinger::onFirstRef() {
Lloyd Pique3fcdef12018-01-22 17:14:00 -0800452 mEventQueue->init(this);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800453}
454
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700455void SurfaceFlinger::binderDied(const wp<IBinder>&) {
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800456 // the window manager died on us. prepare its eulogy.
Rob Carr2aa78cb2020-03-10 14:27:49 -0700457 mBootFinished = false;
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800458
Andy McFadden13a082e2012-08-24 10:16:42 -0700459 // restore initial conditions (default device unblank, etc)
460 initializeDisplays();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800461
462 // restart the boot-animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700463 startBootAnim();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800464}
465
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700466void SurfaceFlinger::run() {
467 while (true) {
468 mEventQueue->waitMessage();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800469 }
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700470}
471
472template <typename F, typename T>
473inline std::future<T> SurfaceFlinger::schedule(F&& f) {
474 auto [task, future] = makeTask(std::move(f));
475 mEventQueue->postMessage(std::move(task));
476 return std::move(future);
Robert Carr1db73f62016-12-21 12:58:51 -0800477}
478
479sp<ISurfaceComposerClient> SurfaceFlinger::createConnection() {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700480 const sp<Client> client = new Client(this);
481 return client->initCheck() == NO_ERROR ? client : nullptr;
Robert Carr1db73f62016-12-21 12:58:51 -0800482}
483
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700484sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName, bool secure) {
Mathias Agopiane57f2922012-08-09 16:29:12 -0700485 class DisplayToken : public BBinder {
486 sp<SurfaceFlinger> flinger;
487 virtual ~DisplayToken() {
488 // no more references, this display must be terminated
489 Mutex::Autolock _l(flinger->mStateLock);
490 flinger->mCurrentState.displays.removeItem(this);
491 flinger->setTransactionFlags(eDisplayTransactionNeeded);
492 }
493 public:
Chih-Hung Hsiehc4067912016-05-03 14:03:27 -0700494 explicit DisplayToken(const sp<SurfaceFlinger>& flinger)
Mathias Agopiane57f2922012-08-09 16:29:12 -0700495 : flinger(flinger) {
496 }
497 };
498
499 sp<BBinder> token = new DisplayToken(this);
500
501 Mutex::Autolock _l(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700502 // Display ID is assigned when virtual display is allocated by HWC.
503 DisplayDeviceState state;
504 state.isSecure = secure;
505 state.displayName = displayName;
506 mCurrentState.displays.add(token, state);
507 mInterceptor->saveDisplayCreation(state);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700508 return token;
509}
510
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700511void SurfaceFlinger::destroyDisplay(const sp<IBinder>& displayToken) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700512 Mutex::Autolock lock(mStateLock);
Jesse Hall6c913be2013-08-08 12:15:49 -0700513
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700514 const ssize_t index = mCurrentState.displays.indexOfKey(displayToken);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700515 if (index < 0) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700516 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
Jesse Hall6c913be2013-08-08 12:15:49 -0700517 return;
518 }
519
Dominik Laskowski075d3172018-05-24 15:50:06 -0700520 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700521 if (state.physical) {
522 ALOGE("%s: Invalid operation on physical display", __FUNCTION__);
Jesse Hall6c913be2013-08-08 12:15:49 -0700523 return;
524 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700525 mInterceptor->saveDisplayDeletion(state.sequenceId);
526 mCurrentState.displays.removeItemsAt(index);
Jesse Hall6c913be2013-08-08 12:15:49 -0700527 setTransactionFlags(eDisplayTransactionNeeded);
528}
529
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800530std::vector<PhysicalDisplayId> SurfaceFlinger::getPhysicalDisplayIds() const {
531 Mutex::Autolock lock(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700532
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800533 const auto internalDisplayId = getInternalDisplayIdLocked();
534 if (!internalDisplayId) {
535 return {};
Dominik Laskowski075d3172018-05-24 15:50:06 -0700536 }
537
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800538 std::vector<PhysicalDisplayId> displayIds;
539 displayIds.reserve(mPhysicalDisplayTokens.size());
540 displayIds.push_back(internalDisplayId->value);
541
542 for (const auto& [id, token] : mPhysicalDisplayTokens) {
543 if (id != *internalDisplayId) {
544 displayIds.push_back(id.value);
545 }
Mathias Agopiane57f2922012-08-09 16:29:12 -0700546 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700547
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800548 return displayIds;
549}
550
551sp<IBinder> SurfaceFlinger::getPhysicalDisplayToken(PhysicalDisplayId displayId) const {
552 Mutex::Autolock lock(mStateLock);
553 return getPhysicalDisplayTokenLocked(DisplayId{displayId});
Mathias Agopiane57f2922012-08-09 16:29:12 -0700554}
555
Ady Abraham37965d42018-11-01 13:43:32 -0700556status_t SurfaceFlinger::getColorManagement(bool* outGetColorManagement) const {
557 if (!outGetColorManagement) {
558 return BAD_VALUE;
559 }
560 *outGetColorManagement = useColorManagement;
561 return NO_ERROR;
Ady Abraham2a6ab2a2018-10-26 14:25:30 -0700562}
563
Lloyd Pique441d5042018-10-18 16:49:51 -0700564HWComposer& SurfaceFlinger::getHwComposer() const {
565 return mCompositionEngine->getHwComposer();
566}
567
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700568renderengine::RenderEngine& SurfaceFlinger::getRenderEngine() const {
569 return mCompositionEngine->getRenderEngine();
570}
571
Lloyd Pique70d91362018-10-18 16:02:55 -0700572compositionengine::CompositionEngine& SurfaceFlinger::getCompositionEngine() const {
573 return *mCompositionEngine.get();
574}
575
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800576void SurfaceFlinger::bootFinished()
577{
Rob Carr2aa78cb2020-03-10 14:27:49 -0700578 if (mBootFinished == true) {
579 ALOGE("Extra call to bootFinished");
580 return;
581 }
582 mBootFinished = true;
Wei Wangf9b05ee2017-07-19 20:59:39 -0700583 if (mStartPropertySetThread->join() != NO_ERROR) {
584 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800585 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800586 const nsecs_t now = systemTime();
587 const nsecs_t duration = now - mBootTime;
Steve Blocka19954a2012-01-04 20:05:49 +0000588 ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700589
Mikael Pessa90092f42019-08-26 17:22:04 -0700590 mFrameTracer->initialize();
Alec Mouri8e2f31b2020-01-16 22:04:35 +0000591 mTimeStats->onBootFinished();
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700592
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700593 // wait patiently for the window manager death
594 const String16 name("window");
Steven Morelanda904bb92019-07-02 17:37:23 -0700595 mWindowManager = defaultServiceManager()->getService(name);
596 if (mWindowManager != 0) {
597 mWindowManager->linkToDeath(static_cast<IBinder::DeathRecipient*>(this));
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700598 }
Robert Carr720e5062018-07-30 17:45:14 -0700599 sp<IBinder> input(defaultServiceManager()->getService(
600 String16("inputflinger")));
601 if (input == nullptr) {
602 ALOGE("Failed to link to input service");
603 } else {
604 mInputFlinger = interface_cast<IInputFlinger>(input);
605 }
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700606
Steven Thomas050b2c82017-03-06 11:45:16 -0800607 if (mVrFlinger) {
608 mVrFlinger->OnBootFinished();
609 }
610
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700611 // stop boot animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700612 // formerly we would just kill the process, but we now ask it to exit so it
613 // can choose where to stop the animation.
614 property_set("service.bootanim.exit", "1");
Yusuke Sato0a688f52015-07-30 23:05:39 -0700615
616 const int LOGTAG_SF_STOP_BOOTANIM = 60110;
617 LOG_EVENT_LONG(LOGTAG_SF_STOP_BOOTANIM,
618 ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
Romain Guy11d63f42017-07-20 12:47:14 -0700619
Dominik Laskowski20134642020-04-20 22:36:44 -0700620 static_cast<void>(schedule([this] {
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800621 readPersistentProperties();
Dan Stoza29e7bdf2020-03-23 14:43:09 -0700622 mPowerAdvisor.onBootFinished();
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800623 mBootStage = BootStage::FINISHED;
Ana Krulecbd6654b2019-02-15 15:18:15 -0800624
Ady Abraham8a82ba62020-01-17 12:43:17 -0800625 if (property_get_bool("sf.debug.show_refresh_rate_overlay", false)) {
Dominik Laskowski20134642020-04-20 22:36:44 -0700626 enableRefreshRateOverlay(true);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800627 }
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800628 }));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800629}
630
Dan Stoza436ccf32018-06-21 12:10:12 -0700631uint32_t SurfaceFlinger::getNewTexture() {
632 {
633 std::lock_guard lock(mTexturePoolMutex);
634 if (!mTexturePool.empty()) {
635 uint32_t name = mTexturePool.back();
636 mTexturePool.pop_back();
637 ATRACE_INT("TexturePoolSize", mTexturePool.size());
638 return name;
639 }
640
641 // The pool was too small, so increase it for the future
642 ++mTexturePoolSize;
643 }
644
645 // The pool was empty, so we need to get a new texture name directly using a
646 // blocking call to the main thread
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700647 return schedule([this] {
648 uint32_t name = 0;
649 getRenderEngine().genTextures(1, &name);
650 return name;
651 })
652 .get();
Dan Stoza436ccf32018-06-21 12:10:12 -0700653}
654
Mathias Agopian3f844832013-08-07 21:24:32 -0700655void SurfaceFlinger::deleteTextureAsync(uint32_t texture) {
Dan Stoza67765d82019-05-07 14:58:27 -0700656 std::lock_guard lock(mTexturePoolMutex);
657 // We don't change the pool size, so the fix-up logic in postComposition will decide whether
658 // to actually delete this or not based on mTexturePoolSize
659 mTexturePool.push_back(texture);
660 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700661}
662
Wei Wangf9b05ee2017-07-19 20:59:39 -0700663// Do not call property_set on main thread which will be blocked by init
664// Use StartPropertySetThread instead.
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700665void SurfaceFlinger::init() {
Mathias Agopiana4912602012-07-12 14:25:33 -0700666 ALOGI( "SurfaceFlinger's main thread ready to run. "
667 "Initializing graphics H/W...");
Steven Thomasb02664d2017-07-26 18:48:28 -0700668 Mutex::Autolock _l(mStateLock);
Kevin DuBois413287f2019-02-25 08:46:47 -0800669
Steven Thomasb02664d2017-07-26 18:48:28 -0700670 // Get a RenderEngine for the given display / config (can't fail)
Peiyong Lin0256f722018-08-31 15:45:10 -0700671 // TODO(b/77156734): We need to stop casting and use HAL types when possible.
Alec Mourida4cf3b2019-02-12 15:33:01 -0800672 // Sending maxFrameBufferAcquiredBuffers as the cache size is tightly tuned to single-display.
Peiyong Lin4137a1d72019-10-09 10:39:09 -0700673 mCompositionEngine->setRenderEngine(renderengine::RenderEngine::create(
674 renderengine::RenderEngineCreationArgs::Builder()
675 .setPixelFormat(static_cast<int32_t>(defaultCompositionPixelFormat))
676 .setImageCacheSize(maxFrameBufferAcquiredBuffers)
677 .setUseColorManagerment(useColorManagement)
678 .setEnableProtectedContext(enable_protected_contents(false))
679 .setPrecacheToneMapperShaderOnly(false)
Lucas Dupin00f16422020-03-11 11:33:04 -0700680 .setSupportsBackgroundBlur(mSupportsBlur)
Peiyong Lin4137a1d72019-10-09 10:39:09 -0700681 .setContextPriority(useContextPriority
682 ? renderengine::RenderEngine::ContextPriority::HIGH
683 : renderengine::RenderEngine::ContextPriority::MEDIUM)
684 .build()));
Alec Mourie4034bb2019-11-19 12:45:54 -0800685 mCompositionEngine->setTimeStats(mTimeStats);
Steven Thomasb02664d2017-07-26 18:48:28 -0700686
687 LOG_ALWAYS_FATAL_IF(mVrFlingerRequestsDisplay,
688 "Starting with vr flinger active is not currently supported.");
Lloyd Pique441d5042018-10-18 16:49:51 -0700689 mCompositionEngine->setHwComposer(getFactory().createHWComposer(getBE().mHwcServiceName));
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800690 mCompositionEngine->getHwComposer().setConfiguration(this, getBE().mComposerSequenceId);
Lloyd Piqueba04e622017-12-14 17:11:26 -0800691 // Process any initial hotplug and resulting display changes.
692 processDisplayHotplugEventsLocked();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700693 const auto display = getDefaultDisplayDeviceLocked();
694 LOG_ALWAYS_FATAL_IF(!display, "Missing internal display after registering composer callback.");
Dominik Laskowski075d3172018-05-24 15:50:06 -0700695 LOG_ALWAYS_FATAL_IF(!getHwComposer().isConnected(*display->getId()),
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700696 "Internal display is disconnected.");
Jesse Hall692c7232012-11-08 15:41:56 -0800697
Steven Thomas050b2c82017-03-06 11:45:16 -0800698 if (useVrFlinger) {
Dominik Laskowski8c001672018-05-30 16:52:06 -0700699 auto vrFlingerRequestDisplayCallback = [this](bool requestDisplay) {
Steven Thomasbe6cbae2017-09-28 15:30:23 -0700700 // This callback is called from the vr flinger dispatch thread. We
701 // need to call signalTransaction(), which requires holding
702 // mStateLock when we're not on the main thread. Acquiring
703 // mStateLock from the vr flinger dispatch thread might trigger a
704 // deadlock in surface flinger (see b/66916578), so post a message
705 // to be handled on the main thread instead.
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700706 static_cast<void>(schedule([=] {
Steven Thomasbe6cbae2017-09-28 15:30:23 -0700707 ALOGI("VR request display mode: requestDisplay=%d", requestDisplay);
708 mVrFlingerRequestsDisplay = requestDisplay;
709 signalTransaction();
Dominik Laskowski8c001672018-05-30 16:52:06 -0700710 }));
Steven Thomas050b2c82017-03-06 11:45:16 -0800711 };
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700712 mVrFlinger = dvr::VrFlinger::Create(getHwComposer().getComposer(),
713 getHwComposer()
Dominik Laskowski075d3172018-05-24 15:50:06 -0700714 .fromPhysicalDisplayId(*display->getId())
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700715 .value_or(0),
716 vrFlingerRequestDisplayCallback);
Steven Thomas050b2c82017-03-06 11:45:16 -0800717 if (!mVrFlinger) {
718 ALOGE("Failed to start vrflinger");
719 }
720 }
721
Mathias Agopian92a979a2012-08-02 18:32:23 -0700722 // initialize our drawing state
723 mDrawingState = mCurrentState;
Mathias Agopian86303202012-07-24 22:46:10 -0700724
Andy McFadden13a082e2012-08-24 10:16:42 -0700725 // set initial conditions (e.g. unblank default device)
726 initializeDisplays();
727
Steven Thomas137d4bc2019-07-25 16:55:14 -0700728 char primeShaderCache[PROPERTY_VALUE_MAX];
729 property_get("service.sf.prime_shader_cache", primeShaderCache, "1");
730 if (atoi(primeShaderCache)) {
731 getRenderEngine().primeCache();
732 }
Dan Stoza4e637772016-07-28 13:31:51 -0700733
Wei Wangf9b05ee2017-07-19 20:59:39 -0700734 // Inform native graphics APIs whether the present timestamp is supported:
Lloyd Pique90c115d2018-09-18 21:39:42 -0700735
736 const bool presentFenceReliable =
Peiyong Line9d809e2020-04-14 13:10:48 -0700737 !getHwComposer().hasCapability(hal::Capability::PRESENT_FENCE_IS_NOT_RELIABLE);
Lloyd Pique90c115d2018-09-18 21:39:42 -0700738 mStartPropertySetThread = getFactory().createStartPropertySetThread(presentFenceReliable);
Wei Wangf9b05ee2017-07-19 20:59:39 -0700739
740 if (mStartPropertySetThread->Start() != NO_ERROR) {
741 ALOGE("Run StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800742 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800743
Dan Stoza9e56aa02015-11-02 13:00:03 -0800744 ALOGV("Done initializing");
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700745}
746
Romain Guy11d63f42017-07-20 12:47:14 -0700747void SurfaceFlinger::readPersistentProperties() {
Chia-I Wu28f320b2018-05-03 11:02:56 -0700748 Mutex::Autolock _l(mStateLock);
749
Romain Guy11d63f42017-07-20 12:47:14 -0700750 char value[PROPERTY_VALUE_MAX];
751
752 property_get("persist.sys.sf.color_saturation", value, "1.0");
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800753 mGlobalSaturationFactor = atof(value);
Chia-I Wu28f320b2018-05-03 11:02:56 -0700754 updateColorMatrixLocked();
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800755 ALOGV("Saturation is set to %.2f", mGlobalSaturationFactor);
Romain Guy54f154a2017-10-24 21:40:32 +0100756
757 property_get("persist.sys.sf.native_mode", value, "0");
Chia-I Wu0d711262018-05-21 15:19:35 -0700758 mDisplayColorSetting = static_cast<DisplayColorSetting>(atoi(value));
Peiyong Lina3ea5592019-02-10 14:45:00 -0800759
760 property_get("persist.sys.sf.color_mode", value, "0");
761 mForceColorMode = static_cast<ColorMode>(atoi(value));
Lucas Dupin00f16422020-03-11 11:33:04 -0700762
763 property_get("persist.sys.sf.disable_blurs", value, "0");
764 bool disableBlurs = atoi(value);
765 mDisableBlurs = disableBlurs;
766 ALOGI_IF(disableBlurs, "Disabling blur effects, user preference.");
Romain Guy11d63f42017-07-20 12:47:14 -0700767}
768
Mathias Agopiana67e4182012-06-19 17:26:12 -0700769void SurfaceFlinger::startBootAnim() {
Wei Wangb254fa32017-01-31 17:43:23 -0800770 // Start boot animation service by setting a property mailbox
771 // if property setting thread is already running, Start() will be just a NOP
Wei Wangf9b05ee2017-07-19 20:59:39 -0700772 mStartPropertySetThread->Start();
Wei Wangb254fa32017-01-31 17:43:23 -0800773 // Wait until property was set
Wei Wangf9b05ee2017-07-19 20:59:39 -0700774 if (mStartPropertySetThread->join() != NO_ERROR) {
775 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800776 }
Mathias Agopiana67e4182012-06-19 17:26:12 -0700777}
778
Mathias Agopian875d8e12013-06-07 15:35:48 -0700779size_t SurfaceFlinger::getMaxTextureSize() const {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700780 return getRenderEngine().getMaxTextureSize();
Mathias Agopiana4912602012-07-12 14:25:33 -0700781}
782
Mathias Agopian875d8e12013-06-07 15:35:48 -0700783size_t SurfaceFlinger::getMaxViewportDims() const {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700784 return getRenderEngine().getMaxViewportDims();
Mathias Agopiana4912602012-07-12 14:25:33 -0700785}
786
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800787// ----------------------------------------------------------------------------
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800788
Jamie Gennis582270d2011-08-17 18:19:00 -0700789bool SurfaceFlinger::authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800790 const sp<IGraphicBufferProducer>& bufferProducer) const {
Jamie Gennis134f0422011-03-08 12:18:54 -0800791 Mutex::Autolock _l(mStateLock);
Robert Carr0d480722017-01-10 16:42:54 -0800792 return authenticateSurfaceTextureLocked(bufferProducer);
793}
794
795bool SurfaceFlinger::authenticateSurfaceTextureLocked(
796 const sp<IGraphicBufferProducer>& bufferProducer) const {
Marco Nelissen097ca272014-11-14 08:01:01 -0800797 sp<IBinder> surfaceTextureBinder(IInterface::asBinder(bufferProducer));
Dan Stoza101d8dc2018-02-27 15:42:25 -0800798 return mGraphicBufferProducerList.count(surfaceTextureBinder.get()) > 0;
Jamie Gennis134f0422011-03-08 12:18:54 -0800799}
800
Brian Anderson6b376712017-04-04 10:51:39 -0700801status_t SurfaceFlinger::getSupportedFrameTimestamps(
802 std::vector<FrameEvent>* outSupported) const {
803 *outSupported = {
804 FrameEvent::REQUESTED_PRESENT,
805 FrameEvent::ACQUIRE,
806 FrameEvent::LATCH,
807 FrameEvent::FIRST_REFRESH_START,
808 FrameEvent::LAST_REFRESH_START,
809 FrameEvent::GPU_COMPOSITION_DONE,
810 FrameEvent::DEQUEUE_READY,
811 FrameEvent::RELEASE,
812 };
Steven Thomas6d8110b2017-08-31 18:24:21 -0700813 ConditionalLock _l(mStateLock,
814 std::this_thread::get_id() != mMainThreadId);
Peiyong Line9d809e2020-04-14 13:10:48 -0700815 if (!getHwComposer().hasCapability(hal::Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
Brian Anderson6b376712017-04-04 10:51:39 -0700816 outSupported->push_back(FrameEvent::DISPLAY_PRESENT);
817 }
818 return NO_ERROR;
819}
820
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800821status_t SurfaceFlinger::getDisplayState(const sp<IBinder>& displayToken, ui::DisplayState* state) {
822 if (!displayToken || !state) {
823 return BAD_VALUE;
824 }
825
826 Mutex::Autolock lock(mStateLock);
827
828 const auto display = getDisplayDeviceLocked(displayToken);
829 if (!display) {
830 return NAME_NOT_FOUND;
831 }
832
833 state->layerStack = display->getLayerStack();
834 state->orientation = display->getOrientation();
835
836 const Rect viewport = display->getViewport();
837 state->viewport = viewport.isValid() ? viewport.getSize() : display->getSize();
838
839 return NO_ERROR;
840}
841
842status_t SurfaceFlinger::getDisplayInfo(const sp<IBinder>& displayToken, DisplayInfo* info) {
843 if (!displayToken || !info) {
844 return BAD_VALUE;
845 }
846
847 Mutex::Autolock lock(mStateLock);
848
849 const auto display = getDisplayDeviceLocked(displayToken);
850 if (!display) {
851 return NAME_NOT_FOUND;
852 }
853
Dominik Laskowski55c85402020-01-21 16:25:47 -0800854 if (const auto connectionType = display->getConnectionType())
855 info->connectionType = *connectionType;
856 else {
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800857 return INVALID_OPERATION;
858 }
859
860 if (mEmulatedDisplayDensity) {
861 info->density = mEmulatedDisplayDensity;
862 } else {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800863 info->density = info->connectionType == DisplayConnectionType::Internal
864 ? mInternalDisplayDensity
865 : FALLBACK_DENSITY;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800866 }
Dominik Laskowskid125d0e2020-05-08 12:36:39 -0700867 info->density /= ACONFIGURATION_DENSITY_MEDIUM;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800868
869 info->secure = display->isSecure();
Marin Shalamanovf5de90d2019-10-08 10:57:25 +0200870 info->deviceProductInfo = getDeviceProductInfoLocked(*display);
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800871
872 return NO_ERROR;
873}
874
Dominik Laskowski22488f62019-03-28 09:53:04 -0700875status_t SurfaceFlinger::getDisplayConfigs(const sp<IBinder>& displayToken,
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800876 Vector<DisplayConfig>* configs) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700877 if (!displayToken || !configs) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700878 return BAD_VALUE;
879 }
880
Dominik Laskowski22488f62019-03-28 09:53:04 -0700881 Mutex::Autolock lock(mStateLock);
882
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800883 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700884 if (!displayId) {
885 return NAME_NOT_FOUND;
Mathias Agopianc666cae2012-07-25 18:56:13 -0700886 }
Mathias Agopian8b736f12012-08-13 17:54:26 -0700887
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800888 const bool isInternal = (displayId == getInternalDisplayIdLocked());
Mathias Agopian1604f772012-09-18 21:54:42 -0700889
Dan Stoza7f7da322014-05-02 15:26:25 -0700890 configs->clear();
Mathias Agopian1604f772012-09-18 21:54:42 -0700891
Dominik Laskowski075d3172018-05-24 15:50:06 -0700892 for (const auto& hwConfig : getHwComposer().getConfigs(*displayId)) {
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800893 DisplayConfig config;
Dan Stoza7f7da322014-05-02 15:26:25 -0700894
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800895 auto width = hwConfig->getWidth();
896 auto height = hwConfig->getHeight();
Dan Stoza7f7da322014-05-02 15:26:25 -0700897
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800898 auto xDpi = hwConfig->getDpiX();
899 auto yDpi = hwConfig->getDpiY();
Yiwei Zhang27de5df2018-08-23 17:04:51 -0700900
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800901 if (isInternal &&
902 (internalDisplayOrientation == ui::ROTATION_90 ||
903 internalDisplayOrientation == ui::ROTATION_270)) {
904 std::swap(width, height);
905 std::swap(xDpi, yDpi);
Dan Stoza7f7da322014-05-02 15:26:25 -0700906 }
907
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800908 config.resolution = ui::Size(width, height);
Ady Abraham2139f732019-11-13 18:56:40 -0800909
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800910 if (mEmulatedDisplayDensity) {
911 config.xDpi = mEmulatedDisplayDensity;
912 config.yDpi = mEmulatedDisplayDensity;
913 } else {
914 config.xDpi = xDpi;
915 config.yDpi = yDpi;
916 }
917
918 const nsecs_t period = hwConfig->getVsyncPeriod();
919 config.refreshRate = 1e9f / period;
920
921 const auto offsets = mPhaseConfiguration->getOffsetsForRefreshRate(config.refreshRate);
922 config.appVsyncOffset = offsets.late.app;
923 config.sfVsyncOffset = offsets.late.sf;
Ady Abrahamff731d82020-02-18 17:22:46 -0800924 config.configGroup = hwConfig->getConfigGroup();
Dan Stoza9e56aa02015-11-02 13:00:03 -0800925
Andy McFadden91b2ca82014-06-13 14:04:23 -0700926 // This is how far in advance a buffer must be queued for
927 // presentation at a given time. If you want a buffer to appear
928 // on the screen at time N, you must submit the buffer before
929 // (N - presentationDeadline).
930 //
931 // Normally it's one full refresh period (to give SF a chance to
932 // latch the buffer), but this can be reduced by configuring a
933 // DispSync offset. Any additional delays introduced by the hardware
934 // composer or panel must be accounted for here.
935 //
936 // We add an additional 1ms to allow for processing time and
937 // differences between the ideal and actual refresh rate.
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800938 config.presentationDeadline = period - config.sfVsyncOffset + 1000000;
Dan Stoza7f7da322014-05-02 15:26:25 -0700939
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800940 configs->push_back(config);
Mathias Agopian8b736f12012-08-13 17:54:26 -0700941 }
942
Dan Stoza7f7da322014-05-02 15:26:25 -0700943 return NO_ERROR;
944}
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700945
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700946status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>&, DisplayStatInfo* stats) {
947 if (!stats) {
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700948 return BAD_VALUE;
949 }
950
Ana Krulecc2870422019-01-29 19:00:58 -0800951 mScheduler->getDisplayStatInfo(stats);
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700952 return NO_ERROR;
953}
954
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700955int SurfaceFlinger::getActiveConfig(const sp<IBinder>& displayToken) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700956 int activeConfig;
957 bool isPrimary;
958
959 {
960 Mutex::Autolock lock(mStateLock);
961
962 if (const auto display = getDisplayDeviceLocked(displayToken)) {
963 activeConfig = display->getActiveConfig().value();
964 isPrimary = display->isPrimary();
965 } else {
966 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
967 return NAME_NOT_FOUND;
968 }
Jinguang Dong9f8b9ae2016-11-29 13:55:57 +0800969 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700970
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700971 if (isPrimary) {
Dominik Laskowski20134642020-04-20 22:36:44 -0700972 if (const auto config = getDesiredActiveConfig()) {
973 return config->configId.value();
Steven Thomasc9098452019-09-30 17:15:05 -0700974 }
Steven Thomasc9098452019-09-30 17:15:05 -0700975 }
Ady Abraham2139f732019-11-13 18:56:40 -0800976
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700977 return activeConfig;
Dan Stoza7f7da322014-05-02 15:26:25 -0700978}
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700979
Ady Abraham03b02dd2019-03-21 15:40:11 -0700980void SurfaceFlinger::setDesiredActiveConfig(const ActiveConfigInfo& info) {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800981 ATRACE_CALL();
Ady Abraham2e1dd892020-03-05 13:48:36 -0800982 auto& refreshRate = mRefreshRateConfigs->getRefreshRateFromConfigId(info.configId);
Ady Abrahamabc27602020-04-08 17:20:29 -0700983 ALOGV("setDesiredActiveConfig(%s)", refreshRate.getName().c_str());
Ana Krulec7d1d6832018-12-27 11:10:09 -0800984
Ady Abrahamb838aed2019-02-12 15:30:16 -0800985 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Ady Abraham59db0a32020-03-02 18:04:20 -0800986 if (mDesiredActiveConfigChanged) {
987 // If a config change is pending, just cache the latest request in
988 // mDesiredActiveConfig
989 const Scheduler::ConfigEvent prevConfig = mDesiredActiveConfig.event;
990 mDesiredActiveConfig = info;
991 mDesiredActiveConfig.event = mDesiredActiveConfig.event | prevConfig;
992 } else {
993 // Check is we are already at the desired config
994 const auto display = getDefaultDisplayDeviceLocked();
Ady Abrahamabc27602020-04-08 17:20:29 -0700995 if (!display || display->getActiveConfig() == refreshRate.getConfigId()) {
Ady Abraham59db0a32020-03-02 18:04:20 -0800996 return;
997 }
Ady Abrahamb838aed2019-02-12 15:30:16 -0800998
Ady Abraham59db0a32020-03-02 18:04:20 -0800999 // Initiate a config change.
1000 mDesiredActiveConfigChanged = true;
1001 mDesiredActiveConfig = info;
1002
Ady Abrahamb838aed2019-02-12 15:30:16 -08001003 // This will trigger HWC refresh without resetting the idle timer.
1004 repaintEverythingForHWC();
Alec Mouri754c98a2019-03-18 18:53:42 -07001005 // Start receiving vsync samples now, so that we can detect a period
1006 // switch.
Ady Abrahamabc27602020-04-08 17:20:29 -07001007 mScheduler->resyncToHardwareVsync(true, refreshRate.getVsyncPeriod());
Ady Abraham53852a52019-05-28 18:07:44 -07001008 // As we called to set period, we will call to onRefreshRateChangeCompleted once
1009 // DispSync model is locked.
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001010 mVSyncModulator->onRefreshRateChangeInitiated();
Ady Abraham2139f732019-11-13 18:56:40 -08001011
Ady Abrahamabc27602020-04-08 17:20:29 -07001012 mPhaseConfiguration->setRefreshRateFps(refreshRate.getFps());
Ady Abraham9e16a482019-12-03 17:19:41 -08001013 mVSyncModulator->setPhaseOffsets(mPhaseConfiguration->getCurrentOffsets());
Ady Abraham32efd542020-05-19 17:49:26 -07001014 mScheduler->setConfigChangePending(true);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001015 }
Ady Abraham03b02dd2019-03-21 15:40:11 -07001016
1017 if (mRefreshRateOverlay) {
Ady Abraham2139f732019-11-13 18:56:40 -08001018 mRefreshRateOverlay->changeRefreshRate(refreshRate);
Ady Abraham03b02dd2019-03-21 15:40:11 -07001019 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001020}
1021
1022status_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& displayToken, int mode) {
1023 ATRACE_CALL();
Ady Abraham838de062019-02-04 10:24:03 -08001024
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001025 if (!displayToken) {
1026 return BAD_VALUE;
1027 }
Ady Abraham838de062019-02-04 10:24:03 -08001028
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001029 auto future = schedule([=]() -> status_t {
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07001030 const auto display = ON_MAIN_THREAD(getDisplayDeviceLocked(displayToken));
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001031 if (!display) {
1032 ALOGE("Attempt to set allowed display configs for invalid display token %p",
1033 displayToken.get());
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001034 return NAME_NOT_FOUND;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001035 } else if (display->isVirtual()) {
1036 ALOGW("Attempt to set allowed display configs for virtual display");
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001037 return INVALID_OPERATION;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001038 } else {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001039 const HwcConfigIndexType config(mode);
1040 const float fps = mRefreshRateConfigs->getRefreshRateFromConfigId(config).getFps();
Steven Thomasf734df42020-04-13 21:09:28 -07001041 const scheduler::RefreshRateConfigs::Policy policy{config, {fps, fps}};
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001042 constexpr bool kOverridePolicy = false;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001043
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001044 return setDesiredDisplayConfigSpecsInternal(display, policy, kOverridePolicy);
1045 }
1046 });
1047
1048 return future.get();
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001049}
1050
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001051void SurfaceFlinger::setActiveConfigInternal() {
1052 ATRACE_CALL();
1053
Dominik Laskowski22488f62019-03-28 09:53:04 -07001054 const auto display = getDefaultDisplayDeviceLocked();
1055 if (!display) {
1056 return;
1057 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001058
Alec Mouri8de697e2020-03-19 10:52:01 -07001059 auto& oldRefreshRate =
1060 mRefreshRateConfigs->getRefreshRateFromConfigId(display->getActiveConfig());
1061
Dominik Laskowski22488f62019-03-28 09:53:04 -07001062 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Ady Abraham2139f732019-11-13 18:56:40 -08001063 mRefreshRateConfigs->setCurrentConfigId(mUpcomingActiveConfig.configId);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07001064 mRefreshRateStats->setConfigMode(mUpcomingActiveConfig.configId);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001065 display->setActiveConfig(mUpcomingActiveConfig.configId);
1066
Ady Abraham2e1dd892020-03-05 13:48:36 -08001067 auto& refreshRate =
Ady Abraham2139f732019-11-13 18:56:40 -08001068 mRefreshRateConfigs->getRefreshRateFromConfigId(mUpcomingActiveConfig.configId);
Ady Abrahamabc27602020-04-08 17:20:29 -07001069 if (refreshRate.getVsyncPeriod() != oldRefreshRate.getVsyncPeriod()) {
Alec Mouri8de697e2020-03-19 10:52:01 -07001070 mTimeStats->incrementRefreshRateSwitches();
1071 }
Ady Abrahamabc27602020-04-08 17:20:29 -07001072 mPhaseConfiguration->setRefreshRateFps(refreshRate.getFps());
Ady Abraham9e16a482019-12-03 17:19:41 -08001073 mVSyncModulator->setPhaseOffsets(mPhaseConfiguration->getCurrentOffsets());
Ady Abrahamabc27602020-04-08 17:20:29 -07001074 ATRACE_INT("ActiveConfigFPS", refreshRate.getFps());
Dominik Laskowski22488f62019-03-28 09:53:04 -07001075
Ana Krulec8d3e4f32019-03-05 10:40:33 -08001076 if (mUpcomingActiveConfig.event != Scheduler::ConfigEvent::None) {
Alec Mouri60aee1c2019-10-28 16:18:59 -07001077 const nsecs_t vsyncPeriod =
1078 mRefreshRateConfigs->getRefreshRateFromConfigId(mUpcomingActiveConfig.configId)
Ady Abrahamabc27602020-04-08 17:20:29 -07001079 .getVsyncPeriod();
Ady Abrahamdfd62162020-06-10 16:11:56 -07001080 mScheduler->onPrimaryDisplayConfigChanged(mAppConnectionHandle, display->getId()->value,
1081 mUpcomingActiveConfig.configId, vsyncPeriod);
Ady Abraham447052e2019-02-13 16:07:27 -08001082 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001083}
1084
Ady Abraham53852a52019-05-28 18:07:44 -07001085void SurfaceFlinger::desiredActiveConfigChangeDone() {
1086 std::lock_guard<std::mutex> lock(mActiveConfigLock);
1087 mDesiredActiveConfig.event = Scheduler::ConfigEvent::None;
1088 mDesiredActiveConfigChanged = false;
Ady Abraham53852a52019-05-28 18:07:44 -07001089
Ady Abraham2e1dd892020-03-05 13:48:36 -08001090 const auto& refreshRate =
Ady Abraham2139f732019-11-13 18:56:40 -08001091 mRefreshRateConfigs->getRefreshRateFromConfigId(mDesiredActiveConfig.configId);
Ady Abrahamabc27602020-04-08 17:20:29 -07001092 mScheduler->resyncToHardwareVsync(true, refreshRate.getVsyncPeriod());
1093 mPhaseConfiguration->setRefreshRateFps(refreshRate.getFps());
Ady Abraham9e16a482019-12-03 17:19:41 -08001094 mVSyncModulator->setPhaseOffsets(mPhaseConfiguration->getCurrentOffsets());
Ady Abraham32efd542020-05-19 17:49:26 -07001095 mScheduler->setConfigChangePending(false);
Ady Abraham53852a52019-05-28 18:07:44 -07001096}
1097
Ady Abraham27cbed72020-04-10 12:56:59 -07001098void SurfaceFlinger::performSetActiveConfig() {
Alec Mourife3dc942019-02-12 14:19:18 -08001099 ATRACE_CALL();
Ady Abraham2139f732019-11-13 18:56:40 -08001100 ALOGV("performSetActiveConfig");
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001101 // Store the local variable to release the lock.
Dominik Laskowski20134642020-04-20 22:36:44 -07001102 const auto desiredActiveConfig = getDesiredActiveConfig();
Ady Abraham27cbed72020-04-10 12:56:59 -07001103 if (!desiredActiveConfig) {
1104 // No desired active config pending to be applied
1105 return;
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001106 }
1107
Ady Abraham2e1dd892020-03-05 13:48:36 -08001108 auto& refreshRate =
Ady Abraham27cbed72020-04-10 12:56:59 -07001109 mRefreshRateConfigs->getRefreshRateFromConfigId(desiredActiveConfig->configId);
Ady Abrahamabc27602020-04-08 17:20:29 -07001110 ALOGV("performSetActiveConfig changing active config to %d(%s)",
1111 refreshRate.getConfigId().value(), refreshRate.getName().c_str());
Dominik Laskowski22488f62019-03-28 09:53:04 -07001112 const auto display = getDefaultDisplayDeviceLocked();
Ady Abraham27cbed72020-04-10 12:56:59 -07001113 if (!display || display->getActiveConfig() == desiredActiveConfig->configId) {
Ady Abrahamb838aed2019-02-12 15:30:16 -08001114 // display is not valid or we are already in the requested mode
1115 // on both cases there is nothing left to do
Ady Abraham53852a52019-05-28 18:07:44 -07001116 desiredActiveConfigChangeDone();
Ady Abraham27cbed72020-04-10 12:56:59 -07001117 return;
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001118 }
Ady Abrahamb838aed2019-02-12 15:30:16 -08001119
Ady Abraham838de062019-02-04 10:24:03 -08001120 // Desired active config was set, it is different than the config currently in use, however
1121 // allowed configs might have change by the time we process the refresh.
1122 // Make sure the desired config is still allowed
Ady Abraham27cbed72020-04-10 12:56:59 -07001123 if (!isDisplayConfigAllowed(desiredActiveConfig->configId)) {
Ady Abraham53852a52019-05-28 18:07:44 -07001124 desiredActiveConfigChangeDone();
Ady Abraham27cbed72020-04-10 12:56:59 -07001125 return;
Ady Abraham838de062019-02-04 10:24:03 -08001126 }
Alec Mouri7f015182019-07-11 13:56:22 -07001127
Ady Abraham27cbed72020-04-10 12:56:59 -07001128 mUpcomingActiveConfig = *desiredActiveConfig;
Ady Abrahamb838aed2019-02-12 15:30:16 -08001129 const auto displayId = display->getId();
1130 LOG_ALWAYS_FATAL_IF(!displayId);
1131
Ady Abrahamabc27602020-04-08 17:20:29 -07001132 ATRACE_INT("ActiveConfigFPS_HWC", refreshRate.getFps());
Ady Abrahamb838aed2019-02-12 15:30:16 -08001133
Ady Abraham3a77a7b2019-12-02 18:46:59 -08001134 // TODO(b/142753666) use constrains
Peiyong Line9d809e2020-04-14 13:10:48 -07001135 hal::VsyncPeriodChangeConstraints constraints;
Ady Abraham3a77a7b2019-12-02 18:46:59 -08001136 constraints.desiredTimeNanos = systemTime();
1137 constraints.seamlessRequired = false;
1138
Peiyong Line9d809e2020-04-14 13:10:48 -07001139 hal::VsyncPeriodChangeTimeline outTimeline;
Ady Abraham3a77a7b2019-12-02 18:46:59 -08001140 auto status =
1141 getHwComposer().setActiveConfigWithConstraints(*displayId,
1142 mUpcomingActiveConfig.configId.value(),
1143 constraints, &outTimeline);
1144 if (status != NO_ERROR) {
Ady Abraham5e95aa22020-03-04 10:26:05 -08001145 // setActiveConfigWithConstraints may fail if a hotplug event is just about
1146 // to be sent. We just log the error in this case.
1147 ALOGW("setActiveConfigWithConstraints failed: %d", status);
Ady Abraham27cbed72020-04-10 12:56:59 -07001148 return;
Ady Abraham3a77a7b2019-12-02 18:46:59 -08001149 }
1150
1151 mScheduler->onNewVsyncPeriodChangeTimeline(outTimeline);
1152 // Scheduler will submit an empty frame to HWC if needed.
Ady Abraham27cbed72020-04-10 12:56:59 -07001153 mSetActiveConfigPending = true;
Mathias Agopianc666cae2012-07-25 18:56:13 -07001154}
Dominik Laskowski075d3172018-05-24 15:50:06 -07001155
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001156status_t SurfaceFlinger::getDisplayColorModes(const sp<IBinder>& displayToken,
1157 Vector<ColorMode>* outColorModes) {
1158 if (!displayToken || !outColorModes) {
Michael Wright28f24d02016-07-12 13:30:53 -07001159 return BAD_VALUE;
1160 }
1161
Peiyong Lina52f0292018-03-14 17:26:31 -07001162 std::vector<ColorMode> modes;
Peiyong Linff84a152019-05-17 18:36:19 -07001163 bool isInternalDisplay = false;
Steven Thomas6d8110b2017-08-31 18:24:21 -07001164 {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001165 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
1166
1167 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1168 if (!displayId) {
1169 return NAME_NOT_FOUND;
1170 }
1171
Dominik Laskowski075d3172018-05-24 15:50:06 -07001172 modes = getHwComposer().getColorModes(*displayId);
Peiyong Linff84a152019-05-17 18:36:19 -07001173 isInternalDisplay = displayId == getInternalDisplayIdLocked();
Steven Thomas6d8110b2017-08-31 18:24:21 -07001174 }
Michael Wright28f24d02016-07-12 13:30:53 -07001175 outColorModes->clear();
Peiyong Linff84a152019-05-17 18:36:19 -07001176
1177 // If it's built-in display and the configuration claims it's not wide color capable,
1178 // filter out all wide color modes. The typical reason why this happens is that the
1179 // hardware is not good enough to support GPU composition of wide color, and thus the
1180 // OEMs choose to disable this capability.
1181 if (isInternalDisplay && !hasWideColorDisplay) {
1182 std::remove_copy_if(modes.cbegin(), modes.cend(), std::back_inserter(*outColorModes),
1183 isWideColorMode);
1184 } else {
1185 std::copy(modes.cbegin(), modes.cend(), std::back_inserter(*outColorModes));
1186 }
Michael Wright28f24d02016-07-12 13:30:53 -07001187
1188 return NO_ERROR;
1189}
1190
Daniel Solomon42d04562019-01-20 21:03:19 -08001191status_t SurfaceFlinger::getDisplayNativePrimaries(const sp<IBinder>& displayToken,
1192 ui::DisplayPrimaries &primaries) {
1193 if (!displayToken) {
1194 return BAD_VALUE;
1195 }
1196
1197 // Currently we only support this API for a single internal display.
1198 if (getInternalDisplayToken() != displayToken) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001199 return NAME_NOT_FOUND;
Daniel Solomon42d04562019-01-20 21:03:19 -08001200 }
1201
1202 memcpy(&primaries, &mInternalDisplayPrimaries, sizeof(ui::DisplayPrimaries));
1203 return NO_ERROR;
1204}
1205
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001206ColorMode SurfaceFlinger::getActiveColorMode(const sp<IBinder>& displayToken) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001207 Mutex::Autolock lock(mStateLock);
1208
1209 if (const auto display = getDisplayDeviceLocked(displayToken)) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07001210 return display->getCompositionDisplay()->getState().colorMode;
Michael Wright28f24d02016-07-12 13:30:53 -07001211 }
Peiyong Lina52f0292018-03-14 17:26:31 -07001212 return static_cast<ColorMode>(BAD_VALUE);
Michael Wright28f24d02016-07-12 13:30:53 -07001213}
1214
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001215status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& displayToken, ColorMode mode) {
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07001216 schedule([=]() MAIN_THREAD {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001217 Vector<ColorMode> modes;
1218 getDisplayColorModes(displayToken, &modes);
1219 bool exists = std::find(std::begin(modes), std::end(modes), mode) != std::end(modes);
1220 if (mode < ColorMode::NATIVE || !exists) {
1221 ALOGE("Attempt to set invalid active color mode %s (%d) for display token %p",
1222 decodeColorMode(mode).c_str(), mode, displayToken.get());
1223 return;
Michael Wright28f24d02016-07-12 13:30:53 -07001224 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001225 const auto display = getDisplayDeviceLocked(displayToken);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001226 if (!display) {
1227 ALOGE("Attempt to set active color mode %s (%d) for invalid display token %p",
1228 decodeColorMode(mode).c_str(), mode, displayToken.get());
1229 } else if (display->isVirtual()) {
1230 ALOGW("Attempt to set active color mode %s (%d) for virtual display",
1231 decodeColorMode(mode).c_str(), mode);
1232 } else {
Lloyd Pique6a3b4462019-03-07 20:58:12 -08001233 display->getCompositionDisplay()->setColorProfile(
1234 compositionengine::Output::ColorProfile{mode, Dataspace::UNKNOWN,
1235 RenderIntent::COLORIMETRIC,
1236 Dataspace::UNKNOWN});
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001237 }
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001238 }).wait();
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001239
Michael Wright28f24d02016-07-12 13:30:53 -07001240 return NO_ERROR;
1241}
Mathias Agopianc666cae2012-07-25 18:56:13 -07001242
Galia Peycheva5492cb52019-10-30 14:13:16 +01001243status_t SurfaceFlinger::getAutoLowLatencyModeSupport(const sp<IBinder>& displayToken,
1244 bool* outSupport) const {
Galia Peycheva5492cb52019-10-30 14:13:16 +01001245 if (!displayToken) {
Galia Peycheva5492cb52019-10-30 14:13:16 +01001246 return BAD_VALUE;
1247 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001248
1249 Mutex::Autolock lock(mStateLock);
1250
Galia Peycheva5492cb52019-10-30 14:13:16 +01001251 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1252 if (!displayId) {
Galia Peycheva5492cb52019-10-30 14:13:16 +01001253 return NAME_NOT_FOUND;
1254 }
Peiyong Line9d809e2020-04-14 13:10:48 -07001255 *outSupport =
1256 getHwComposer().hasDisplayCapability(*displayId,
1257 hal::DisplayCapability::AUTO_LOW_LATENCY_MODE);
Galia Peycheva5492cb52019-10-30 14:13:16 +01001258 return NO_ERROR;
1259}
1260
1261void SurfaceFlinger::setAutoLowLatencyMode(const sp<IBinder>& displayToken, bool on) {
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07001262 static_cast<void>(schedule([=]() MAIN_THREAD {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001263 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
1264 getHwComposer().setAutoLowLatencyMode(*displayId, on);
1265 } else {
1266 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
1267 }
1268 }));
Galia Peycheva5492cb52019-10-30 14:13:16 +01001269}
1270
1271status_t SurfaceFlinger::getGameContentTypeSupport(const sp<IBinder>& displayToken,
1272 bool* outSupport) const {
Galia Peycheva5492cb52019-10-30 14:13:16 +01001273 if (!displayToken) {
Galia Peycheva5492cb52019-10-30 14:13:16 +01001274 return BAD_VALUE;
1275 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001276
1277 Mutex::Autolock lock(mStateLock);
1278
Galia Peycheva5492cb52019-10-30 14:13:16 +01001279 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1280 if (!displayId) {
Galia Peycheva5492cb52019-10-30 14:13:16 +01001281 return NAME_NOT_FOUND;
1282 }
1283
Peiyong Line9d809e2020-04-14 13:10:48 -07001284 std::vector<hal::ContentType> types;
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001285 getHwComposer().getSupportedContentTypes(*displayId, &types);
1286
1287 *outSupport = std::any_of(types.begin(), types.end(),
Peiyong Line9d809e2020-04-14 13:10:48 -07001288 [](auto type) { return type == hal::ContentType::GAME; });
Galia Peycheva5492cb52019-10-30 14:13:16 +01001289 return NO_ERROR;
1290}
1291
1292void SurfaceFlinger::setGameContentType(const sp<IBinder>& displayToken, bool on) {
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07001293 static_cast<void>(schedule([=]() MAIN_THREAD {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001294 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
Peiyong Line9d809e2020-04-14 13:10:48 -07001295 const auto type = on ? hal::ContentType::GAME : hal::ContentType::NONE;
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001296 getHwComposer().setContentType(*displayId, type);
1297 } else {
1298 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
1299 }
1300 }));
Galia Peycheva5492cb52019-10-30 14:13:16 +01001301}
1302
Svetoslavd85084b2014-03-20 10:28:31 -07001303status_t SurfaceFlinger::clearAnimationFrameStats() {
1304 Mutex::Autolock _l(mStateLock);
1305 mAnimFrameTracker.clearStats();
1306 return NO_ERROR;
1307}
1308
1309status_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const {
1310 Mutex::Autolock _l(mStateLock);
1311 mAnimFrameTracker.getStats(outStats);
1312 return NO_ERROR;
1313}
1314
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001315status_t SurfaceFlinger::getHdrCapabilities(const sp<IBinder>& displayToken,
1316 HdrCapabilities* outCapabilities) const {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001317 Mutex::Autolock lock(mStateLock);
Dan Stozac4f471e2016-03-24 09:31:08 -07001318
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001319 const auto display = getDisplayDeviceLocked(displayToken);
1320 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001321 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
1322 return NAME_NOT_FOUND;
Dan Stozac4f471e2016-03-24 09:31:08 -07001323 }
1324
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001325 // At this point the DisplayDevice should already be set up,
Peiyong Linfb069302018-04-25 14:34:31 -07001326 // meaning the luminance information is already queried from
1327 // hardware composer and stored properly.
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001328 const HdrCapabilities& capabilities = display->getHdrCapabilities();
Peiyong Linfb069302018-04-25 14:34:31 -07001329 *outCapabilities = HdrCapabilities(capabilities.getSupportedHdrTypes(),
1330 capabilities.getDesiredMaxLuminance(),
1331 capabilities.getDesiredMaxAverageLuminance(),
1332 capabilities.getDesiredMinLuminance());
Dan Stozac4f471e2016-03-24 09:31:08 -07001333
1334 return NO_ERROR;
1335}
1336
Marin Shalamanovf5de90d2019-10-08 10:57:25 +02001337std::optional<DeviceProductInfo> SurfaceFlinger::getDeviceProductInfoLocked(
1338 const DisplayDevice& display) const {
1339 // TODO(b/149075047): Populate DeviceProductInfo on hotplug and store it in DisplayDevice to
1340 // avoid repetitive HAL IPC and EDID parsing.
1341 const auto displayId = display.getId();
1342 LOG_FATAL_IF(!displayId);
1343
1344 const auto hwcDisplayId = getHwComposer().fromPhysicalDisplayId(*displayId);
1345 LOG_FATAL_IF(!hwcDisplayId);
1346
1347 uint8_t port;
1348 DisplayIdentificationData data;
1349 if (!getHwComposer().getDisplayIdentificationData(*hwcDisplayId, &port, &data)) {
1350 ALOGV("%s: No identification data.", __FUNCTION__);
1351 return {};
1352 }
1353
1354 const auto info = parseDisplayIdentificationData(port, data);
1355 if (!info) {
1356 return {};
1357 }
1358 return info->deviceProductInfo;
1359}
1360
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001361status_t SurfaceFlinger::getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
1362 ui::PixelFormat* outFormat,
1363 ui::Dataspace* outDataspace,
1364 uint8_t* outComponentMask) const {
1365 if (!outFormat || !outDataspace || !outComponentMask) {
1366 return BAD_VALUE;
1367 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001368
1369 Mutex::Autolock lock(mStateLock);
1370
1371 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1372 if (!displayId) {
1373 return NAME_NOT_FOUND;
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001374 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001375
1376 return getHwComposer().getDisplayedContentSamplingAttributes(*displayId, outFormat,
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001377 outDataspace, outComponentMask);
1378}
1379
Kevin DuBois74e53772018-11-19 10:52:38 -08001380status_t SurfaceFlinger::setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken,
1381 bool enable, uint8_t componentMask,
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001382 uint64_t maxFrames) {
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07001383 return schedule([=]() MAIN_THREAD -> status_t {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001384 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
1385 return getHwComposer().setDisplayContentSamplingEnabled(*displayId, enable,
1386 componentMask,
1387 maxFrames);
1388 } else {
1389 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
1390 return NAME_NOT_FOUND;
1391 }
1392 })
1393 .get();
Kevin DuBois74e53772018-11-19 10:52:38 -08001394}
1395
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001396status_t SurfaceFlinger::getDisplayedContentSample(const sp<IBinder>& displayToken,
1397 uint64_t maxFrames, uint64_t timestamp,
1398 DisplayedFrameStats* outStats) const {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001399 Mutex::Autolock lock(mStateLock);
1400
1401 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1402 if (!displayId) {
1403 return NAME_NOT_FOUND;
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001404 }
1405
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001406 return getHwComposer().getDisplayedContentSample(*displayId, maxFrames, timestamp, outStats);
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001407}
1408
Peiyong Lin3c2791e2019-01-14 17:05:18 -08001409status_t SurfaceFlinger::getProtectedContentSupport(bool* outSupported) const {
1410 if (!outSupported) {
1411 return BAD_VALUE;
1412 }
1413 *outSupported = getRenderEngine().supportsProtectedContent();
1414 return NO_ERROR;
1415}
1416
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001417status_t SurfaceFlinger::isWideColorDisplay(const sp<IBinder>& displayToken,
1418 bool* outIsWideColorDisplay) const {
1419 if (!displayToken || !outIsWideColorDisplay) {
1420 return BAD_VALUE;
1421 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001422
1423 Mutex::Autolock lock(mStateLock);
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001424 const auto display = getDisplayDeviceLocked(displayToken);
1425 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001426 return NAME_NOT_FOUND;
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001427 }
Peiyong Linff84a152019-05-17 18:36:19 -07001428
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001429 *outIsWideColorDisplay =
1430 display->isPrimary() ? hasWideColorDisplay : display->hasWideColorGamut();
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001431 return NO_ERROR;
1432}
1433
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001434status_t SurfaceFlinger::enableVSyncInjections(bool enable) {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001435 schedule([=] {
Dominik Laskowski6505f792019-09-18 11:10:05 -07001436 Mutex::Autolock lock(mStateLock);
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001437
Dominik Laskowski6505f792019-09-18 11:10:05 -07001438 if (const auto handle = mScheduler->enableVSyncInjection(enable)) {
1439 mEventQueue->setEventConnection(
1440 mScheduler->getEventConnection(enable ? handle : mSfConnectionHandle));
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001441 }
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001442 }).wait();
Dominik Laskowski8c001672018-05-30 16:52:06 -07001443
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001444 return NO_ERROR;
1445}
1446
1447status_t SurfaceFlinger::injectVSync(nsecs_t when) {
Dominik Laskowski6505f792019-09-18 11:10:05 -07001448 Mutex::Autolock lock(mStateLock);
Ady Abraham5facfb12020-04-22 15:18:31 -07001449 return mScheduler->injectVSync(when, calculateExpectedPresentTime(when)) ? NO_ERROR : BAD_VALUE;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001450}
1451
Vishnu Nair43bccf82020-06-05 10:53:37 -07001452status_t SurfaceFlinger::getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) {
Kalle Raitaa099a242017-01-11 11:17:29 -08001453 outLayers->clear();
Vishnu Nair43bccf82020-06-05 10:53:37 -07001454 schedule([=] {
1455 const auto display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked());
1456 mDrawingState.traverseInZOrder([&](Layer* layer) {
1457 outLayers->push_back(layer->getLayerDebugInfo(display.get()));
1458 });
1459 }).wait();
Kalle Raitaa099a242017-01-11 11:17:29 -08001460 return NO_ERROR;
1461}
1462
Peiyong Linc6780972018-10-28 15:24:08 -07001463status_t SurfaceFlinger::getCompositionPreference(
1464 Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
1465 Dataspace* outWideColorGamutDataspace,
1466 ui::PixelFormat* outWideColorGamutPixelFormat) const {
Peiyong Lin9d846a52018-11-05 13:18:20 -08001467 *outDataspace = mDefaultCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001468 *outPixelFormat = defaultCompositionPixelFormat;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001469 *outWideColorGamutDataspace = mWideColorGamutCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001470 *outWideColorGamutPixelFormat = wideColorGamutCompositionPixelFormat;
Peiyong Lin0256f722018-08-31 15:45:10 -07001471 return NO_ERROR;
1472}
1473
Dan Stozaec460082018-12-17 15:35:09 -08001474status_t SurfaceFlinger::addRegionSamplingListener(const Rect& samplingArea,
1475 const sp<IBinder>& stopLayerHandle,
1476 const sp<IRegionSamplingListener>& listener) {
tangrobinaf45f012019-02-26 18:10:10 +08001477 if (!listener || samplingArea == Rect::INVALID_RECT) {
Dan Stozaec460082018-12-17 15:35:09 -08001478 return BAD_VALUE;
1479 }
Alec Mouri9a02eda2020-04-21 17:39:34 -07001480
1481 const wp<Layer> stopLayer = fromHandle(stopLayerHandle);
1482 mRegionSamplingThread->addListener(samplingArea, stopLayer, listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001483 return NO_ERROR;
1484}
1485
Dan Stozaec460082018-12-17 15:35:09 -08001486status_t SurfaceFlinger::removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) {
tangrobinaf45f012019-02-26 18:10:10 +08001487 if (!listener) {
1488 return BAD_VALUE;
1489 }
Dan Stozaec460082018-12-17 15:35:09 -08001490 mRegionSamplingThread->removeListener(listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001491 return NO_ERROR;
1492}
Dan Gittik57e63c52019-01-18 16:37:54 +00001493
1494status_t SurfaceFlinger::getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
1495 bool* outSupport) const {
1496 if (!displayToken || !outSupport) {
1497 return BAD_VALUE;
1498 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001499
1500 Mutex::Autolock lock(mStateLock);
1501
Dan Gittik57e63c52019-01-18 16:37:54 +00001502 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1503 if (!displayId) {
1504 return NAME_NOT_FOUND;
1505 }
1506 *outSupport =
Peiyong Line9d809e2020-04-14 13:10:48 -07001507 getHwComposer().hasDisplayCapability(*displayId, hal::DisplayCapability::BRIGHTNESS);
Dan Gittik57e63c52019-01-18 16:37:54 +00001508 return NO_ERROR;
1509}
1510
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001511status_t SurfaceFlinger::setDisplayBrightness(const sp<IBinder>& displayToken, float brightness) {
Dan Gittik57e63c52019-01-18 16:37:54 +00001512 if (!displayToken) {
1513 return BAD_VALUE;
1514 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001515
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07001516 return promise::chain(schedule([=]() MAIN_THREAD {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001517 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
1518 return getHwComposer().setDisplayBrightness(*displayId, brightness);
1519 } else {
1520 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
Dominik Laskowski5690bde2020-04-23 19:04:22 -07001521 return promise::yield<status_t>(NAME_NOT_FOUND);
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001522 }
Dominik Laskowski5690bde2020-04-23 19:04:22 -07001523 }))
1524 .then([](std::future<status_t> task) { return task; })
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001525 .get();
Dan Gittik57e63c52019-01-18 16:37:54 +00001526}
1527
Ady Abraham8532d012019-05-08 14:50:56 -07001528status_t SurfaceFlinger::notifyPowerHint(int32_t hintId) {
1529 PowerHint powerHint = static_cast<PowerHint>(hintId);
1530
1531 if (powerHint == PowerHint::INTERACTION) {
1532 mScheduler->notifyTouchEvent();
1533 }
1534
1535 return NO_ERROR;
1536}
1537
Mathias Agopiand0566bc2011-11-17 17:49:17 -08001538// ----------------------------------------------------------------------------
1539
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -07001540sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection(
Ady Abraham0f4a1b12019-06-04 16:04:04 -07001541 ISurfaceComposer::VsyncSource vsyncSource, ISurfaceComposer::ConfigChanged configChanged) {
Ana Krulecc2870422019-01-29 19:00:58 -08001542 const auto& handle =
1543 vsyncSource == eVsyncSourceSurfaceFlinger ? mSfConnectionHandle : mAppConnectionHandle;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001544
Steven Thomas2bbaabe2019-08-28 16:08:35 -07001545 return mScheduler->createDisplayEventConnection(handle, configChanged);
Mathias Agopianbb641242010-05-18 17:06:55 -07001546}
1547
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001548void SurfaceFlinger::signalTransaction() {
Ady Abraham8532d012019-05-08 14:50:56 -07001549 mScheduler->resetIdleTimer();
Dan Stoza030fbc12020-02-19 15:32:01 -08001550 mPowerAdvisor.notifyDisplayUpdateImminent();
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001551 mEventQueue->invalidate();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001552}
1553
1554void SurfaceFlinger::signalLayerUpdate() {
Ady Abraham8532d012019-05-08 14:50:56 -07001555 mScheduler->resetIdleTimer();
Dan Stoza030fbc12020-02-19 15:32:01 -08001556 mPowerAdvisor.notifyDisplayUpdateImminent();
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001557 mEventQueue->invalidate();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001558}
1559
1560void SurfaceFlinger::signalRefresh() {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07001561 mRefreshPending = true;
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001562 mEventQueue->refresh();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001563}
1564
Dominik Laskowski83b88212018-12-11 13:34:06 -08001565nsecs_t SurfaceFlinger::getVsyncPeriod() const {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001566 const auto displayId = getInternalDisplayIdLocked();
Dominik Laskowski83b88212018-12-11 13:34:06 -08001567 if (!displayId || !getHwComposer().isConnected(*displayId)) {
1568 return 0;
1569 }
1570
Ady Abraham3a77a7b2019-12-02 18:46:59 -08001571 return getHwComposer().getDisplayVsyncPeriod(*displayId);
Dominik Laskowski83b88212018-12-11 13:34:06 -08001572}
1573
Peiyong Line9d809e2020-04-14 13:10:48 -07001574void SurfaceFlinger::onVsyncReceived(int32_t sequenceId, hal::HWDisplayId hwcDisplayId,
Ady Abraham7159f572019-10-11 11:10:18 -07001575 int64_t timestamp,
Peiyong Line9d809e2020-04-14 13:10:48 -07001576 std::optional<hal::VsyncPeriodNanos> vsyncPeriod) {
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001577 ATRACE_NAME("SF onVsync");
1578
Steven Thomas3cfac282017-02-06 12:29:30 -08001579 Mutex::Autolock lock(mStateLock);
Steven Thomasb02664d2017-07-26 18:48:28 -07001580 // Ignore any vsyncs from a previous hardware composer.
David Sodman105b7dc2017-11-04 20:28:14 -07001581 if (sequenceId != getBE().mComposerSequenceId) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001582 return;
1583 }
1584
Dominik Laskowski075d3172018-05-24 15:50:06 -07001585 if (!getHwComposer().onVsync(hwcDisplayId, timestamp)) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001586 return;
1587 }
1588
Dominik Laskowski075d3172018-05-24 15:50:06 -07001589 if (hwcDisplayId != getHwComposer().getInternalHwcDisplayId()) {
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001590 // For now, we don't do anything with external display vsyncs.
1591 return;
1592 }
1593
Alec Mourif8e689c2019-05-20 18:32:22 -07001594 bool periodFlushed = false;
Ady Abraham5dee2f12020-02-05 17:49:47 -08001595 mScheduler->addResyncSample(timestamp, vsyncPeriod, &periodFlushed);
Alec Mourif8e689c2019-05-20 18:32:22 -07001596 if (periodFlushed) {
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001597 mVSyncModulator->onRefreshRateChangeCompleted();
Alec Mouri754c98a2019-03-18 18:53:42 -07001598 }
Mathias Agopian148994e2012-09-19 17:31:36 -07001599}
1600
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001601void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
David Sodman99974d22017-11-28 12:04:33 -08001602 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
1603 *compositorTiming = getBE().mCompositorTiming;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001604}
1605
Ady Abraham2139f732019-11-13 18:56:40 -08001606bool SurfaceFlinger::isDisplayConfigAllowed(HwcConfigIndexType configId) const {
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001607 return mRefreshRateConfigs->isConfigAllowed(configId);
Ady Abraham838de062019-02-04 10:24:03 -08001608}
1609
Ady Abraham2139f732019-11-13 18:56:40 -08001610void SurfaceFlinger::changeRefreshRateLocked(const RefreshRate& refreshRate,
1611 Scheduler::ConfigEvent event) {
Dominik Laskowski22488f62019-03-28 09:53:04 -07001612 const auto display = getDefaultDisplayDeviceLocked();
1613 if (!display || mBootStage != BootStage::FINISHED) {
Ana Krulec7d1d6832018-12-27 11:10:09 -08001614 return;
1615 }
Alec Mouri1c9e82b2019-03-07 12:24:05 -08001616 ATRACE_CALL();
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001617
Ana Krulec7d1d6832018-12-27 11:10:09 -08001618 // Don't do any updating if the current fps is the same as the new one.
Ady Abrahamabc27602020-04-08 17:20:29 -07001619 if (!isDisplayConfigAllowed(refreshRate.getConfigId())) {
Ady Abraham2139f732019-11-13 18:56:40 -08001620 ALOGV("Skipping config %d as it is not part of allowed configs",
Ady Abrahamabc27602020-04-08 17:20:29 -07001621 refreshRate.getConfigId().value());
Ady Abraham1902d072019-03-01 17:18:59 -08001622 return;
1623 }
1624
Ady Abrahamabc27602020-04-08 17:20:29 -07001625 setDesiredActiveConfig({refreshRate.getConfigId(), event});
Ana Krulec7d1d6832018-12-27 11:10:09 -08001626}
1627
Peiyong Line9d809e2020-04-14 13:10:48 -07001628void SurfaceFlinger::onHotplugReceived(int32_t sequenceId, hal::HWDisplayId hwcDisplayId,
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07001629 hal::Connection connection) {
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001630 ALOGV("%s(%d, %" PRIu64 ", %s)", __FUNCTION__, sequenceId, hwcDisplayId,
Peiyong Line9d809e2020-04-14 13:10:48 -07001631 connection == hal::Connection::CONNECTED ? "connected" : "disconnected");
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001632
Lloyd Piqueba04e622017-12-14 17:11:26 -08001633 // Ignore events that do not have the right sequenceId.
1634 if (sequenceId != getBE().mComposerSequenceId) {
1635 return;
1636 }
1637
Steven Thomasb02664d2017-07-26 18:48:28 -07001638 // Only lock if we're not on the main thread. This function is normally
1639 // called on a hwbinder thread, but for the primary display it's called on
1640 // the main thread with the state lock already held, so don't attempt to
1641 // acquire it here.
Lloyd Piqueba04e622017-12-14 17:11:26 -08001642 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
Steven Thomasb02664d2017-07-26 18:48:28 -07001643
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001644 mPendingHotplugEvents.emplace_back(HotplugEvent{hwcDisplayId, connection});
Mathias Agopian9e2463e2012-09-21 18:26:16 -07001645
Jiwen 'Steve' Caiccfd6822018-02-21 16:15:58 -08001646 if (std::this_thread::get_id() == mMainThreadId) {
1647 // Process all pending hot plug events immediately if we are on the main thread.
1648 processDisplayHotplugEventsLocked();
1649 }
1650
Lloyd Piqueba04e622017-12-14 17:11:26 -08001651 setTransactionFlags(eDisplayTransactionNeeded);
Mathias Agopian86303202012-07-24 22:46:10 -07001652}
1653
Ady Abraham7159f572019-10-11 11:10:18 -07001654void SurfaceFlinger::onVsyncPeriodTimingChangedReceived(
Peiyong Line9d809e2020-04-14 13:10:48 -07001655 int32_t sequenceId, hal::HWDisplayId /*display*/,
1656 const hal::VsyncPeriodChangeTimeline& updatedTimeline) {
Ady Abraham3a77a7b2019-12-02 18:46:59 -08001657 Mutex::Autolock lock(mStateLock);
1658 if (sequenceId != getBE().mComposerSequenceId) {
1659 return;
1660 }
1661 mScheduler->onNewVsyncPeriodChangeTimeline(updatedTimeline);
Ady Abraham7159f572019-10-11 11:10:18 -07001662}
1663
Peiyong Line9d809e2020-04-14 13:10:48 -07001664void SurfaceFlinger::onSeamlessPossible(int32_t /*sequenceId*/, hal::HWDisplayId /*display*/) {
Ady Abrahamb0433bc2020-01-08 17:31:06 -08001665 // TODO(b/142753666): use constraints when calling to setActiveConfigWithConstrains and
1666 // use this callback to know when to retry in case of SEAMLESS_NOT_POSSIBLE.
1667}
1668
Peiyong Line9d809e2020-04-14 13:10:48 -07001669void SurfaceFlinger::onRefreshReceived(int sequenceId, hal::HWDisplayId /*hwcDisplayId*/) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001670 Mutex::Autolock lock(mStateLock);
David Sodman105b7dc2017-11-04 20:28:14 -07001671 if (sequenceId != getBE().mComposerSequenceId) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001672 return;
Steven Thomas3cfac282017-02-06 12:29:30 -08001673 }
Ana Krulec7d1d6832018-12-27 11:10:09 -08001674 repaintEverythingForHWC();
Steven Thomas3cfac282017-02-06 12:29:30 -08001675}
1676
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001677void SurfaceFlinger::setPrimaryVsyncEnabled(bool enabled) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001678 ATRACE_CALL();
Ady Abraham9ba25122019-06-03 17:10:55 -07001679
1680 // Enable / Disable HWVsync from the main thread to avoid race conditions with
1681 // display power state.
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07001682 static_cast<void>(schedule([=]() MAIN_THREAD { setPrimaryVsyncEnabledInternal(enabled); }));
Ady Abraham9ba25122019-06-03 17:10:55 -07001683}
1684
1685void SurfaceFlinger::setPrimaryVsyncEnabledInternal(bool enabled) {
1686 ATRACE_CALL();
1687
Peiyong Line9d809e2020-04-14 13:10:48 -07001688 mHWCVsyncPendingState = enabled ? hal::Vsync::ENABLE : hal::Vsync::DISABLE;
Ady Abraham27c70212019-06-11 10:52:26 -07001689
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001690 if (const auto displayId = getInternalDisplayIdLocked()) {
Ady Abraham9ba25122019-06-03 17:10:55 -07001691 sp<DisplayDevice> display = getDefaultDisplayDeviceLocked();
1692 if (display && display->isPoweredOn()) {
Ady Abraham27c70212019-06-11 10:52:26 -07001693 setVsyncEnabledInHWC(*displayId, mHWCVsyncPendingState);
Ady Abraham9ba25122019-06-03 17:10:55 -07001694 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07001695 }
Mathias Agopian86303202012-07-24 22:46:10 -07001696}
1697
Steven Thomasb02664d2017-07-26 18:48:28 -07001698void SurfaceFlinger::resetDisplayState() {
Ana Krulecc2870422019-01-29 19:00:58 -08001699 mScheduler->disableHardwareVsync(true);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001700 // Clear the drawing state so that the logic inside of
1701 // handleTransactionLocked will fire. It will determine the delta between
1702 // mCurrentState and mDrawingState and re-apply all changes when we make the
1703 // transition.
1704 mDrawingState.displays.clear();
1705 mDisplays.clear();
1706}
1707
Steven Thomas050b2c82017-03-06 11:45:16 -08001708void SurfaceFlinger::updateVrFlinger() {
Alec Mourife3dc942019-02-12 14:19:18 -08001709 ATRACE_CALL();
Steven Thomas050b2c82017-03-06 11:45:16 -08001710 if (!mVrFlinger)
1711 return;
1712 bool vrFlingerRequestsDisplay = mVrFlingerRequestsDisplay;
Lloyd Pique441d5042018-10-18 16:49:51 -07001713 if (vrFlingerRequestsDisplay == getHwComposer().isUsingVrComposer()) {
Mark Urbanus209beca2017-02-23 11:16:04 -08001714 return;
1715 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001716
Lloyd Pique441d5042018-10-18 16:49:51 -07001717 if (vrFlingerRequestsDisplay && !getHwComposer().getComposer()->isRemote()) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001718 ALOGE("Vr flinger is only supported for remote hardware composer"
1719 " service connections. Ignoring request to transition to vr"
1720 " flinger.");
1721 mVrFlingerRequestsDisplay = false;
1722 return;
Mark Urbanus209beca2017-02-23 11:16:04 -08001723 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001724
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001725 Mutex::Autolock _l(mStateLock);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001726
Steven Thomas0123ac62018-07-12 11:32:34 -07001727 sp<DisplayDevice> display = getDefaultDisplayDeviceLocked();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07001728 LOG_ALWAYS_FATAL_IF(!display);
Lloyd Pique07e33212018-12-18 16:33:37 -08001729
Peiyong Lin65248e02020-04-18 21:15:07 -07001730 const hal::PowerMode currentDisplayPowerMode = display->getPowerMode();
Lloyd Pique07e33212018-12-18 16:33:37 -08001731
1732 // Clear out all the output layers from the composition engine for all
1733 // displays before destroying the hardware composer interface. This ensures
1734 // any HWC layers are destroyed through that interface before it becomes
1735 // invalid.
1736 for (const auto& [token, displayDevice] : mDisplays) {
Lloyd Pique01c77c12019-04-17 12:48:32 -07001737 displayDevice->getCompositionDisplay()->clearOutputLayers();
Lloyd Pique07e33212018-12-18 16:33:37 -08001738 }
1739
Steven Thomas0123ac62018-07-12 11:32:34 -07001740 // This DisplayDevice will no longer be relevant once resetDisplayState() is
1741 // called below. Clear the reference now so we don't accidentally use it
1742 // later.
1743 display.clear();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001744
Steven Thomasb02664d2017-07-26 18:48:28 -07001745 if (!vrFlingerRequestsDisplay) {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001746 mVrFlinger->SeizeDisplayOwnership();
Steven Thomasb02664d2017-07-26 18:48:28 -07001747 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001748
Steven Thomasb02664d2017-07-26 18:48:28 -07001749 resetDisplayState();
Lloyd Pique441d5042018-10-18 16:49:51 -07001750 // Delete the current instance before creating the new one
1751 mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
1752 mCompositionEngine->setHwComposer(getFactory().createHWComposer(
1753 vrFlingerRequestsDisplay ? "vr" : getBE().mHwcServiceName));
Lloyd Pique4603f3c2020-02-11 12:06:56 -08001754 mCompositionEngine->getHwComposer().setConfiguration(this, ++getBE().mComposerSequenceId);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001755
Lloyd Pique441d5042018-10-18 16:49:51 -07001756 LOG_ALWAYS_FATAL_IF(!getHwComposer().getComposer()->isRemote(),
David Sodman105b7dc2017-11-04 20:28:14 -07001757 "Switched to non-remote hardware composer");
Steven Thomasb02664d2017-07-26 18:48:28 -07001758
1759 if (vrFlingerRequestsDisplay) {
1760 mVrFlinger->GrantDisplayOwnership();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001761 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001762
1763 mVisibleRegionsDirty = true;
1764 invalidateHwcGeometry();
1765
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001766 // Re-enable default display.
Steven Thomas0123ac62018-07-12 11:32:34 -07001767 display = getDefaultDisplayDeviceLocked();
1768 LOG_ALWAYS_FATAL_IF(!display);
Dominik Laskowskie9774092018-12-11 10:04:24 -08001769 setPowerModeInternal(display, currentDisplayPowerMode);
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001770
Steven Thomasb02664d2017-07-26 18:48:28 -07001771 // Reset the timing values to account for the period of the swapped in HWC
Dominik Laskowski83b88212018-12-11 13:34:06 -08001772 const nsecs_t vsyncPeriod = getVsyncPeriod();
1773 mAnimFrameTracker.setDisplayRefreshPeriod(vsyncPeriod);
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001774
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001775 // The present fences returned from vr_hwc are not an accurate
1776 // representation of vsync times.
Ana Krulecc2870422019-01-29 19:00:58 -08001777 mScheduler->setIgnorePresentFences(getHwComposer().isUsingVrComposer() || !hasSyncFramework);
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001778
Steven Thomasb02664d2017-07-26 18:48:28 -07001779 // Use phase of 0 since phase is not known.
1780 // Use latency of 0, which will snap to the ideal latency.
Dominik Laskowski83b88212018-12-11 13:34:06 -08001781 DisplayStatInfo stats{0 /* vsyncTime */, vsyncPeriod};
Ana Krulece588e312018-09-18 12:32:24 -07001782 setCompositorTimingSnapped(stats, 0);
Stephen Kiazyk82386cd2017-04-14 13:43:29 -07001783
Ana Krulecc2870422019-01-29 19:00:58 -08001784 mScheduler->resyncToHardwareVsync(false, vsyncPeriod);
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001785
Lloyd Piquef1c675b2018-09-12 20:45:39 -07001786 mRepaintEverything = true;
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001787 setTransactionFlags(eDisplayTransactionNeeded);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001788}
1789
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07001790sp<Fence> SurfaceFlinger::previousFrameFence() {
Ady Abrahambe0f9482019-04-24 15:41:53 -07001791 // We are storing the last 2 present fences. If sf's phase offset is to be
1792 // woken up before the actual vsync but targeting the next vsync, we need to check
1793 // fence N-2
Alec Mouri6d414b52020-03-17 11:18:05 -07001794 return mVSyncModulator->getOffsets().sf > 0 ? mPreviousPresentFences[0]
1795 : mPreviousPresentFences[1];
1796}
1797
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07001798bool SurfaceFlinger::previousFramePending(int graceTimeMs) {
Alec Mouri6d414b52020-03-17 11:18:05 -07001799 ATRACE_CALL();
1800 const sp<Fence>& fence = previousFrameFence();
Ady Abrahambe0f9482019-04-24 15:41:53 -07001801
Ady Abraham11579302019-09-19 12:35:58 -07001802 if (fence == Fence::NO_FENCE) {
1803 return false;
1804 }
1805
Dan Stoza59083052020-04-28 10:13:20 -07001806 const status_t status = fence->wait(graceTimeMs);
1807 // This is the same as Fence::Status::Unsignaled, but it saves a getStatus() call,
1808 // which calls wait(0) again internally
1809 return status == -ETIME;
Ady Abrahambe0f9482019-04-24 15:41:53 -07001810}
1811
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07001812nsecs_t SurfaceFlinger::previousFramePresentTime() {
Alec Mouri6d414b52020-03-17 11:18:05 -07001813 const sp<Fence>& fence = previousFrameFence();
1814
1815 if (fence == Fence::NO_FENCE) {
1816 return Fence::SIGNAL_TIME_INVALID;
1817 }
1818
1819 return fence->getSignalTime();
1820}
1821
Ady Abraham5facfb12020-04-22 15:18:31 -07001822nsecs_t SurfaceFlinger::calculateExpectedPresentTime(nsecs_t now) const {
Alec Mouriaa614192019-06-06 13:28:34 -07001823 DisplayStatInfo stats;
1824 mScheduler->getDisplayStatInfo(&stats);
Ady Abraham5facfb12020-04-22 15:18:31 -07001825 const nsecs_t presentTime = mScheduler->getDispSyncExpectedPresentTime(now);
Alec Mouriaa614192019-06-06 13:28:34 -07001826 // Inflate the expected present time if we're targetting the next vsync.
Ady Abraham5facfb12020-04-22 15:18:31 -07001827 return mVSyncModulator->getOffsets().sf > 0 ? presentTime : presentTime + stats.vsyncPeriod;
Alec Mouriaa614192019-06-06 13:28:34 -07001828}
1829
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07001830void SurfaceFlinger::onMessageReceived(int32_t what, nsecs_t expectedVSyncTime) {
Jamie Gennis1c8e95c2012-02-23 19:27:23 -08001831 ATRACE_CALL();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001832 switch (what) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08001833 case MessageQueue::INVALIDATE: {
Dan Stoza28d46a52020-04-28 09:54:54 -07001834 onMessageInvalidate(expectedVSyncTime);
Dan Stoza6b9454d2014-11-07 16:00:59 -08001835 break;
1836 }
1837 case MessageQueue::REFRESH: {
Dan Stoza28d46a52020-04-28 09:54:54 -07001838 onMessageRefresh();
Dan Stoza6b9454d2014-11-07 16:00:59 -08001839 break;
1840 }
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001841 }
1842}
1843
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07001844void SurfaceFlinger::onMessageInvalidate(nsecs_t expectedVSyncTime) {
Dan Stoza28d46a52020-04-28 09:54:54 -07001845 ATRACE_CALL();
1846
1847 const nsecs_t frameStart = systemTime();
1848 // calculate the expected present time once and use the cached
1849 // value throughout this frame to make sure all layers are
1850 // seeing this same value.
1851 const nsecs_t lastExpectedPresentTime = mExpectedPresentTime.load();
1852 mExpectedPresentTime = expectedVSyncTime;
1853
1854 // When Backpressure propagation is enabled we want to give a small grace period
1855 // for the present fence to fire instead of just giving up on this frame to handle cases
1856 // where present fence is just about to get signaled.
1857 const int graceTimeForPresentFenceMs =
1858 (mPropagateBackpressure &&
1859 (mPropagateBackpressureClientComposition || !mHadClientComposition))
1860 ? 1
1861 : 0;
1862
1863 // Pending frames may trigger backpressure propagation.
1864 const TracedOrdinal<bool> framePending = {"PrevFramePending",
1865 previousFramePending(graceTimeForPresentFenceMs)};
1866
1867 // Frame missed counts for metrics tracking.
1868 // A frame is missed if the prior frame is still pending. If no longer pending,
1869 // then we still count the frame as missed if the predicted present time
1870 // was further in the past than when the fence actually fired.
1871
1872 // Add some slop to correct for drift. This should generally be
1873 // smaller than a typical frame duration, but should not be so small
1874 // that it reports reasonable drift as a missed frame.
1875 DisplayStatInfo stats;
1876 mScheduler->getDisplayStatInfo(&stats);
1877 const nsecs_t frameMissedSlop = stats.vsyncPeriod / 2;
1878 const nsecs_t previousPresentTime = previousFramePresentTime();
1879 const TracedOrdinal<bool> frameMissed = {"PrevFrameMissed",
1880 framePending ||
1881 (previousPresentTime >= 0 &&
1882 (lastExpectedPresentTime <
1883 previousPresentTime - frameMissedSlop))};
1884 const TracedOrdinal<bool> hwcFrameMissed = {"PrevHwcFrameMissed",
1885 mHadDeviceComposition && frameMissed};
1886 const TracedOrdinal<bool> gpuFrameMissed = {"PrevGpuFrameMissed",
1887 mHadClientComposition && frameMissed};
1888
1889 if (frameMissed) {
1890 mFrameMissedCount++;
1891 mTimeStats->incrementMissedFrames();
1892 if (mMissedFrameJankCount == 0) {
1893 mMissedFrameJankStart = systemTime();
1894 }
1895 mMissedFrameJankCount++;
1896 }
1897
1898 if (hwcFrameMissed) {
1899 mHwcFrameMissedCount++;
1900 }
1901
1902 if (gpuFrameMissed) {
1903 mGpuFrameMissedCount++;
1904 }
1905
1906 // If we are in the middle of a config change and the fence hasn't
1907 // fired yet just wait for the next invalidate
1908 if (mSetActiveConfigPending) {
1909 if (framePending) {
1910 mEventQueue->invalidate();
1911 return;
1912 }
1913
1914 // We received the present fence from the HWC, so we assume it successfully updated
1915 // the config, hence we update SF.
1916 mSetActiveConfigPending = false;
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07001917 ON_MAIN_THREAD(setActiveConfigInternal());
Dan Stoza28d46a52020-04-28 09:54:54 -07001918 }
1919
1920 if (framePending && mPropagateBackpressure) {
1921 if ((hwcFrameMissed && !gpuFrameMissed) || mPropagateBackpressureClientComposition) {
1922 signalLayerUpdate();
1923 return;
1924 }
1925 }
1926
1927 // Our jank window is always at least 100ms since we missed a
1928 // frame...
1929 static constexpr nsecs_t kMinJankyDuration =
1930 std::chrono::duration_cast<std::chrono::nanoseconds>(100ms).count();
1931 // ...but if it's larger than 1s then we missed the trace cutoff.
1932 static constexpr nsecs_t kMaxJankyDuration =
1933 std::chrono::duration_cast<std::chrono::nanoseconds>(1s).count();
Alec Mouri1b6a60c2020-06-08 13:54:24 -07001934 nsecs_t jankDurationToUpload = -1;
Dan Stoza28d46a52020-04-28 09:54:54 -07001935 // If we're in a user build then don't push any atoms
1936 if (!mIsUserBuild && mMissedFrameJankCount > 0) {
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07001937 const auto display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked());
Dan Stoza28d46a52020-04-28 09:54:54 -07001938 // Only report jank when the display is on, as displays in DOZE
1939 // power mode may operate at a different frame rate than is
1940 // reported in their config, which causes noticeable (but less
1941 // severe) jank.
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07001942 if (display && display->getPowerMode() == hal::PowerMode::ON) {
Dan Stoza28d46a52020-04-28 09:54:54 -07001943 const nsecs_t currentTime = systemTime();
1944 const nsecs_t jankDuration = currentTime - mMissedFrameJankStart;
1945 if (jankDuration > kMinJankyDuration && jankDuration < kMaxJankyDuration) {
Alec Mouri1b6a60c2020-06-08 13:54:24 -07001946 jankDurationToUpload = jankDuration;
Dan Stoza28d46a52020-04-28 09:54:54 -07001947 }
1948
1949 // We either reported a jank event or we missed the trace
1950 // window, so clear counters here.
1951 if (jankDuration > kMinJankyDuration) {
1952 mMissedFrameJankCount = 0;
1953 mMissedFrameJankStart = 0;
1954 }
1955 }
1956 }
1957
1958 // Now that we're going to make it to the handleMessageTransaction()
1959 // call below it's safe to call updateVrFlinger(), which will
1960 // potentially trigger a display handoff.
1961 updateVrFlinger();
1962
1963 if (mTracingEnabledChanged) {
1964 mTracingEnabled = mTracing.isEnabled();
1965 mTracingEnabledChanged = false;
1966 }
1967
1968 bool refreshNeeded;
1969 {
1970 ConditionalLockGuard<std::mutex> lock(mTracingLock, mTracingEnabled);
1971
1972 refreshNeeded = handleMessageTransaction();
1973 refreshNeeded |= handleMessageInvalidate();
1974 if (mTracingEnabled) {
1975 mAddCompositionStateToTrace =
1976 mTracing.flagIsSetLocked(SurfaceTracing::TRACE_COMPOSITION);
1977 if (mVisibleRegionsDirty && !mAddCompositionStateToTrace) {
1978 mTracing.notifyLocked("visibleRegionsDirty");
1979 }
1980 }
1981 }
1982
1983 // Layers need to get updated (in the previous line) before we can use them for
1984 // choosing the refresh rate.
1985 // Hold mStateLock as chooseRefreshRateForContent promotes wp<Layer> to sp<Layer>
1986 // and may eventually call to ~Layer() if it holds the last reference
1987 {
1988 Mutex::Autolock _l(mStateLock);
1989 mScheduler->chooseRefreshRateForContent();
1990 }
1991
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07001992 ON_MAIN_THREAD(performSetActiveConfig());
Dan Stoza28d46a52020-04-28 09:54:54 -07001993
1994 updateCursorAsync();
1995 updateInputFlinger();
1996
1997 refreshNeeded |= mRepaintEverything;
1998 if (refreshNeeded && CC_LIKELY(mBootStage != BootStage::BOOTLOADER)) {
Alec Mouri1b6a60c2020-06-08 13:54:24 -07001999 mLastJankDuration = jankDurationToUpload;
Dan Stoza28d46a52020-04-28 09:54:54 -07002000 // Signal a refresh if a transaction modified the window state,
2001 // a new buffer was latched, or if HWC has requested a full
2002 // repaint
2003 if (mFrameStartTime <= 0) {
2004 // We should only use the time of the first invalidate
2005 // message that signals a refresh as the beginning of the
2006 // frame. Otherwise the real frame time will be
2007 // underestimated.
2008 mFrameStartTime = frameStart;
2009 }
2010 signalRefresh();
2011 }
2012}
2013
Dan Stoza6b9454d2014-11-07 16:00:59 -08002014bool SurfaceFlinger::handleMessageTransaction() {
Alec Mourife3dc942019-02-12 14:19:18 -08002015 ATRACE_CALL();
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08002016 uint32_t transactionFlags = peekTransactionFlags();
Marissa Wall713b63f2018-10-17 15:42:43 -07002017
Marissa Walle6e3c0d2019-03-29 10:28:30 -07002018 bool flushedATransaction = flushTransactionQueues();
2019
2020 bool runHandleTransaction = transactionFlags &&
2021 ((transactionFlags != eTransactionFlushNeeded) || flushedATransaction);
2022
2023 if (runHandleTransaction) {
2024 handleTransaction(eTransactionMask);
2025 } else {
2026 getTransactionFlags(eTransactionFlushNeeded);
Marissa Wall713b63f2018-10-17 15:42:43 -07002027 }
2028
Marissa Walle6e3c0d2019-03-29 10:28:30 -07002029 if (transactionFlushNeeded()) {
2030 setTransactionFlags(eTransactionFlushNeeded);
Mathias Agopian4fec8732012-06-29 14:12:52 -07002031 }
Marissa Wall713b63f2018-10-17 15:42:43 -07002032
Marissa Walle6e3c0d2019-03-29 10:28:30 -07002033 return runHandleTransaction;
Mathias Agopian4fec8732012-06-29 14:12:52 -07002034}
2035
Dan Stoza28d46a52020-04-28 09:54:54 -07002036void SurfaceFlinger::onMessageRefresh() {
Mathias Agopiancd60f992012-08-16 16:28:27 -07002037 ATRACE_CALL();
Dan Stoza14cd37c2015-07-09 12:43:33 -07002038
Dan Stoza2b6d38e2017-06-01 16:40:30 -07002039 mRefreshPending = false;
2040
Lloyd Piqueab039b52019-02-13 14:22:42 -08002041 compositionengine::CompositionRefreshArgs refreshArgs;
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002042 const auto& displays = ON_MAIN_THREAD(mDisplays);
2043 refreshArgs.outputs.reserve(displays.size());
2044 for (const auto& [_, display] : displays) {
Lloyd Piqueab039b52019-02-13 14:22:42 -08002045 refreshArgs.outputs.push_back(display->getCompositionDisplay());
2046 }
2047 mDrawingState.traverseInZOrder([&refreshArgs](Layer* layer) {
Lloyd Piquede196652020-01-22 17:29:58 -08002048 if (auto layerFE = layer->getCompositionEngineLayerFE())
2049 refreshArgs.layers.push_back(layerFE);
Lloyd Piqueab039b52019-02-13 14:22:42 -08002050 });
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002051 refreshArgs.layersWithQueuedFrames.reserve(mLayersWithQueuedFrames.size());
2052 for (sp<Layer> layer : mLayersWithQueuedFrames) {
Lloyd Piquede196652020-01-22 17:29:58 -08002053 if (auto layerFE = layer->getCompositionEngineLayerFE())
2054 refreshArgs.layersWithQueuedFrames.push_back(layerFE);
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002055 }
2056
Lloyd Piquef8cf14d2019-02-28 16:03:12 -08002057 refreshArgs.repaintEverything = mRepaintEverything.exchange(false);
Lloyd Pique6a3b4462019-03-07 20:58:12 -08002058 refreshArgs.outputColorSetting = useColorManagement
2059 ? mDisplayColorSetting
2060 : compositionengine::OutputColorSetting::kUnmanaged;
2061 refreshArgs.colorSpaceAgnosticDataspace = mColorSpaceAgnosticDataspace;
2062 refreshArgs.forceOutputColorMode = mForceColorMode;
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002063
2064 refreshArgs.updatingOutputGeometryThisFrame = mVisibleRegionsDirty;
2065 refreshArgs.updatingGeometryThisFrame = mGeometryInvalid || mVisibleRegionsDirty;
Lucas Dupin2dd6f392020-02-18 17:43:36 -08002066 refreshArgs.blursAreExpensive = mBlursAreExpensive;
Snild Dolkow9e217d62020-04-22 15:53:42 +02002067 refreshArgs.internalDisplayRotationFlags = DisplayDevice::getPrimaryDisplayRotationFlags();
Lloyd Pique3eb1b212019-03-07 21:15:40 -08002068
2069 if (CC_UNLIKELY(mDrawingState.colorMatrixChanged)) {
2070 refreshArgs.colorTransformMatrix = mDrawingState.colorMatrix;
2071 mDrawingState.colorMatrixChanged = false;
2072 }
2073
2074 refreshArgs.devOptForceClientComposition = mDebugDisableHWC || mDebugRegion;
2075
Lloyd Piquef8cf14d2019-02-28 16:03:12 -08002076 if (mDebugRegion != 0) {
2077 refreshArgs.devOptFlashDirtyRegionsDelay =
2078 std::chrono::milliseconds(mDebugRegion > 1 ? mDebugRegion : 0);
2079 }
Lloyd Piqueab039b52019-02-13 14:22:42 -08002080
Lloyd Pique3eb1b212019-03-07 21:15:40 -08002081 mGeometryInvalid = false;
2082
Ady Abraham3a77a7b2019-12-02 18:46:59 -08002083 // Store the present time just before calling to the composition engine so we could notify
2084 // the scheduler.
2085 const auto presentTime = systemTime();
2086
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002087 mCompositionEngine->present(refreshArgs);
Alec Mouri9519bf12019-11-15 16:54:44 -08002088 mTimeStats->recordFrameDuration(mFrameStartTime, systemTime());
2089 // Reset the frame start time now that we've recorded this frame.
2090 mFrameStartTime = 0;
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002091
Ady Abraham3a77a7b2019-12-02 18:46:59 -08002092 mScheduler->onDisplayRefreshed(presentTime);
2093
David Sodmanfa9b2af2017-12-24 13:28:59 -08002094 postFrame();
David Sodman2b406362017-12-15 13:33:47 -08002095 postComposition();
Dan Stoza05dacfb2016-07-01 13:33:38 -07002096
Alec Mouri8f7a0102020-04-15 12:11:10 -07002097 const bool prevFrameHadDeviceComposition = mHadDeviceComposition;
2098
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002099 mHadClientComposition = std::any_of(displays.cbegin(), displays.cend(), [](const auto& pair) {
2100 const auto& state = pair.second->getCompositionDisplay()->getState();
2101 return state.usesClientComposition && !state.reusedClientComposition;
2102 });
2103 mHadDeviceComposition = std::any_of(displays.cbegin(), displays.cend(), [](const auto& pair) {
2104 const auto& state = pair.second->getCompositionDisplay()->getState();
2105 return state.usesDeviceComposition;
2106 });
Vishnu Nair9b079a22020-01-21 14:36:08 -08002107 mReusedClientComposition =
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002108 std::any_of(displays.cbegin(), displays.cend(), [](const auto& pair) {
2109 const auto& state = pair.second->getCompositionDisplay()->getState();
2110 return state.reusedClientComposition;
Vishnu Nair9b079a22020-01-21 14:36:08 -08002111 });
David Sodmanfa9b2af2017-12-24 13:28:59 -08002112
Alec Mouri8f7a0102020-04-15 12:11:10 -07002113 // Only report a strategy change if we move in and out of composition with hw overlays
2114 if (prevFrameHadDeviceComposition != mHadDeviceComposition) {
2115 mTimeStats->incrementCompositionStrategyChanges();
2116 }
2117
Dominik Laskowskieddeda12019-07-19 11:54:13 -07002118 mVSyncModulator->onRefreshed(mHadClientComposition);
Dan Stoza14cd37c2015-07-09 12:43:33 -07002119
David Sodman7e4ae112018-02-09 15:02:28 -08002120 mLayersWithQueuedFrames.clear();
Vishnu Nairdf529052019-06-07 14:53:14 -07002121 if (mVisibleRegionsDirty) {
2122 mVisibleRegionsDirty = false;
Vishnu Nair60db8c02020-04-02 11:55:16 -07002123 if (mTracingEnabled && mAddCompositionStateToTrace) {
Vishnu Nairdf529052019-06-07 14:53:14 -07002124 mTracing.notify("visibleRegionsDirty");
2125 }
2126 }
Lloyd Piqueab039b52019-02-13 14:22:42 -08002127
2128 if (mCompositionEngine->needsAnotherUpdate()) {
2129 signalLayerUpdate();
2130 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07002131}
Mathias Agopian4fec8732012-06-29 14:12:52 -07002132
David Sodmanfa9b2af2017-12-24 13:28:59 -08002133bool SurfaceFlinger::handleMessageInvalidate() {
2134 ATRACE_CALL();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002135 bool refreshNeeded = handlePageFlip();
2136
Vishnu Nair4351ad52019-02-11 14:13:02 -08002137 if (mVisibleRegionsDirty) {
2138 computeLayerBounds();
2139 }
2140
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002141 for (auto& layer : mLayersPendingRefresh) {
2142 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002143 visibleReg.set(layer->getScreenBounds());
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002144 invalidateLayerStack(layer, visibleReg);
2145 }
2146 mLayersPendingRefresh.clear();
2147 return refreshNeeded;
Mathias Agopian4fec8732012-06-29 14:12:52 -07002148}
2149
Ana Krulece588e312018-09-18 12:32:24 -07002150void SurfaceFlinger::updateCompositorTiming(const DisplayStatInfo& stats, nsecs_t compositeTime,
2151 std::shared_ptr<FenceTime>& presentFenceTime) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002152 // Update queue of past composite+present times and determine the
2153 // most recently known composite to present latency.
David Sodman99974d22017-11-28 12:04:33 -08002154 getBE().mCompositePresentTimes.push({compositeTime, presentFenceTime});
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002155 nsecs_t compositeToPresentLatency = -1;
David Sodman99974d22017-11-28 12:04:33 -08002156 while (!getBE().mCompositePresentTimes.empty()) {
2157 SurfaceFlingerBE::CompositePresentTime& cpt = getBE().mCompositePresentTimes.front();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002158 // Cached values should have been updated before calling this method,
2159 // which helps avoid duplicate syscalls.
2160 nsecs_t displayTime = cpt.display->getCachedSignalTime();
2161 if (displayTime == Fence::SIGNAL_TIME_PENDING) {
2162 break;
2163 }
2164 compositeToPresentLatency = displayTime - cpt.composite;
David Sodman99974d22017-11-28 12:04:33 -08002165 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002166 }
2167
2168 // Don't let mCompositePresentTimes grow unbounded, just in case.
David Sodman99974d22017-11-28 12:04:33 -08002169 while (getBE().mCompositePresentTimes.size() > 16) {
2170 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002171 }
2172
Ana Krulece588e312018-09-18 12:32:24 -07002173 setCompositorTimingSnapped(stats, compositeToPresentLatency);
Brian Andersond0010582017-03-07 13:20:31 -08002174}
2175
Ana Krulece588e312018-09-18 12:32:24 -07002176void SurfaceFlinger::setCompositorTimingSnapped(const DisplayStatInfo& stats,
2177 nsecs_t compositeToPresentLatency) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002178 // Integer division and modulo round toward 0 not -inf, so we need to
2179 // treat negative and positive offsets differently.
Ady Abraham9e16a482019-12-03 17:19:41 -08002180 nsecs_t idealLatency = (mPhaseConfiguration->getCurrentOffsets().late.sf > 0)
2181 ? (stats.vsyncPeriod -
2182 (mPhaseConfiguration->getCurrentOffsets().late.sf % stats.vsyncPeriod))
2183 : ((-mPhaseConfiguration->getCurrentOffsets().late.sf) % stats.vsyncPeriod);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002184
Ady Abraham9e16a482019-12-03 17:19:41 -08002185 // Just in case mPhaseConfiguration->getCurrentOffsets().late.sf == -vsyncInterval.
Brian Andersond0010582017-03-07 13:20:31 -08002186 if (idealLatency <= 0) {
Ana Krulece588e312018-09-18 12:32:24 -07002187 idealLatency = stats.vsyncPeriod;
Brian Andersond0010582017-03-07 13:20:31 -08002188 }
2189
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002190 // Snap the latency to a value that removes scheduling jitter from the
2191 // composition and present times, which often have >1ms of jitter.
2192 // Reducing jitter is important if an app attempts to extrapolate
2193 // something (such as user input) to an accurate diasplay time.
Ady Abraham9e16a482019-12-03 17:19:41 -08002194 // Snapping also allows an app to precisely calculate
2195 // mPhaseConfiguration->getCurrentOffsets().late.sf with (presentLatency % interval).
Ana Krulece588e312018-09-18 12:32:24 -07002196 nsecs_t bias = stats.vsyncPeriod / 2;
2197 int64_t extraVsyncs = (compositeToPresentLatency - idealLatency + bias) / stats.vsyncPeriod;
2198 nsecs_t snappedCompositeToPresentLatency =
2199 (extraVsyncs > 0) ? idealLatency + (extraVsyncs * stats.vsyncPeriod) : idealLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002200
David Sodman99974d22017-11-28 12:04:33 -08002201 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
Ana Krulece588e312018-09-18 12:32:24 -07002202 getBE().mCompositorTiming.deadline = stats.vsyncTime - idealLatency;
2203 getBE().mCompositorTiming.interval = stats.vsyncPeriod;
David Sodman99974d22017-11-28 12:04:33 -08002204 getBE().mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002205}
2206
David Sodman2b406362017-12-15 13:33:47 -08002207void SurfaceFlinger::postComposition()
Mathias Agopiancd60f992012-08-16 16:28:27 -07002208{
Dan Stoza9e56aa02015-11-02 13:00:03 -08002209 ATRACE_CALL();
2210 ALOGV("postComposition");
2211
Brian Andersonf6386862016-10-31 16:34:13 -07002212 nsecs_t dequeueReadyTime = systemTime();
Brian Anderson3546a3f2016-07-14 11:51:14 -07002213 for (auto& layer : mLayersWithQueuedFrames) {
Brian Andersonf6386862016-10-31 16:34:13 -07002214 layer->releasePendingBuffer(dequeueReadyTime);
Brian Anderson3546a3f2016-07-14 11:51:14 -07002215 }
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002216
2217 const auto* display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked()).get();
Brian Anderson3d4039d2016-09-23 16:31:30 -07002218
David Sodman73beded2017-11-15 11:56:06 -08002219 getBE().mGlCompositionDoneTimeline.updateSignalTimes();
Brian Anderson3d4039d2016-09-23 16:31:30 -07002220 std::shared_ptr<FenceTime> glCompositionDoneFenceTime;
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002221 if (display && display->getCompositionDisplay()->getState().usesClientComposition) {
Brian Anderson3d4039d2016-09-23 16:31:30 -07002222 glCompositionDoneFenceTime =
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002223 std::make_shared<FenceTime>(display->getCompositionDisplay()
Lloyd Pique31cb2942018-10-19 17:23:03 -07002224 ->getRenderSurface()
2225 ->getClientTargetAcquireFence());
David Sodman73beded2017-11-15 11:56:06 -08002226 getBE().mGlCompositionDoneTimeline.push(glCompositionDoneFenceTime);
Brian Anderson3d4039d2016-09-23 16:31:30 -07002227 } else {
2228 glCompositionDoneFenceTime = FenceTime::NO_FENCE;
2229 }
Brian Anderson3d4039d2016-09-23 16:31:30 -07002230
David Sodman73beded2017-11-15 11:56:06 -08002231 getBE().mDisplayTimeline.updateSignalTimes();
Ady Abrahambe0f9482019-04-24 15:41:53 -07002232 mPreviousPresentFences[1] = mPreviousPresentFences[0];
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002233 mPreviousPresentFences[0] =
2234 display ? getHwComposer().getPresentFence(*display->getId()) : Fence::NO_FENCE;
Ady Abrahambe0f9482019-04-24 15:41:53 -07002235 auto presentFenceTime = std::make_shared<FenceTime>(mPreviousPresentFences[0]);
David Sodman73beded2017-11-15 11:56:06 -08002236 getBE().mDisplayTimeline.push(presentFenceTime);
Brian Anderson3d4039d2016-09-23 16:31:30 -07002237
Ana Krulece588e312018-09-18 12:32:24 -07002238 DisplayStatInfo stats;
Ana Krulecc2870422019-01-29 19:00:58 -08002239 mScheduler->getDisplayStatInfo(&stats);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002240
Lloyd Piqueab039b52019-02-13 14:22:42 -08002241 // We use the CompositionEngine::getLastFrameRefreshTimestamp() which might
2242 // be sampled a little later than when we started doing work for this frame,
2243 // but that should be okay since updateCompositorTiming has snapping logic.
2244 updateCompositorTiming(stats, mCompositionEngine->getLastFrameRefreshTimestamp(),
2245 presentFenceTime);
Brian Andersond0010582017-03-07 13:20:31 -08002246 CompositorTiming compositorTiming;
2247 {
David Sodman99974d22017-11-28 12:04:33 -08002248 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
2249 compositorTiming = getBE().mCompositorTiming;
Brian Andersond0010582017-03-07 13:20:31 -08002250 }
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002251
Edgar Arriaga844fa672020-01-16 14:21:42 -08002252 mDrawingState.traverse([&](Layer* layer) {
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002253 const bool frameLatched = layer->onPostComposition(display, glCompositionDoneFenceTime,
2254 presentFenceTime, compositorTiming);
Dan Stozae77c7662016-05-13 11:37:28 -07002255 if (frameLatched) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07002256 recordBufferingStats(layer->getName(), layer->getOccupancyHistory(false));
Dan Stozae77c7662016-05-13 11:37:28 -07002257 }
Robert Carr2047fae2016-11-28 14:09:09 -08002258 });
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002259
Valerie Hau4b678442020-04-14 10:50:42 -07002260 mTransactionCompletedThread.addPresentFence(mPreviousPresentFences[0]);
2261 mTransactionCompletedThread.sendCallbacks();
2262
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002263 if (display && display->isPrimary() && display->getPowerMode() == hal::PowerMode::ON &&
2264 presentFenceTime->isValid()) {
Ana Krulecc2870422019-01-29 19:00:58 -08002265 mScheduler->addPresentFence(presentFenceTime);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07002266 }
2267
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002268 const bool isDisplayConnected = display && getHwComposer().isConnected(*display->getId());
2269
Fabien Sanglardcbf153b2017-03-10 17:57:12 -08002270 if (!hasSyncFramework) {
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002271 if (isDisplayConnected && display->isPoweredOn()) {
Ana Krulecc2870422019-01-29 19:00:58 -08002272 mScheduler->enableHardwareVsync();
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07002273 }
2274 }
2275
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002276 if (mAnimCompositionPending) {
2277 mAnimCompositionPending = false;
2278
Brian Anderson4e606e32017-03-16 15:34:57 -07002279 if (presentFenceTime->isValid()) {
Brian Anderson3d4039d2016-09-23 16:31:30 -07002280 mAnimFrameTracker.setActualPresentFence(
Brian Anderson4e606e32017-03-16 15:34:57 -07002281 std::move(presentFenceTime));
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002282 } else if (isDisplayConnected) {
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002283 // The HWC doesn't support present fences, so use the refresh
2284 // timestamp instead.
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002285 const nsecs_t presentTime = getHwComposer().getRefreshTimestamp(*display->getId());
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002286 mAnimFrameTracker.setActualPresentTime(presentTime);
2287 }
2288 mAnimFrameTracker.advanceFrame();
2289 }
Dan Stozab90cf072015-03-05 11:05:59 -08002290
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002291 mTimeStats->incrementTotalFrames();
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07002292 if (mHadClientComposition) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002293 mTimeStats->incrementClientCompositionFrames();
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07002294 }
2295
Vishnu Nair9b079a22020-01-21 14:36:08 -08002296 if (mReusedClientComposition) {
2297 mTimeStats->incrementClientCompositionReusedFrames();
2298 }
2299
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002300 mTimeStats->setPresentFenceGlobal(presentFenceTime);
Yiwei Zhangce6ebc02018-10-20 12:42:38 -07002301
Alec Mouri717bcb62020-02-10 17:07:19 -08002302 const size_t sfConnections = mScheduler->getEventThreadConnectionCount(mSfConnectionHandle);
2303 const size_t appConnections = mScheduler->getEventThreadConnectionCount(mAppConnectionHandle);
2304 mTimeStats->recordDisplayEventConnectionCount(sfConnections + appConnections);
2305
Alec Mouri1b6a60c2020-06-08 13:54:24 -07002306 if (mLastJankDuration > 0) {
2307 ATRACE_NAME("Jank detected");
2308 const int32_t jankyDurationMillis = mLastJankDuration / (1000 * 1000);
2309 android::util::stats_write(android::util::DISPLAY_JANK_REPORTED, jankyDurationMillis,
2310 mMissedFrameJankCount);
2311 mLastJankDuration = -1;
2312 }
2313
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002314 if (isDisplayConnected && !display->isPoweredOn()) {
Dan Stozab90cf072015-03-05 11:05:59 -08002315 return;
2316 }
2317
2318 nsecs_t currentTime = systemTime();
2319 if (mHasPoweredOff) {
2320 mHasPoweredOff = false;
2321 } else {
David Sodman4a36e932017-11-07 14:29:47 -08002322 nsecs_t elapsedTime = currentTime - getBE().mLastSwapTime;
Ana Krulece588e312018-09-18 12:32:24 -07002323 size_t numPeriods = static_cast<size_t>(elapsedTime / stats.vsyncPeriod);
David Sodman4a36e932017-11-07 14:29:47 -08002324 if (numPeriods < SurfaceFlingerBE::NUM_BUCKETS - 1) {
2325 getBE().mFrameBuckets[numPeriods] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002326 } else {
David Sodman4a36e932017-11-07 14:29:47 -08002327 getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002328 }
David Sodman4a36e932017-11-07 14:29:47 -08002329 getBE().mTotalTime += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002330 }
David Sodman4a36e932017-11-07 14:29:47 -08002331 getBE().mLastSwapTime = currentTime;
Dan Stoza436ccf32018-06-21 12:10:12 -07002332
Alec Mouri4dde1782019-09-30 17:27:13 -07002333 // Cleanup any outstanding resources due to rendering a prior frame.
2334 getRenderEngine().cleanupPostRender();
2335
Dan Stoza436ccf32018-06-21 12:10:12 -07002336 {
2337 std::lock_guard lock(mTexturePoolMutex);
Dan Stoza67765d82019-05-07 14:58:27 -07002338 if (mTexturePool.size() < mTexturePoolSize) {
2339 const size_t refillCount = mTexturePoolSize - mTexturePool.size();
Dan Stoza436ccf32018-06-21 12:10:12 -07002340 const size_t offset = mTexturePool.size();
2341 mTexturePool.resize(mTexturePoolSize);
2342 getRenderEngine().genTextures(refillCount, mTexturePool.data() + offset);
2343 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Dan Stoza67765d82019-05-07 14:58:27 -07002344 } else if (mTexturePool.size() > mTexturePoolSize) {
2345 const size_t deleteCount = mTexturePool.size() - mTexturePoolSize;
2346 const size_t offset = mTexturePoolSize;
2347 getRenderEngine().deleteTextures(deleteCount, mTexturePool.data() + offset);
2348 mTexturePool.resize(mTexturePoolSize);
2349 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Dan Stoza436ccf32018-06-21 12:10:12 -07002350 }
2351 }
Marissa Walle2ffb422018-10-12 11:33:52 -07002352
Kevin DuBois413287f2019-02-25 08:46:47 -08002353 if (mLumaSampling && mRegionSamplingThread) {
2354 mRegionSamplingThread->notifyNewContent();
Dan Stozaec460082018-12-17 15:35:09 -08002355 }
Dan Stoza45de5ba2019-04-25 14:12:09 -07002356
2357 // Even though ATRACE_INT64 already checks if tracing is enabled, it doesn't prevent the
2358 // side-effect of getTotalSize(), so we check that again here
2359 if (ATRACE_ENABLED()) {
Marissa Wall22b2de12019-12-02 18:11:43 -08002360 // getTotalSize returns the total number of buffers that were allocated by SurfaceFlinger
Dan Stoza45de5ba2019-04-25 14:12:09 -07002361 ATRACE_INT64("Total Buffer Size", GraphicBufferAllocator::get().getTotalSize());
2362 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07002363}
2364
Lloyd Pique7eebe692020-04-22 22:40:06 -07002365FloatRect SurfaceFlinger::getLayerClipBoundsForDisplay(const DisplayDevice& displayDevice) const {
2366 return displayDevice.getViewport().toFloatRect();
2367}
2368
Vishnu Nair4351ad52019-02-11 14:13:02 -08002369void SurfaceFlinger::computeLayerBounds() {
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002370 for (const auto& pair : ON_MAIN_THREAD(mDisplays)) {
Vishnu Nair4351ad52019-02-11 14:13:02 -08002371 const auto& displayDevice = pair.second;
2372 const auto display = displayDevice->getCompositionDisplay();
2373 for (const auto& layer : mDrawingState.layersSortedByZ) {
2374 // only consider the layers on the given layer stack
2375 if (!display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
Vishnu Nair01ace762019-02-12 14:25:24 -08002376 continue;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002377 }
2378
Lloyd Pique7eebe692020-04-22 22:40:06 -07002379 layer->computeBounds(getLayerClipBoundsForDisplay(*displayDevice), ui::Transform(),
Vishnu Nairc97b8db2019-10-29 18:19:35 -07002380 0.f /* shadowRadius */);
Vishnu Nair4351ad52019-02-11 14:13:02 -08002381 }
2382 }
2383}
2384
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002385void SurfaceFlinger::postFrame() {
2386 const auto display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked());
Dominik Laskowski075d3172018-05-24 15:50:06 -07002387 if (display && getHwComposer().isConnected(*display->getId())) {
2388 uint32_t flipCount = display->getPageFlipCount();
David Sodmanfa9b2af2017-12-24 13:28:59 -08002389 if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
2390 logFrameStats();
2391 }
2392 }
2393}
2394
Mathias Agopian87baae12012-07-31 12:38:26 -07002395void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002396{
Mathias Agopian841cde52012-03-01 15:44:37 -08002397 ATRACE_CALL();
2398
Mathias Agopian7cc6df52013-06-05 14:30:54 -07002399 // here we keep a copy of the drawing state (that is the state that's
2400 // going to be overwritten by handleTransactionLocked()) outside of
2401 // mStateLock so that the side-effects of the State assignment
2402 // don't happen with mStateLock held (which can cause deadlocks).
2403 State drawingState(mDrawingState);
2404
Mathias Agopianca4d3602011-05-19 15:38:14 -07002405 Mutex::Autolock _l(mStateLock);
Dominik Laskowski9dab3432019-03-27 13:21:10 -07002406 mDebugInTransaction = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002407
Mathias Agopianca4d3602011-05-19 15:38:14 -07002408 // Here we're guaranteed that some transaction flags are set
2409 // so we can call handleTransactionLocked() unconditionally.
2410 // We call getTransactionFlags(), which will also clear the flags,
2411 // with mStateLock held to guarantee that mCurrentState won't change
2412 // until the transaction is committed.
Mathias Agopian4da75192010-08-10 17:19:56 -07002413
Dominik Laskowskieddeda12019-07-19 11:54:13 -07002414 mVSyncModulator->onTransactionHandled();
Mathias Agopiane57f2922012-08-09 16:29:12 -07002415 transactionFlags = getTransactionFlags(eTransactionMask);
Mathias Agopian87baae12012-07-31 12:38:26 -07002416 handleTransactionLocked(transactionFlags);
Mathias Agopiandea20b12011-05-03 17:04:02 -07002417
Mathias Agopianca4d3602011-05-19 15:38:14 -07002418 mDebugInTransaction = 0;
2419 invalidateHwcGeometry();
2420 // here the transaction has been committed
Mathias Agopian3d579642009-06-04 18:46:21 -07002421}
2422
Lloyd Piqueba04e622017-12-14 17:11:26 -08002423void SurfaceFlinger::processDisplayHotplugEventsLocked() {
2424 for (const auto& event : mPendingHotplugEvents) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002425 const std::optional<DisplayIdentificationInfo> info =
2426 getHwComposer().onHotplug(event.hwcDisplayId, event.connection);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002427
Dominik Laskowski075d3172018-05-24 15:50:06 -07002428 if (!info) {
Lloyd Piqueba04e622017-12-14 17:11:26 -08002429 continue;
2430 }
2431
Dominik Laskowski55c85402020-01-21 16:25:47 -08002432 const DisplayId displayId = info->id;
2433 const auto it = mPhysicalDisplayTokens.find(displayId);
2434
Peiyong Line9d809e2020-04-14 13:10:48 -07002435 if (event.connection == hal::Connection::CONNECTED) {
Dominik Laskowski55c85402020-01-21 16:25:47 -08002436 if (it == mPhysicalDisplayTokens.end()) {
2437 ALOGV("Creating display %s", to_string(displayId).c_str());
2438
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002439 if (event.hwcDisplayId == getHwComposer().getInternalHwcDisplayId()) {
Dominik Laskowski55c85402020-01-21 16:25:47 -08002440 initScheduler(displayId);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002441 }
Dominik Laskowski55c85402020-01-21 16:25:47 -08002442
Dominik Laskowski075d3172018-05-24 15:50:06 -07002443 DisplayDeviceState state;
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002444 state.physical = {displayId, getHwComposer().getDisplayConnectionType(displayId),
2445 event.hwcDisplayId};
Dominik Laskowski075d3172018-05-24 15:50:06 -07002446 state.isSecure = true; // All physical displays are currently considered secure.
2447 state.displayName = info->name;
Dominik Laskowski55c85402020-01-21 16:25:47 -08002448
2449 sp<IBinder> token = new BBinder();
2450 mCurrentState.displays.add(token, state);
2451 mPhysicalDisplayTokens.emplace(displayId, std::move(token));
2452
Dominik Laskowski075d3172018-05-24 15:50:06 -07002453 mInterceptor->saveDisplayCreation(state);
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002454 } else {
2455 ALOGV("Recreating display %s", to_string(displayId).c_str());
2456
2457 const auto token = it->second;
2458 auto& state = mCurrentState.displays.editValueFor(token);
2459 state.sequenceId = DisplayDeviceState{}.sequenceId;
Steven Thomaseb6d2052018-03-20 15:40:48 -07002460 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08002461 } else {
Dominik Laskowski55c85402020-01-21 16:25:47 -08002462 ALOGV("Removing display %s", to_string(displayId).c_str());
Lloyd Piqueba04e622017-12-14 17:11:26 -08002463
Dominik Laskowski55c85402020-01-21 16:25:47 -08002464 const ssize_t index = mCurrentState.displays.indexOfKey(it->second);
Dominik Laskowski075d3172018-05-24 15:50:06 -07002465 if (index >= 0) {
2466 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
2467 mInterceptor->saveDisplayDeletion(state.sequenceId);
2468 mCurrentState.displays.removeItemsAt(index);
Lloyd Piquefcd86612017-12-14 17:15:36 -08002469 }
Dominik Laskowski55c85402020-01-21 16:25:47 -08002470 mPhysicalDisplayTokens.erase(it);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002471 }
2472
2473 processDisplayChangesLocked();
2474 }
2475
2476 mPendingHotplugEvents.clear();
2477}
2478
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002479void SurfaceFlinger::dispatchDisplayHotplugEvent(PhysicalDisplayId displayId, bool connected) {
Dominik Laskowski98041832019-08-01 18:35:59 -07002480 mScheduler->onHotplugReceived(mAppConnectionHandle, displayId, connected);
2481 mScheduler->onHotplugReceived(mSfConnectionHandle, displayId, connected);
Dominik Laskowski1eba0202019-01-24 09:14:40 -08002482}
2483
Lloyd Pique99d3da52018-01-22 17:48:03 -08002484sp<DisplayDevice> SurfaceFlinger::setupNewDisplayDeviceInternal(
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -07002485 const wp<IBinder>& displayToken,
2486 std::shared_ptr<compositionengine::Display> compositionDisplay,
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002487 const DisplayDeviceState& state,
2488 const sp<compositionengine::DisplaySurface>& displaySurface,
Dominik Laskowski075d3172018-05-24 15:50:06 -07002489 const sp<IGraphicBufferProducer>& producer) {
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -07002490 auto displayId = compositionDisplay->getDisplayId();
2491 DisplayDeviceCreationArgs creationArgs(this, displayToken, compositionDisplay);
Dominik Laskowskie9774092018-12-11 10:04:24 -08002492 creationArgs.sequenceId = state.sequenceId;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002493 creationArgs.isSecure = state.isSecure;
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002494 creationArgs.displaySurface = displaySurface;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002495 creationArgs.hasWideColorGamut = false;
2496 creationArgs.supportedPerFrameMetadata = 0;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002497
Dominik Laskowski55c85402020-01-21 16:25:47 -08002498 if (const auto& physical = state.physical) {
2499 creationArgs.connectionType = physical->type;
2500 }
2501
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002502 const bool isInternalDisplay = displayId && displayId == getInternalDisplayIdLocked();
Dominik Laskowski075d3172018-05-24 15:50:06 -07002503 creationArgs.isPrimary = isInternalDisplay;
2504
2505 if (useColorManagement && displayId) {
2506 std::vector<ColorMode> modes = getHwComposer().getColorModes(*displayId);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002507 for (ColorMode colorMode : modes) {
Peiyong Linfca547f2018-07-09 13:03:33 -07002508 if (isWideColorMode(colorMode)) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002509 creationArgs.hasWideColorGamut = true;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002510 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002511
Dominik Laskowski7e045462018-05-30 13:02:02 -07002512 std::vector<RenderIntent> renderIntents =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002513 getHwComposer().getRenderIntents(*displayId, colorMode);
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002514 creationArgs.hwcColorModes.emplace(colorMode, renderIntents);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002515 }
tangrobin6753a022018-08-10 10:58:54 +08002516 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002517
Dominik Laskowski075d3172018-05-24 15:50:06 -07002518 if (displayId) {
2519 getHwComposer().getHdrCapabilities(*displayId, &creationArgs.hdrCapabilities);
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002520 creationArgs.supportedPerFrameMetadata =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002521 getHwComposer().getSupportedPerFrameMetadata(*displayId);
Chia-I Wu0f509fb2018-06-21 15:52:50 +08002522 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002523
Lloyd Pique90c115d2018-09-18 21:39:42 -07002524 auto nativeWindowSurface = getFactory().createNativeWindowSurface(producer);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002525 auto nativeWindow = nativeWindowSurface->getNativeWindow();
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002526 creationArgs.nativeWindow = nativeWindow;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002527
Lloyd Pique99d3da52018-01-22 17:48:03 -08002528 // Make sure that composition can never be stalled by a virtual display
2529 // consumer that isn't processing buffers fast enough. We have to do this
Alec Mouri0a9c7b82018-11-16 13:05:25 -08002530 // here, in case the display is composed entirely by HWC.
Dominik Laskowski281644e2018-04-19 15:47:35 -07002531 if (state.isVirtual()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002532 nativeWindow->setSwapInterval(nativeWindow.get(), 0);
2533 }
2534
Dominik Laskowski718f9602019-11-09 20:01:35 -08002535 creationArgs.physicalOrientation =
2536 isInternalDisplay ? internalDisplayOrientation : ui::ROTATION_0;
Chia-I Wua02871c2018-08-27 14:38:23 -07002537
Lloyd Pique99d3da52018-01-22 17:48:03 -08002538 // virtual displays are always considered enabled
Peiyong Lin65248e02020-04-18 21:15:07 -07002539 creationArgs.initialPowerMode = state.isVirtual() ? hal::PowerMode::ON : hal::PowerMode::OFF;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002540
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -07002541 sp<DisplayDevice> display = getFactory().createDisplayDevice(creationArgs);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002542
2543 if (maxFrameBufferAcquiredBuffers >= 3) {
2544 nativeWindowSurface->preallocateBuffers();
2545 }
2546
2547 ColorMode defaultColorMode = ColorMode::NATIVE;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002548 Dataspace defaultDataSpace = Dataspace::UNKNOWN;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002549 if (display->hasWideColorGamut()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002550 defaultColorMode = ColorMode::SRGB;
Peiyong Lin14724e62018-12-05 07:27:30 -08002551 defaultDataSpace = Dataspace::V0_SRGB;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002552 }
Lloyd Pique6a3b4462019-03-07 20:58:12 -08002553 display->getCompositionDisplay()->setColorProfile(
2554 compositionengine::Output::ColorProfile{defaultColorMode, defaultDataSpace,
2555 RenderIntent::COLORIMETRIC,
2556 Dataspace::UNKNOWN});
Dominik Laskowski075d3172018-05-24 15:50:06 -07002557 if (!state.isVirtual()) {
2558 LOG_ALWAYS_FATAL_IF(!displayId);
Ady Abraham2139f732019-11-13 18:56:40 -08002559 auto activeConfigId = HwcConfigIndexType(getHwComposer().getActiveConfigIndex(*displayId));
2560 display->setActiveConfig(activeConfigId);
Lloyd Pique3c085a02018-05-09 19:38:32 -07002561 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07002562
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002563 display->setLayerStack(state.layerStack);
2564 display->setProjection(state.orientation, state.viewport, state.frame);
2565 display->setDisplayName(state.displayName);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002566
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002567 return display;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002568}
2569
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002570void SurfaceFlinger::processDisplayAdded(const wp<IBinder>& displayToken,
2571 const DisplayDeviceState& state) {
2572 int width = 0;
2573 int height = 0;
2574 ui::PixelFormat pixelFormat = static_cast<ui::PixelFormat>(PIXEL_FORMAT_UNKNOWN);
2575 if (state.physical) {
2576 const auto& activeConfig =
2577 getCompositionEngine().getHwComposer().getActiveConfig(state.physical->id);
2578 width = activeConfig->getWidth();
2579 height = activeConfig->getHeight();
2580 pixelFormat = static_cast<ui::PixelFormat>(PIXEL_FORMAT_RGBA_8888);
2581 } else if (state.surface != nullptr) {
2582 int status = state.surface->query(NATIVE_WINDOW_WIDTH, &width);
2583 ALOGE_IF(status != NO_ERROR, "Unable to query width (%d)", status);
2584 status = state.surface->query(NATIVE_WINDOW_HEIGHT, &height);
2585 ALOGE_IF(status != NO_ERROR, "Unable to query height (%d)", status);
2586 int intPixelFormat;
2587 status = state.surface->query(NATIVE_WINDOW_FORMAT, &intPixelFormat);
2588 ALOGE_IF(status != NO_ERROR, "Unable to query format (%d)", status);
2589 pixelFormat = static_cast<ui::PixelFormat>(intPixelFormat);
2590 } else {
2591 // Virtual displays without a surface are dormant:
2592 // they have external state (layer stack, projection,
2593 // etc.) but no internal state (i.e. a DisplayDevice).
2594 return;
2595 }
2596
2597 compositionengine::DisplayCreationArgsBuilder builder;
2598 if (const auto& physical = state.physical) {
2599 builder.setPhysical({physical->id, physical->type});
2600 }
2601 builder.setPixels(ui::Size(width, height));
2602 builder.setPixelFormat(pixelFormat);
2603 builder.setIsSecure(state.isSecure);
2604 builder.setLayerStackId(state.layerStack);
2605 builder.setPowerAdvisor(&mPowerAdvisor);
2606 builder.setUseHwcVirtualDisplays(mUseHwcVirtualDisplays || getHwComposer().isUsingVrComposer());
2607 builder.setName(state.displayName);
2608 const auto compositionDisplay = getCompositionEngine().createDisplay(builder.build());
2609
2610 sp<compositionengine::DisplaySurface> displaySurface;
2611 sp<IGraphicBufferProducer> producer;
2612 sp<IGraphicBufferProducer> bqProducer;
2613 sp<IGraphicBufferConsumer> bqConsumer;
2614 getFactory().createBufferQueue(&bqProducer, &bqConsumer, /*consumerIsSurfaceFlinger =*/false);
2615
2616 std::optional<DisplayId> displayId = compositionDisplay->getId();
2617
2618 if (state.isVirtual()) {
2619 sp<VirtualDisplaySurface> vds =
2620 new VirtualDisplaySurface(getHwComposer(), displayId, state.surface, bqProducer,
2621 bqConsumer, state.displayName);
2622
2623 displaySurface = vds;
2624 producer = vds;
2625 } else {
2626 ALOGE_IF(state.surface != nullptr,
2627 "adding a supported display, but rendering "
2628 "surface is provided (%p), ignoring it",
2629 state.surface.get());
2630
2631 LOG_ALWAYS_FATAL_IF(!displayId);
2632 displaySurface = new FramebufferSurface(getHwComposer(), *displayId, bqConsumer,
2633 maxGraphicsWidth, maxGraphicsHeight);
2634 producer = bqProducer;
2635 }
2636
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002637 LOG_FATAL_IF(!displaySurface);
2638 const auto display = setupNewDisplayDeviceInternal(displayToken, compositionDisplay, state,
2639 displaySurface, producer);
2640 mDisplays.emplace(displayToken, display);
2641 if (!state.isVirtual()) {
2642 LOG_FATAL_IF(!displayId);
2643 dispatchDisplayHotplugEvent(displayId->value, true);
2644 }
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002645
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002646 if (display->isPrimary()) {
2647 mScheduler->onPrimaryDisplayAreaChanged(display->getWidth() * display->getHeight());
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002648 }
2649}
2650
2651void SurfaceFlinger::processDisplayRemoved(const wp<IBinder>& displayToken) {
2652 if (const auto display = getDisplayDeviceLocked(displayToken)) {
2653 // Save display ID before disconnecting.
2654 const auto displayId = display->getId();
2655 display->disconnect();
2656
2657 if (!display->isVirtual()) {
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002658 LOG_FATAL_IF(!displayId);
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002659 dispatchDisplayHotplugEvent(displayId->value, false);
2660 }
2661 }
2662
2663 mDisplays.erase(displayToken);
2664}
2665
2666void SurfaceFlinger::processDisplayChanged(const wp<IBinder>& displayToken,
2667 const DisplayDeviceState& currentState,
2668 const DisplayDeviceState& drawingState) {
2669 const sp<IBinder> currentBinder = IInterface::asBinder(currentState.surface);
2670 const sp<IBinder> drawingBinder = IInterface::asBinder(drawingState.surface);
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002671 if (currentBinder != drawingBinder || currentState.sequenceId != drawingState.sequenceId) {
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002672 // changing the surface is like destroying and recreating the DisplayDevice
2673 if (const auto display = getDisplayDeviceLocked(displayToken)) {
2674 display->disconnect();
2675 }
2676 mDisplays.erase(displayToken);
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002677 if (const auto& physical = currentState.physical) {
2678 getHwComposer().allocatePhysicalDisplay(physical->hwcDisplayId, physical->id);
2679 }
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002680 processDisplayAdded(displayToken, currentState);
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002681 if (currentState.physical) {
Marin Shalamanov4c5e3012020-06-04 21:41:42 +02002682 const auto display = getDisplayDeviceLocked(displayToken);
2683 setPowerModeInternal(display, hal::PowerMode::ON);
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002684 }
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002685 return;
2686 }
2687
2688 if (const auto display = getDisplayDeviceLocked(displayToken)) {
2689 if (currentState.layerStack != drawingState.layerStack) {
2690 display->setLayerStack(currentState.layerStack);
2691 }
2692 if ((currentState.orientation != drawingState.orientation) ||
2693 (currentState.viewport != drawingState.viewport) ||
2694 (currentState.frame != drawingState.frame)) {
2695 display->setProjection(currentState.orientation, currentState.viewport,
2696 currentState.frame);
2697 }
2698 if (currentState.width != drawingState.width ||
2699 currentState.height != drawingState.height) {
2700 display->setDisplaySize(currentState.width, currentState.height);
Dominik Laskowski20134642020-04-20 22:36:44 -07002701
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002702 if (display->isPrimary()) {
2703 mScheduler->onPrimaryDisplayAreaChanged(currentState.width * currentState.height);
2704 }
Dominik Laskowski20134642020-04-20 22:36:44 -07002705
2706 if (mRefreshRateOverlay) {
2707 mRefreshRateOverlay->setViewport(display->getSize());
2708 }
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002709 }
2710 }
2711}
2712
Lloyd Pique347200f2017-12-14 17:00:15 -08002713void SurfaceFlinger::processDisplayChangesLocked() {
2714 // here we take advantage of Vector's copy-on-write semantics to
2715 // improve performance by skipping the transaction entirely when
2716 // know that the lists are identical
2717 const KeyedVector<wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
2718 const KeyedVector<wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
2719 if (!curr.isIdenticalTo(draw)) {
2720 mVisibleRegionsDirty = true;
Lloyd Pique347200f2017-12-14 17:00:15 -08002721
2722 // find the displays that were removed
2723 // (ie: in drawing state but not in current state)
2724 // also handle displays that changed
2725 // (ie: displays that are in both lists)
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002726 for (size_t i = 0; i < draw.size(); i++) {
2727 const wp<IBinder>& displayToken = draw.keyAt(i);
2728 const ssize_t j = curr.indexOfKey(displayToken);
Lloyd Pique347200f2017-12-14 17:00:15 -08002729 if (j < 0) {
2730 // in drawing state but not in current state
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002731 processDisplayRemoved(displayToken);
Lloyd Pique347200f2017-12-14 17:00:15 -08002732 } else {
2733 // this display is in both lists. see if something changed.
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002734 const DisplayDeviceState& currentState = curr[j];
2735 const DisplayDeviceState& drawingState = draw[i];
2736 processDisplayChanged(displayToken, currentState, drawingState);
Lloyd Pique347200f2017-12-14 17:00:15 -08002737 }
Lloyd Pique347200f2017-12-14 17:00:15 -08002738 }
2739
2740 // find displays that were added
2741 // (ie: in current state but not in drawing state)
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002742 for (size_t i = 0; i < curr.size(); i++) {
2743 const wp<IBinder>& displayToken = curr.keyAt(i);
2744 if (draw.indexOfKey(displayToken) < 0) {
2745 processDisplayAdded(displayToken, curr[i]);
Lloyd Pique347200f2017-12-14 17:00:15 -08002746 }
2747 }
2748 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08002749
2750 mDrawingState.displays = mCurrentState.displays;
Lloyd Pique347200f2017-12-14 17:00:15 -08002751}
2752
Mathias Agopian87baae12012-07-31 12:38:26 -07002753void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
Mathias Agopian3d579642009-06-04 18:46:21 -07002754{
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07002755 const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
2756
Dan Stoza7dde5992015-05-22 09:51:44 -07002757 // Notify all layers of available frames
Edgar Arriaga844fa672020-01-16 14:21:42 -08002758 mCurrentState.traverse([expectedPresentTime](Layer* layer) {
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07002759 layer->notifyAvailableFrames(expectedPresentTime);
Robert Carr2047fae2016-11-28 14:09:09 -08002760 });
Dan Stoza7dde5992015-05-22 09:51:44 -07002761
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002762 /*
2763 * Traversal of the children
2764 * (perform the transaction for each of them if needed)
2765 */
2766
Marissa Wall06255332019-03-27 13:48:27 -07002767 if ((transactionFlags & eTraversalNeeded) || mTraversalNeededMainThread) {
Edgar Arriaga844fa672020-01-16 14:21:42 -08002768 mCurrentState.traverse([&](Layer* layer) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002769 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
Robert Carr2047fae2016-11-28 14:09:09 -08002770 if (!trFlags) return;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002771
2772 const uint32_t flags = layer->doTransaction(0);
2773 if (flags & Layer::eVisibleRegion)
2774 mVisibleRegionsDirty = true;
Robert Carr720e5062018-07-30 17:45:14 -07002775
2776 if (flags & Layer::eInputInfoChanged) {
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002777 mInputInfoChanged = true;
Robert Carr720e5062018-07-30 17:45:14 -07002778 }
Robert Carr2047fae2016-11-28 14:09:09 -08002779 });
Marissa Wall06255332019-03-27 13:48:27 -07002780 mTraversalNeededMainThread = false;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002781 }
2782
2783 /*
Mathias Agopian3559b072012-08-15 13:46:03 -07002784 * Perform display own transactions if needed
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002785 */
2786
Mathias Agopiane57f2922012-08-09 16:29:12 -07002787 if (transactionFlags & eDisplayTransactionNeeded) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002788 processDisplayChangesLocked();
Lloyd Piqueba04e622017-12-14 17:11:26 -08002789 processDisplayHotplugEventsLocked();
Mathias Agopian3559b072012-08-15 13:46:03 -07002790 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002791
Vishnu Nair6213bd92020-05-08 17:42:25 -07002792 if (transactionFlags & (eTransformHintUpdateNeeded | eDisplayTransactionNeeded)) {
Mathias Agopian84300952012-11-21 16:02:13 -08002793 // The transform hint might have changed for some layers
2794 // (either because a display has changed, or because a layer
2795 // as changed).
2796 //
2797 // Walk through all the layers in currentLayers,
2798 // and update their transform hint.
2799 //
2800 // If a layer is visible only on a single display, then that
2801 // display is used to calculate the hint, otherwise we use the
2802 // default display.
2803 //
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002804 // NOTE: we do this here, rather than when presenting the display so that
Mathias Agopian84300952012-11-21 16:02:13 -08002805 // the hint is set before we acquire a buffer from the surface texture.
2806 //
2807 // NOTE: layer transactions have taken place already, so we use their
2808 // drawing state. However, SurfaceFlinger's own transaction has not
2809 // happened yet, so we must use the current state layer list
2810 // (soon to become the drawing state list).
2811 //
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002812 sp<const DisplayDevice> hintDisplay;
Mathias Agopian84300952012-11-21 16:02:13 -08002813 uint32_t currentlayerStack = 0;
Robert Carr2047fae2016-11-28 14:09:09 -08002814 bool first = true;
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002815 mCurrentState.traverse([&](Layer* layer) REQUIRES(mStateLock) {
Mathias Agopian84300952012-11-21 16:02:13 -08002816 // NOTE: we rely on the fact that layers are sorted by
2817 // layerStack first (so we don't have to traverse the list
2818 // of displays for every layer).
Robert Carr1f0a16a2016-10-24 16:27:39 -07002819 uint32_t layerStack = layer->getLayerStack();
Robert Carr2047fae2016-11-28 14:09:09 -08002820 if (first || currentlayerStack != layerStack) {
Mathias Agopian84300952012-11-21 16:02:13 -08002821 currentlayerStack = layerStack;
2822 // figure out if this layerstack is mirrored
2823 // (more than one display) if so, pick the default display,
2824 // if not, pick the only display it's on.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002825 hintDisplay = nullptr;
2826 for (const auto& [token, display] : mDisplays) {
Lloyd Piqueef36b002019-01-23 17:52:04 -08002827 if (display->getCompositionDisplay()
2828 ->belongsInOutput(layer->getLayerStack(),
2829 layer->getPrimaryDisplayOnly())) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002830 if (hintDisplay) {
2831 hintDisplay = nullptr;
Mathias Agopian84300952012-11-21 16:02:13 -08002832 break;
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002833 } else {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002834 hintDisplay = display;
Mathias Agopian84300952012-11-21 16:02:13 -08002835 }
2836 }
2837 }
2838 }
Chet Haase91d25932013-04-11 15:24:55 -07002839
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002840 if (!hintDisplay) {
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002841 // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
2842 // redraw after transform hint changes. See bug 8508397.
Robert Carr56a0b9a2017-12-04 16:06:13 -08002843
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002844 // could be null when this layer is using a layerStack
2845 // that is not visible on any display. Also can occur at
2846 // screen off/on times.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002847 hintDisplay = getDefaultDisplayDeviceLocked();
Mathias Agopian84300952012-11-21 16:02:13 -08002848 }
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002849
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002850 // could be null if there is no display available at all to get
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002851 // the transform hint from.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002852 if (hintDisplay) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -07002853 layer->updateTransformHint(hintDisplay->getTransformHint());
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08002854 }
Robert Carr2047fae2016-11-28 14:09:09 -08002855
2856 first = false;
2857 });
Mathias Agopian84300952012-11-21 16:02:13 -08002858 }
2859
Mathias Agopian3559b072012-08-15 13:46:03 -07002860 /*
2861 * Perform our own transaction if needed
2862 */
Robert Carr1f0a16a2016-10-24 16:27:39 -07002863
2864 if (mLayersAdded) {
2865 mLayersAdded = false;
2866 // Layers have been added.
Mathias Agopian3559b072012-08-15 13:46:03 -07002867 mVisibleRegionsDirty = true;
2868 }
2869
2870 // some layers might have been removed, so
2871 // we need to update the regions they're exposing.
2872 if (mLayersRemoved) {
2873 mLayersRemoved = false;
2874 mVisibleRegionsDirty = true;
Robert Carr2047fae2016-11-28 14:09:09 -08002875 mDrawingState.traverseInZOrder([&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07002876 if (mLayersPendingRemoval.indexOf(layer) >= 0) {
Mathias Agopian3559b072012-08-15 13:46:03 -07002877 // this layer is not visible anymore
Robert Carr1f0a16a2016-10-24 16:27:39 -07002878 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002879 visibleReg.set(layer->getScreenBounds());
Chia-I Wuab0c3192017-08-01 11:29:00 -07002880 invalidateLayerStack(layer, visibleReg);
Mathias Agopian0aa758d2009-04-22 15:23:34 -07002881 }
Robert Carr2047fae2016-11-28 14:09:09 -08002882 });
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002883 }
2884
Vishnu Nairec0ab382019-02-13 15:32:56 -08002885 commitInputWindowCommands();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002886 commitTransaction();
Riley Andrews03414a12014-07-01 14:22:59 -07002887}
2888
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002889void SurfaceFlinger::updateInputFlinger() {
Robert Carr720e5062018-07-30 17:45:14 -07002890 ATRACE_CALL();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002891 if (!mInputFlinger) {
Vishnu Nairde19f852018-12-18 16:11:53 -08002892 return;
2893 }
2894
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002895 if (mVisibleRegionsDirty || mInputInfoChanged) {
2896 mInputInfoChanged = false;
2897 updateInputWindowInfo();
chaviw95ef3c42019-02-14 10:55:09 -08002898 } else if (mInputWindowCommands.syncInputWindows) {
2899 // If the caller requested to sync input windows, but there are no
2900 // changes to input windows, notify immediately.
2901 setInputWindowsFinished();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002902 }
2903
Arthur Hung6cbb9752019-09-05 16:38:18 +08002904 mInputWindowCommands.clear();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002905}
2906
2907void SurfaceFlinger::updateInputWindowInfo() {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002908 std::vector<InputWindowInfo> inputHandles;
Robert Carr720e5062018-07-30 17:45:14 -07002909
2910 mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
Robert Carredd13602020-04-13 17:24:34 -07002911 if (layer->needsInputInfo()) {
Vishnu Nair51625fa2018-12-06 13:54:33 -08002912 // When calculating the screen bounds we ignore the transparent region since it may
2913 // result in an unwanted offset.
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002914 inputHandles.push_back(layer->fillInputInfo());
Robert Carr720e5062018-07-30 17:45:14 -07002915 }
2916 });
chaviw291d88a2019-02-14 10:33:58 -08002917
2918 mInputFlinger->setInputWindows(inputHandles,
2919 mInputWindowCommands.syncInputWindows ? mSetInputWindowsListener
2920 : nullptr);
Robert Carr720e5062018-07-30 17:45:14 -07002921}
2922
Vishnu Nairec0ab382019-02-13 15:32:56 -08002923void SurfaceFlinger::commitInputWindowCommands() {
Rob Carr9a2cc992020-03-06 12:44:45 -08002924 mInputWindowCommands.merge(mPendingInputWindowCommands);
Vishnu Nairec0ab382019-02-13 15:32:56 -08002925 mPendingInputWindowCommands.clear();
2926}
2927
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002928void SurfaceFlinger::updateCursorAsync() {
Lloyd Piquec7b0c752019-03-07 20:59:59 -08002929 compositionengine::CompositionRefreshArgs refreshArgs;
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002930 for (const auto& [_, display] : ON_MAIN_THREAD(mDisplays)) {
Lloyd Piquec7b0c752019-03-07 20:59:59 -08002931 if (display->getId()) {
2932 refreshArgs.outputs.push_back(display->getCompositionDisplay());
Riley Andrews03414a12014-07-01 14:22:59 -07002933 }
2934 }
Lloyd Piquec7b0c752019-03-07 20:59:59 -08002935
2936 mCompositionEngine->updateCursorAsync(refreshArgs);
Mathias Agopian4fec8732012-06-29 14:12:52 -07002937}
2938
Ady Abraham2139f732019-11-13 18:56:40 -08002939void SurfaceFlinger::changeRefreshRate(const RefreshRate& refreshRate,
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07002940 Scheduler::ConfigEvent event) {
Ady Abraham8a82ba62020-01-17 12:43:17 -08002941 // If this is called from the main thread mStateLock must be locked before
2942 // Currently the only way to call this function from the main thread is from
2943 // Sheduler::chooseRefreshRateForContent
2944
2945 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
Ady Abraham2139f732019-11-13 18:56:40 -08002946 changeRefreshRateLocked(refreshRate, event);
2947}
2948
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002949void SurfaceFlinger::initScheduler(DisplayId primaryDisplayId) {
2950 if (mScheduler) {
2951 // In practice it's not allowed to hotplug in/out the primary display once it's been
2952 // connected during startup, but some tests do it, so just warn and return.
2953 ALOGW("Can't re-init scheduler");
2954 return;
2955 }
2956
Ady Abraham2139f732019-11-13 18:56:40 -08002957 auto currentConfig = HwcConfigIndexType(getHwComposer().getActiveConfigIndex(primaryDisplayId));
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002958 mRefreshRateConfigs =
Ana Krulec3f6a2062020-01-23 15:48:01 -08002959 std::make_unique<scheduler::RefreshRateConfigs>(getHwComposer().getConfigs(
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002960 primaryDisplayId),
2961 currentConfig);
2962 mRefreshRateStats =
2963 std::make_unique<scheduler::RefreshRateStats>(*mRefreshRateConfigs, *mTimeStats,
Peiyong Lin65248e02020-04-18 21:15:07 -07002964 currentConfig, hal::PowerMode::OFF);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002965 mRefreshRateStats->setConfigMode(currentConfig);
2966
Ady Abraham9e16a482019-12-03 17:19:41 -08002967 mPhaseConfiguration = getFactory().createPhaseConfiguration(*mRefreshRateConfigs);
2968
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002969 // start the EventThread
2970 mScheduler =
2971 getFactory().createScheduler([this](bool enabled) { setPrimaryVsyncEnabled(enabled); },
Ady Abraham3a77a7b2019-12-02 18:46:59 -08002972 *mRefreshRateConfigs, *this);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002973 mAppConnectionHandle =
Ady Abraham9e16a482019-12-03 17:19:41 -08002974 mScheduler->createConnection("app", mPhaseConfiguration->getCurrentOffsets().late.app,
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002975 impl::EventThread::InterceptVSyncsCallback());
2976 mSfConnectionHandle =
Ady Abraham9e16a482019-12-03 17:19:41 -08002977 mScheduler->createConnection("sf", mPhaseConfiguration->getCurrentOffsets().late.sf,
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002978 [this](nsecs_t timestamp) {
2979 mInterceptor->saveVSyncEvent(timestamp);
2980 });
2981
2982 mEventQueue->setEventConnection(mScheduler->getEventConnection(mSfConnectionHandle));
2983 mVSyncModulator.emplace(*mScheduler, mAppConnectionHandle, mSfConnectionHandle,
Ady Abraham9e16a482019-12-03 17:19:41 -08002984 mPhaseConfiguration->getCurrentOffsets());
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002985
2986 mRegionSamplingThread =
2987 new RegionSamplingThread(*this, *mScheduler,
2988 RegionSamplingThread::EnvironmentTimingTunables());
Alec Mouri60aee1c2019-10-28 16:18:59 -07002989 // Dispatch a config change request for the primary display on scheduler
2990 // initialization, so that the EventThreads always contain a reference to a
2991 // prior configuration.
2992 //
2993 // This is a bit hacky, but this avoids a back-pointer into the main SF
2994 // classes from EventThread, and there should be no run-time binder cost
2995 // anyway since there are no connected apps at this point.
2996 const nsecs_t vsyncPeriod =
Ady Abrahamabc27602020-04-08 17:20:29 -07002997 mRefreshRateConfigs->getRefreshRateFromConfigId(currentConfig).getVsyncPeriod();
Ady Abrahamdfd62162020-06-10 16:11:56 -07002998 mScheduler->onPrimaryDisplayConfigChanged(mAppConnectionHandle, primaryDisplayId.value,
2999 currentConfig, vsyncPeriod);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003000}
3001
Mathias Agopian4fec8732012-06-29 14:12:52 -07003002void SurfaceFlinger::commitTransaction()
3003{
Vishnu Nair60db8c02020-04-02 11:55:16 -07003004 commitTransactionLocked();
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003005 mTransactionPending = false;
3006 mAnimTransactionPending = false;
Mathias Agopian4fec8732012-06-29 14:12:52 -07003007 mTransactionCV.broadcast();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003008}
3009
Lloyd Pique58e24a32019-08-01 15:50:14 -07003010void SurfaceFlinger::commitTransactionLocked() {
3011 if (!mLayersPendingRemoval.isEmpty()) {
3012 // Notify removed layers now that they can't be drawn from
3013 for (const auto& l : mLayersPendingRemoval) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003014 recordBufferingStats(l->getName(), l->getOccupancyHistory(true));
Lloyd Pique58e24a32019-08-01 15:50:14 -07003015
3016 // Ensure any buffers set to display on any children are released.
3017 if (l->isRemovedFromCurrentState()) {
3018 l->latchAndReleaseBuffer();
3019 }
3020
3021 // If the layer has been removed and has no parent, then it will not be reachable
3022 // when traversing layers on screen. Add the layer to the offscreenLayers set to
3023 // ensure we can copy its current to drawing state.
3024 if (!l->getParent()) {
3025 mOffscreenLayers.emplace(l.get());
3026 }
3027 }
3028 mLayersPendingRemoval.clear();
3029 }
3030
3031 // If this transaction is part of a window animation then the next frame
3032 // we composite should be considered an animation as well.
3033 mAnimCompositionPending = mAnimTransactionPending;
3034
3035 mDrawingState = mCurrentState;
3036 // clear the "changed" flags in current state
3037 mCurrentState.colorMatrixChanged = false;
3038
Edgar Arriaga844fa672020-01-16 14:21:42 -08003039 mDrawingState.traverse([&](Layer* layer) {
Lloyd Pique58e24a32019-08-01 15:50:14 -07003040 layer->commitChildList();
3041
3042 // If the layer can be reached when traversing mDrawingState, then the layer is no
3043 // longer offscreen. Remove the layer from the offscreenLayer set.
3044 if (mOffscreenLayers.count(layer)) {
3045 mOffscreenLayers.erase(layer);
3046 }
3047 });
3048
3049 commitOffscreenLayers();
Edgar Arriaga844fa672020-01-16 14:21:42 -08003050 mDrawingState.traverse([&](Layer* layer) { layer->updateMirrorInfo(); });
Lloyd Pique58e24a32019-08-01 15:50:14 -07003051}
3052
chaviw74d90ad2019-04-26 14:45:26 -07003053void SurfaceFlinger::commitOffscreenLayers() {
3054 for (Layer* offscreenLayer : mOffscreenLayers) {
Edgar Arriaga844fa672020-01-16 14:21:42 -08003055 offscreenLayer->traverse(LayerVector::StateSet::Drawing, [](Layer* layer) {
chaviw74d90ad2019-04-26 14:45:26 -07003056 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
3057 if (!trFlags) return;
3058
3059 layer->doTransaction(0);
3060 layer->commitChildList();
3061 });
3062 }
3063}
3064
Chia-I Wuab0c3192017-08-01 11:29:00 -07003065void SurfaceFlinger::invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty) {
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07003066 for (const auto& [token, displayDevice] : ON_MAIN_THREAD(mDisplays)) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003067 auto display = displayDevice->getCompositionDisplay();
Lloyd Piqueef36b002019-01-23 17:52:04 -08003068 if (display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003069 display->editState().dirtyRegion.orSelf(dirty);
Mathias Agopian92a979a2012-08-02 18:32:23 -07003070 }
3071 }
Mathias Agopian87baae12012-07-31 12:38:26 -07003072}
3073
Dan Stoza6b9454d2014-11-07 16:00:59 -08003074bool SurfaceFlinger::handlePageFlip()
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003075{
Ady Abraham09bd3922019-04-08 10:44:56 -07003076 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08003077 ALOGV("handlePageFlip");
3078
Brian Andersond6927fb2016-07-23 23:37:30 -07003079 nsecs_t latchTime = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003080
Mathias Agopian4fec8732012-06-29 14:12:52 -07003081 bool visibleRegions = false;
Dan Stoza6b9454d2014-11-07 16:00:59 -08003082 bool frameQueued = false;
Mike Stroyan0cd76192017-04-20 12:10:48 -06003083 bool newDataLatched = false;
Eric Penner51c59cd2014-07-28 19:51:58 -07003084
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003085 const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
3086
Eric Penner51c59cd2014-07-28 19:51:58 -07003087 // Store the set of layers that need updates. This set must not change as
3088 // buffers are being latched, as this could result in a deadlock.
3089 // Example: Two producers share the same command stream and:
3090 // 1.) Layer 0 is latched
3091 // 2.) Layer 0 gets a new frame
3092 // 2.) Layer 1 gets a new frame
3093 // 3.) Layer 1 is latched.
3094 // Display is now waiting on Layer 1's frame, which is behind layer 0's
3095 // second frame. But layer 0's second frame could be waiting on display.
Edgar Arriaga844fa672020-01-16 14:21:42 -08003096 mDrawingState.traverse([&](Layer* layer) {
Marissa Wallfd668622018-05-10 10:21:13 -07003097 if (layer->hasReadyFrame()) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08003098 frameQueued = true;
Ana Krulec010d2192018-10-08 06:29:54 -07003099 if (layer->shouldPresentNow(expectedPresentTime)) {
Robert Carr2047fae2016-11-28 14:09:09 -08003100 mLayersWithQueuedFrames.push_back(layer);
Dan Stozaee44edd2015-03-23 15:50:23 -07003101 } else {
Ady Abraham09bd3922019-04-08 10:44:56 -07003102 ATRACE_NAME("!layer->shouldPresentNow()");
Dan Stozaee44edd2015-03-23 15:50:23 -07003103 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08003104 }
Dan Stozaee44edd2015-03-23 15:50:23 -07003105 } else {
3106 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08003107 }
Robert Carr2047fae2016-11-28 14:09:09 -08003108 });
3109
chaviw49a108c2019-08-12 11:23:06 -07003110 // The client can continue submitting buffers for offscreen layers, but they will not
3111 // be shown on screen. Therefore, we need to latch and release buffers of offscreen
3112 // layers to ensure dequeueBuffer doesn't block indefinitely.
3113 for (Layer* offscreenLayer : mOffscreenLayers) {
Edgar Arriaga844fa672020-01-16 14:21:42 -08003114 offscreenLayer->traverse(LayerVector::StateSet::Drawing,
chaviw49a108c2019-08-12 11:23:06 -07003115 [&](Layer* l) { l->latchAndReleaseBuffer(); });
3116 }
3117
Lloyd Piquef2c79392018-12-20 16:23:33 -08003118 if (!mLayersWithQueuedFrames.empty()) {
3119 // mStateLock is needed for latchBuffer as LayerRejecter::reject()
3120 // writes to Layer current state. See also b/119481871
3121 Mutex::Autolock lock(mStateLock);
3122
3123 for (auto& layer : mLayersWithQueuedFrames) {
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003124 if (layer->latchBuffer(visibleRegions, latchTime, expectedPresentTime)) {
Vishnu Nair6194e2e2019-02-06 12:58:39 -08003125 mLayersPendingRefresh.push_back(layer);
3126 }
Lloyd Piquef2c79392018-12-20 16:23:33 -08003127 layer->useSurfaceDamage();
Lloyd Piquef2c79392018-12-20 16:23:33 -08003128 if (layer->isBufferLatched()) {
3129 newDataLatched = true;
3130 }
Mike Stroyan0cd76192017-04-20 12:10:48 -06003131 }
Mathias Agopian4fec8732012-06-29 14:12:52 -07003132 }
Mathias Agopian4da75192010-08-10 17:19:56 -07003133
Mathias Agopian3b1d2b62012-07-11 13:48:17 -07003134 mVisibleRegionsDirty |= visibleRegions;
Dan Stoza6b9454d2014-11-07 16:00:59 -08003135
3136 // If we will need to wake up at some time in the future to deal with a
3137 // queued frame that shouldn't be displayed during this vsync period, wake
3138 // up during the next vsync period to check again.
Chia-I Wua36bf922017-06-30 12:51:05 -07003139 if (frameQueued && (mLayersWithQueuedFrames.empty() || !newDataLatched)) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08003140 signalLayerUpdate();
3141 }
3142
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08003143 // enter boot animation on first buffer latch
3144 if (CC_UNLIKELY(mBootStage == BootStage::BOOTLOADER && newDataLatched)) {
3145 ALOGI("Enter boot animation");
3146 mBootStage = BootStage::BOOTANIMATION;
3147 }
3148
Edgar Arriaga844fa672020-01-16 14:21:42 -08003149 mDrawingState.traverse([&](Layer* layer) { layer->updateCloneBufferInfo(); });
chaviw74b03172019-08-19 11:09:03 -07003150
Dan Stoza6b9454d2014-11-07 16:00:59 -08003151 // Only continue with the refresh if there is actually new work to do
Mike Stroyan0cd76192017-04-20 12:10:48 -06003152 return !mLayersWithQueuedFrames.empty() && newDataLatched;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003153}
3154
Mathias Agopianad456f92011-01-13 17:53:01 -08003155void SurfaceFlinger::invalidateHwcGeometry()
3156{
Dan Stoza9e56aa02015-11-02 13:00:03 -08003157 mGeometryInvalid = true;
Mathias Agopianad456f92011-01-13 17:53:01 -08003158}
3159
Robert Carrc0df3122019-04-11 13:18:21 -07003160status_t SurfaceFlinger::addClientLayer(const sp<Client>& client, const sp<IBinder>& handle,
3161 const sp<IGraphicBufferProducer>& gbc, const sp<Layer>& lbc,
3162 const sp<IBinder>& parentHandle,
Vishnu Nair6213bd92020-05-08 17:42:25 -07003163 const sp<Layer>& parentLayer, bool addToCurrentState,
3164 uint32_t* outTransformHint) {
Dan Stoza7d89d062015-04-30 13:29:25 -07003165 // add this layer to the current state list
3166 {
3167 Mutex::Autolock _l(mStateLock);
Robert Carrc0df3122019-04-11 13:18:21 -07003168 sp<Layer> parent;
3169 if (parentHandle != nullptr) {
Alec Mouri9a02eda2020-04-21 17:39:34 -07003170 parent = fromHandleLocked(parentHandle).promote();
Robert Carrc0df3122019-04-11 13:18:21 -07003171 if (parent == nullptr) {
3172 return NAME_NOT_FOUND;
3173 }
3174 } else {
3175 parent = parentLayer;
3176 }
3177
Ady Abraham0a525092020-03-03 12:51:24 -08003178 if (mNumLayers >= ISurfaceComposer::MAX_LAYERS) {
chaviweadf0d42019-08-12 13:28:29 -07003179 ALOGE("AddClientLayer failed, mNumLayers (%zu) >= MAX_LAYERS (%zu)", mNumLayers.load(),
Ady Abraham0a525092020-03-03 12:51:24 -08003180 ISurfaceComposer::MAX_LAYERS);
Dan Stoza7d89d062015-04-30 13:29:25 -07003181 return NO_MEMORY;
3182 }
Robert Carrc0df3122019-04-11 13:18:21 -07003183
3184 mLayersByLocalBinderToken.emplace(handle->localBinder(), lbc);
3185
Robert Carrb89ea9d2018-12-10 13:01:14 -08003186 if (parent == nullptr && addToCurrentState) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003187 mCurrentState.layersSortedByZ.add(lbc);
chaviwac841852019-01-16 16:04:43 -08003188 } else if (parent == nullptr) {
3189 lbc->onRemovedFromCurrentState();
3190 } else if (parent->isRemovedFromCurrentState()) {
3191 parent->addChild(lbc);
3192 lbc->onRemovedFromCurrentState();
Robert Carrb89ea9d2018-12-10 13:01:14 -08003193 } else {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003194 parent->addChild(lbc);
3195 }
Chia-I Wu98f1c102017-05-30 14:54:08 -07003196
Yiwei Zhang243b3782018-05-15 17:40:04 -07003197 if (gbc != nullptr) {
3198 mGraphicBufferProducerList.insert(IInterface::asBinder(gbc).get());
3199 LOG_ALWAYS_FATAL_IF(mGraphicBufferProducerList.size() >
3200 mMaxGraphicBufferProducerListSize,
3201 "Suspected IGBP leak: %zu IGBPs (%zu max), %zu Layers",
3202 mGraphicBufferProducerList.size(),
chaviweadf0d42019-08-12 13:28:29 -07003203 mMaxGraphicBufferProducerListSize, mNumLayers.load());
Yiwei Zhang243b3782018-05-15 17:40:04 -07003204 }
Vishnu Nair6213bd92020-05-08 17:42:25 -07003205
3206 if (const auto display = getDefaultDisplayDeviceLocked()) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -07003207 lbc->updateTransformHint(display->getTransformHint());
Vishnu Nair6213bd92020-05-08 17:42:25 -07003208 }
3209 if (outTransformHint) {
3210 *outTransformHint = lbc->getTransformHint();
3211 }
3212
Robert Carr1f0a16a2016-10-24 16:27:39 -07003213 mLayersAdded = true;
Dan Stoza7d89d062015-04-30 13:29:25 -07003214 }
3215
Mathias Agopian96f08192010-06-02 23:28:45 -07003216 // attach this layer to the client
Mathias Agopianac9fa422013-02-11 16:40:36 -08003217 client->attachLayer(handle, lbc);
Mathias Agopian4f113742011-05-03 16:21:41 -07003218
Dan Stoza7d89d062015-04-30 13:29:25 -07003219 return NO_ERROR;
Mathias Agopian96f08192010-06-02 23:28:45 -07003220}
3221
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07003222void SurfaceFlinger::removeGraphicBufferProducerAsync(const wp<IBinder>& binder) {
3223 static_cast<void>(schedule([=] {
3224 Mutex::Autolock lock(mStateLock);
3225 mGraphicBufferProducerList.erase(binder);
3226 }));
3227}
3228
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08003229uint32_t SurfaceFlinger::peekTransactionFlags() {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003230 return mTransactionFlags;
Mathias Agopiandea20b12011-05-03 17:04:02 -07003231}
3232
Mathias Agopian3f844832013-08-07 21:24:32 -07003233uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003234 return mTransactionFlags.fetch_and(~flags) & flags;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003235}
3236
Mathias Agopian3f844832013-08-07 21:24:32 -07003237uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) {
Ady Abrahambf1349c2020-06-12 14:26:18 -07003238 return setTransactionFlags(flags, Scheduler::TransactionStart::Normal);
Dan Stoza84d619e2018-03-28 17:07:36 -07003239}
3240
3241uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags,
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003242 Scheduler::TransactionStart transactionStart) {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003243 uint32_t old = mTransactionFlags.fetch_or(flags);
Dominik Laskowskieddeda12019-07-19 11:54:13 -07003244 mVSyncModulator->setTransactionStart(transactionStart);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003245 if ((old & flags)==0) { // wake the server up
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08003246 signalTransaction();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003247 }
3248 return old;
3249}
3250
Robert Carr7ec777d2020-05-29 12:02:51 -07003251uint32_t SurfaceFlinger::setTransactionFlagsNoWake(uint32_t flags) {
3252 return mTransactionFlags.fetch_or(flags);
3253}
3254
Marissa Wall713b63f2018-10-17 15:42:43 -07003255bool SurfaceFlinger::flushTransactionQueues() {
Valerie Haufce31b82019-04-30 16:41:14 -07003256 // to prevent onHandleDestroyed from being called while the lock is held,
3257 // we must keep a copy of the transactions (specifically the composer
3258 // states) around outside the scope of the lock
3259 std::vector<const TransactionState> transactions;
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003260 bool flushedATransaction = false;
Valerie Haufce31b82019-04-30 16:41:14 -07003261 {
3262 Mutex::Autolock _l(mStateLock);
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003263
Valerie Haufce31b82019-04-30 16:41:14 -07003264 auto it = mTransactionQueues.begin();
3265 while (it != mTransactionQueues.end()) {
3266 auto& [applyToken, transactionQueue] = *it;
Marissa Wall713b63f2018-10-17 15:42:43 -07003267
Valerie Haufce31b82019-04-30 16:41:14 -07003268 while (!transactionQueue.empty()) {
3269 const auto& transaction = transactionQueue.front();
3270 if (!transactionIsReadyToBeApplied(transaction.desiredPresentTime,
3271 transaction.states)) {
3272 setTransactionFlags(eTransactionFlushNeeded);
3273 break;
3274 }
3275 transactions.push_back(transaction);
3276 applyTransactionState(transaction.states, transaction.displays, transaction.flags,
3277 mPendingInputWindowCommands, transaction.desiredPresentTime,
Valerie Hau9dab9732019-08-20 09:29:25 -07003278 transaction.buffer, transaction.postTime,
3279 transaction.privileged, transaction.hasListenerCallbacks,
3280 transaction.listenerCallbacks, /*isMainThread*/ true);
Valerie Haufce31b82019-04-30 16:41:14 -07003281 transactionQueue.pop();
3282 flushedATransaction = true;
Marissa Wall713b63f2018-10-17 15:42:43 -07003283 }
Marissa Wall713b63f2018-10-17 15:42:43 -07003284
Valerie Haufce31b82019-04-30 16:41:14 -07003285 if (transactionQueue.empty()) {
3286 it = mTransactionQueues.erase(it);
3287 mTransactionCV.broadcast();
3288 } else {
Valerie Haue5562ec2019-05-14 12:39:16 -07003289 it = std::next(it, 1);
Valerie Haufce31b82019-04-30 16:41:14 -07003290 }
Valerie Hauf6016b62019-03-28 10:49:59 -07003291 }
Marissa Wall713b63f2018-10-17 15:42:43 -07003292 }
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003293 return flushedATransaction;
3294}
3295
3296bool SurfaceFlinger::transactionFlushNeeded() {
3297 return !mTransactionQueues.empty();
Marissa Wall713b63f2018-10-17 15:42:43 -07003298}
3299
chaviwca27f252018-02-06 16:46:39 -08003300
Marissa Wall17b4e452018-12-26 16:32:34 -08003301bool SurfaceFlinger::transactionIsReadyToBeApplied(int64_t desiredPresentTime,
3302 const Vector<ComposerState>& states) {
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003303
3304 const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
Marissa Wall17b4e452018-12-26 16:32:34 -08003305 // Do not present if the desiredPresentTime has not passed unless it is more than one second
3306 // in the future. We ignore timestamps more than 1 second in the future for stability reasons.
3307 if (desiredPresentTime >= 0 && desiredPresentTime >= expectedPresentTime &&
3308 desiredPresentTime < expectedPresentTime + s2ns(1)) {
3309 return false;
3310 }
3311
Marissa Wall713b63f2018-10-17 15:42:43 -07003312 for (const ComposerState& state : states) {
3313 const layer_state_t& s = state.state;
3314 if (!(s.what & layer_state_t::eAcquireFenceChanged)) {
3315 continue;
3316 }
3317 if (s.acquireFence && s.acquireFence->getStatus() == Fence::Status::Unsignaled) {
Marissa Wall17b4e452018-12-26 16:32:34 -08003318 return false;
Marissa Wall713b63f2018-10-17 15:42:43 -07003319 }
3320 }
Marissa Wall17b4e452018-12-26 16:32:34 -08003321 return true;
Marissa Wall713b63f2018-10-17 15:42:43 -07003322}
3323
Valerie Hau9dab9732019-08-20 09:29:25 -07003324void SurfaceFlinger::setTransactionState(
3325 const Vector<ComposerState>& states, const Vector<DisplayState>& displays, uint32_t flags,
3326 const sp<IBinder>& applyToken, const InputWindowCommands& inputWindowCommands,
3327 int64_t desiredPresentTime, const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
3328 const std::vector<ListenerCallbacks>& listenerCallbacks) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003329 ATRACE_CALL();
Robert Carr14167e02019-02-13 13:50:55 -08003330
Valerie Haubc6ddb12019-03-08 11:10:15 -08003331 const int64_t postTime = systemTime();
3332
Robert Carr14167e02019-02-13 13:50:55 -08003333 bool privileged = callingThreadHasUnscopedSurfaceFlingerAccess();
3334
Mathias Agopian698c0872011-06-28 19:09:31 -07003335 Mutex::Autolock _l(mStateLock);
Mathias Agopiane57f2922012-08-09 16:29:12 -07003336
Marissa Wall713b63f2018-10-17 15:42:43 -07003337 // If its TransactionQueue already has a pending TransactionState or if it is pending
Valerie Hauf6016b62019-03-28 10:49:59 -07003338 auto itr = mTransactionQueues.find(applyToken);
3339 // if this is an animation frame, wait until prior animation frame has
3340 // been applied by SF
3341 if (flags & eAnimation) {
3342 while (itr != mTransactionQueues.end()) {
3343 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
3344 if (CC_UNLIKELY(err != NO_ERROR)) {
3345 ALOGW_IF(err == TIMED_OUT,
3346 "setTransactionState timed out "
3347 "waiting for animation frame to apply");
3348 break;
3349 }
3350 itr = mTransactionQueues.find(applyToken);
3351 }
3352 }
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003353
Ady Abraham5facfb12020-04-22 15:18:31 -07003354 const bool pendingTransactions = itr != mTransactionQueues.end();
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003355 // Expected present time is computed and cached on invalidate, so it may be stale.
Ady Abraham5facfb12020-04-22 15:18:31 -07003356 if (!pendingTransactions) {
3357 mExpectedPresentTime = calculateExpectedPresentTime(systemTime());
3358 }
3359
3360 if (pendingTransactions || !transactionIsReadyToBeApplied(desiredPresentTime, states)) {
Robert Carr14167e02019-02-13 13:50:55 -08003361 mTransactionQueues[applyToken].emplace(states, displays, flags, desiredPresentTime,
Valerie Hau9dab9732019-08-20 09:29:25 -07003362 uncacheBuffer, postTime, privileged,
3363 hasListenerCallbacks, listenerCallbacks);
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003364 setTransactionFlags(eTransactionFlushNeeded);
Marissa Wall713b63f2018-10-17 15:42:43 -07003365 return;
3366 }
3367
Valerie Haubc6ddb12019-03-08 11:10:15 -08003368 applyTransactionState(states, displays, flags, inputWindowCommands, desiredPresentTime,
Valerie Hau9dab9732019-08-20 09:29:25 -07003369 uncacheBuffer, postTime, privileged, hasListenerCallbacks,
3370 listenerCallbacks);
Marissa Wall713b63f2018-10-17 15:42:43 -07003371}
3372
Valerie Hau9dab9732019-08-20 09:29:25 -07003373void SurfaceFlinger::applyTransactionState(
3374 const Vector<ComposerState>& states, const Vector<DisplayState>& displays, uint32_t flags,
3375 const InputWindowCommands& inputWindowCommands, const int64_t desiredPresentTime,
3376 const client_cache_t& uncacheBuffer, const int64_t postTime, bool privileged,
3377 bool hasListenerCallbacks, const std::vector<ListenerCallbacks>& listenerCallbacks,
3378 bool isMainThread) {
Marissa Wall713b63f2018-10-17 15:42:43 -07003379 uint32_t transactionFlags = 0;
3380
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003381 if (flags & eAnimation) {
3382 // For window updates that are part of an animation we must wait for
3383 // previous animation "frames" to be handled.
Valerie Hau38448362019-04-11 14:49:33 -07003384 while (!isMainThread && mAnimTransactionPending) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003385 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003386 if (CC_UNLIKELY(err != NO_ERROR)) {
3387 // just in case something goes wrong in SF, return to the
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003388 // caller after a few seconds.
3389 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out "
3390 "waiting for previous animation frame");
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003391 mAnimTransactionPending = false;
3392 break;
3393 }
3394 }
3395 }
3396
chaviwca27f252018-02-06 16:46:39 -08003397 for (const DisplayState& display : displays) {
3398 transactionFlags |= setDisplayStateLocked(display);
Jamie Gennisb8d69a52011-10-10 15:48:06 -07003399 }
3400
Valerie Hau9dab9732019-08-20 09:29:25 -07003401 // start and end registration for listeners w/ no surface so they can get their callback. Note
3402 // that listeners with SurfaceControls will start registration during setClientStateLocked
3403 // below.
3404 for (const auto& listener : listenerCallbacks) {
3405 mTransactionCompletedThread.startRegistration(listener);
3406 mTransactionCompletedThread.endRegistration(listener);
Marissa Walld600d572019-03-26 15:38:50 -07003407 }
3408
Valerie Hau9dab9732019-08-20 09:29:25 -07003409 std::unordered_set<ListenerCallbacks, ListenerCallbacksHash> listenerCallbacksWithSurfaces;
Marissa Walle2ffb422018-10-12 11:33:52 -07003410 uint32_t clientStateFlags = 0;
chaviwca27f252018-02-06 16:46:39 -08003411 for (const ComposerState& state : states) {
Valerie Hau9dab9732019-08-20 09:29:25 -07003412 clientStateFlags |= setClientStateLocked(state, desiredPresentTime, postTime, privileged,
3413 listenerCallbacksWithSurfaces);
Ady Abraham5def7332020-05-29 16:13:47 -07003414 if ((flags & eAnimation) && state.state.surface) {
3415 if (const auto layer = fromHandleLocked(state.state.surface).promote(); layer) {
3416 mScheduler->recordLayerHistory(layer.get(), desiredPresentTime,
3417 LayerHistory::LayerUpdateType::AnimationTX);
3418 }
3419 }
Marissa Wall3dad52d2019-03-22 14:03:19 -07003420 }
3421
Valerie Hau9dab9732019-08-20 09:29:25 -07003422 for (const auto& listenerCallback : listenerCallbacksWithSurfaces) {
Marissa Wallefb71af2019-06-27 14:45:53 -07003423 mTransactionCompletedThread.endRegistration(listenerCallback);
3424 }
3425
Marissa Walle2ffb422018-10-12 11:33:52 -07003426 // If the state doesn't require a traversal and there are callbacks, send them now
Valerie Hau9dab9732019-08-20 09:29:25 -07003427 if (!(clientStateFlags & eTraversalNeeded) && hasListenerCallbacks) {
Marissa Walle2ffb422018-10-12 11:33:52 -07003428 mTransactionCompletedThread.sendCallbacks();
3429 }
3430 transactionFlags |= clientStateFlags;
chaviwca27f252018-02-06 16:46:39 -08003431
chaviw273171b2018-12-26 11:46:30 -08003432 transactionFlags |= addInputWindowCommands(inputWindowCommands);
3433
Marissa Wall947d34e2019-03-29 14:03:53 -07003434 if (uncacheBuffer.isValid()) {
3435 ClientCache::getInstance().erase(uncacheBuffer);
Alec Mouri4545a8a2019-08-08 20:05:32 -07003436 getRenderEngine().unbindExternalTextureBuffer(uncacheBuffer.id);
Marissa Wall78b72202019-03-15 14:58:34 -07003437 }
3438
Jorim Jaggibdcf09c2017-08-08 15:22:08 +02003439 // If a synchronous transaction is explicitly requested without any changes, force a transaction
3440 // anyway. This can be used as a flush mechanism for previous async transactions.
3441 // Empty animation transaction can be used to simulate back-pressure, so also force a
3442 // transaction for empty animation transactions.
3443 if (transactionFlags == 0 &&
3444 ((flags & eSynchronous) || (flags & eAnimation))) {
Robert Carr2a7dbb42016-05-24 11:41:28 -07003445 transactionFlags = eTransactionNeeded;
3446 }
3447
Marissa Wall06255332019-03-27 13:48:27 -07003448 // If we are on the main thread, we are about to preform a traversal. Clear the traversal bit
3449 // so we don't have to wake up again next frame to preform an uneeded traversal.
3450 if (isMainThread && (transactionFlags & eTraversalNeeded)) {
3451 transactionFlags = transactionFlags & (~eTraversalNeeded);
3452 mTraversalNeededMainThread = true;
3453 }
3454
Ady Abrahambf1349c2020-06-12 14:26:18 -07003455 const auto transactionStart = [](uint32_t flags) {
3456 if (flags & eEarlyWakeup) {
3457 return Scheduler::TransactionStart::Early;
3458 }
3459 if (flags & eExplicitEarlyWakeupEnd) {
3460 return Scheduler::TransactionStart::EarlyEnd;
3461 }
3462 if (flags & eExplicitEarlyWakeupStart) {
3463 return Scheduler::TransactionStart::EarlyStart;
3464 }
3465 return Scheduler::TransactionStart::Normal;
3466 }(flags);
3467
Mathias Agopian386aa982011-11-07 21:58:03 -08003468 if (transactionFlags) {
Lloyd Pique4dccc412018-01-22 17:21:36 -08003469 if (mInterceptor->isEnabled()) {
3470 mInterceptor->saveTransaction(states, mCurrentState.displays, displays, flags);
Irvelffc9efc2016-07-27 15:16:37 -07003471 }
Irvel468051e2016-06-13 16:44:44 -07003472
Ady Abrahambf1349c2020-06-12 14:26:18 -07003473 // TODO(b/159125966): Remove eEarlyWakeup completly as no client should use this flag
3474 if (flags & eEarlyWakeup) {
3475 ALOGW("eEarlyWakeup is deprecated. Use eExplicitEarlyWakeup[Start|End]");
3476 }
3477
3478 if (!privileged && (flags & (eExplicitEarlyWakeupStart | eExplicitEarlyWakeupEnd))) {
3479 ALOGE("Only WindowManager is allowed to use eExplicitEarlyWakeup[Start|End] flags");
3480 flags &= ~(eExplicitEarlyWakeupStart | eExplicitEarlyWakeupEnd);
3481 }
3482
Mathias Agopian386aa982011-11-07 21:58:03 -08003483 // this triggers the transaction
Ady Abrahambf1349c2020-06-12 14:26:18 -07003484 setTransactionFlags(transactionFlags, transactionStart);
Mathias Agopian386aa982011-11-07 21:58:03 -08003485
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003486 if (flags & eAnimation) {
3487 mAnimTransactionPending = true;
3488 }
Robert Carr238f4a22020-04-29 13:04:02 -07003489
3490 // if this is a synchronous transaction, wait for it to take effect
3491 // before returning.
3492 const bool synchronous = flags & eSynchronous;
3493 const bool syncInput = inputWindowCommands.syncInputWindows;
3494 if (!synchronous && !syncInput) {
3495 return;
3496 }
3497
3498 if (synchronous) {
3499 mTransactionPending = true;
3500 }
3501 if (syncInput) {
chaviw4fe36852019-04-15 16:25:49 -07003502 mPendingSyncInputWindows = true;
3503 }
Valerie Hau0779ded2019-03-19 12:43:04 -07003504
Robert Carr238f4a22020-04-29 13:04:02 -07003505
Valerie Hau0779ded2019-03-19 12:43:04 -07003506 // applyTransactionState can be called by either the main SF thread or by
3507 // another process through setTransactionState. While a given process may wish
3508 // to wait on synchronous transactions, the main SF thread should never
3509 // be blocked. Therefore, we only wait if isMainThread is false.
3510 while (!isMainThread && (mTransactionPending || mPendingSyncInputWindows)) {
Mathias Agopian386aa982011-11-07 21:58:03 -08003511 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
3512 if (CC_UNLIKELY(err != NO_ERROR)) {
3513 // just in case something goes wrong in SF, return to the
3514 // called after a few seconds.
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003515 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");
3516 mTransactionPending = false;
chaviw95ef3c42019-02-14 10:55:09 -08003517 mPendingSyncInputWindows = false;
Mathias Agopian386aa982011-11-07 21:58:03 -08003518 break;
3519 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -07003520 }
Ady Abrahambf1349c2020-06-12 14:26:18 -07003521 } else {
3522 // even if a transaction is not needed, we need to update VsyncModulator
3523 // about explicit early indications
3524 if (transactionStart == Scheduler::TransactionStart::EarlyStart ||
3525 transactionStart == Scheduler::TransactionStart::EarlyEnd) {
3526 mVSyncModulator->setTransactionStart(transactionStart);
3527 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003528 }
3529}
3530
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003531uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s) {
3532 const ssize_t index = mCurrentState.displays.indexOfKey(s.token);
3533 if (index < 0) return 0;
Jesse Hall9a143922012-10-04 16:29:19 -07003534
Mathias Agopiane57f2922012-08-09 16:29:12 -07003535 uint32_t flags = 0;
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003536 DisplayDeviceState& state = mCurrentState.displays.editValueAt(index);
3537
3538 const uint32_t what = s.what;
3539 if (what & DisplayState::eSurfaceChanged) {
3540 if (IInterface::asBinder(state.surface) != IInterface::asBinder(s.surface)) {
3541 state.surface = s.surface;
3542 flags |= eDisplayTransactionNeeded;
Michael Lentine47e45402014-07-18 15:34:25 -07003543 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07003544 }
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003545 if (what & DisplayState::eLayerStackChanged) {
3546 if (state.layerStack != s.layerStack) {
3547 state.layerStack = s.layerStack;
3548 flags |= eDisplayTransactionNeeded;
3549 }
3550 }
3551 if (what & DisplayState::eDisplayProjectionChanged) {
3552 if (state.orientation != s.orientation) {
3553 state.orientation = s.orientation;
3554 flags |= eDisplayTransactionNeeded;
3555 }
3556 if (state.frame != s.frame) {
3557 state.frame = s.frame;
3558 flags |= eDisplayTransactionNeeded;
3559 }
3560 if (state.viewport != s.viewport) {
3561 state.viewport = s.viewport;
3562 flags |= eDisplayTransactionNeeded;
3563 }
3564 }
3565 if (what & DisplayState::eDisplaySizeChanged) {
3566 if (state.width != s.width) {
3567 state.width = s.width;
3568 flags |= eDisplayTransactionNeeded;
3569 }
3570 if (state.height != s.height) {
3571 state.height = s.height;
3572 flags |= eDisplayTransactionNeeded;
3573 }
3574 }
3575
Mathias Agopiane57f2922012-08-09 16:29:12 -07003576 return flags;
3577}
3578
Steven Thomasd4071902020-03-24 16:02:53 -07003579bool SurfaceFlinger::callingThreadHasUnscopedSurfaceFlingerAccess(bool usePermissionCache) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003580 IPCThreadState* ipc = IPCThreadState::self();
3581 const int pid = ipc->getCallingPid();
3582 const int uid = ipc->getCallingUid();
Robert Carrd4ae7f32018-06-07 16:10:57 -07003583 if ((uid != AID_GRAPHICS && uid != AID_SYSTEM) &&
Steven Thomasd4071902020-03-24 16:02:53 -07003584 (usePermissionCache ? !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)
3585 : !checkPermission(sAccessSurfaceFlinger, pid, uid))) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003586 return false;
3587 }
3588 return true;
3589}
3590
Marissa Wall3dad52d2019-03-22 14:03:19 -07003591uint32_t SurfaceFlinger::setClientStateLocked(
Valerie Hau9dab9732019-08-20 09:29:25 -07003592 const ComposerState& composerState, int64_t desiredPresentTime, int64_t postTime,
3593 bool privileged,
3594 std::unordered_set<ListenerCallbacks, ListenerCallbacksHash>& listenerCallbacks) {
chaviwca27f252018-02-06 16:46:39 -08003595 const layer_state_t& s = composerState.state;
chaviwca27f252018-02-06 16:46:39 -08003596
Valerie Hau9dab9732019-08-20 09:29:25 -07003597 for (auto& listener : s.listeners) {
3598 // note that startRegistration will not re-register if the listener has
3599 // already be registered for a prior surface control
3600 mTransactionCompletedThread.startRegistration(listener);
3601 listenerCallbacks.insert(listener);
3602 }
3603
Vishnu Nairdc6f5b92019-12-03 07:33:37 -08003604 sp<Layer> layer = nullptr;
3605 if (s.surface) {
Alec Mouri9a02eda2020-04-21 17:39:34 -07003606 layer = fromHandleLocked(s.surface).promote();
Vishnu Nairdc6f5b92019-12-03 07:33:37 -08003607 } else {
3608 // The client may provide us a null handle. Treat it as if the layer was removed.
3609 ALOGW("Attempt to set client state with a null layer handle");
3610 }
chaviw8b3871a2017-11-01 17:41:01 -07003611 if (layer == nullptr) {
Valerie Hau9dab9732019-08-20 09:29:25 -07003612 for (auto& [listener, callbackIds] : s.listeners) {
Marissa Wallefb71af2019-06-27 14:45:53 -07003613 mTransactionCompletedThread.registerUnpresentedCallbackHandle(
Valerie Hau9dab9732019-08-20 09:29:25 -07003614 new CallbackHandle(listener, callbackIds, s.surface));
Marissa Wall88e20482019-06-24 10:49:42 -07003615 }
chaviw8b3871a2017-11-01 17:41:01 -07003616 return 0;
3617 }
3618
chaviw8b3871a2017-11-01 17:41:01 -07003619 uint32_t flags = 0;
3620
Garfield Tan8a3083e2018-12-03 13:21:07 -08003621 const uint64_t what = s.what;
Jorim Jaggidba32732018-05-28 17:43:52 +02003622
3623 // If we are deferring transaction, make sure to push the pending state, as otherwise the
3624 // pending state will also be deferred.
Marissa Wallf58c14b2018-07-24 10:50:43 -07003625 if (what & layer_state_t::eDeferTransaction_legacy) {
Jorim Jaggidba32732018-05-28 17:43:52 +02003626 layer->pushPendingState();
3627 }
3628
Valerie Hau871d6352020-01-29 08:44:02 -08003629 // Only set by BLAST adapter layers
3630 if (what & layer_state_t::eProducerDisconnect) {
3631 layer->onDisconnect();
3632 }
3633
chaviw8b3871a2017-11-01 17:41:01 -07003634 if (what & layer_state_t::ePositionChanged) {
chaviw214c89d2019-09-04 16:03:53 -07003635 if (layer->setPosition(s.x, s.y)) {
chaviw8b3871a2017-11-01 17:41:01 -07003636 flags |= eTraversalNeeded;
Mathias Agopiane57f2922012-08-09 16:29:12 -07003637 }
chaviw8b3871a2017-11-01 17:41:01 -07003638 }
3639 if (what & layer_state_t::eLayerChanged) {
3640 // NOTE: index needs to be calculated before we update the state
3641 const auto& p = layer->getParent();
3642 if (p == nullptr) {
chaviw64f7b422017-07-12 10:31:58 -07003643 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
chaviw8b3871a2017-11-01 17:41:01 -07003644 if (layer->setLayer(s.z) && idx >= 0) {
Mathias Agopiane57f2922012-08-09 16:29:12 -07003645 mCurrentState.layersSortedByZ.removeAt(idx);
3646 mCurrentState.layersSortedByZ.add(layer);
3647 // we need traversal (state changed)
3648 // AND transaction (list changed)
3649 flags |= eTransactionNeeded|eTraversalNeeded;
3650 }
chaviw8b3871a2017-11-01 17:41:01 -07003651 } else {
3652 if (p->setChildLayer(layer, s.z)) {
chaviw06178942017-07-27 10:25:59 -07003653 flags |= eTransactionNeeded|eTraversalNeeded;
3654 }
3655 }
chaviw8b3871a2017-11-01 17:41:01 -07003656 }
3657 if (what & layer_state_t::eRelativeLayerChanged) {
Robert Carr503c7042017-09-27 15:06:08 -07003658 // NOTE: index needs to be calculated before we update the state
3659 const auto& p = layer->getParent();
3660 if (p == nullptr) {
3661 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
3662 if (layer->setRelativeLayer(s.relativeLayerHandle, s.z) && idx >= 0) {
3663 mCurrentState.layersSortedByZ.removeAt(idx);
3664 mCurrentState.layersSortedByZ.add(layer);
3665 // we need traversal (state changed)
3666 // AND transaction (list changed)
3667 flags |= eTransactionNeeded|eTraversalNeeded;
3668 }
3669 } else {
3670 if (p->setChildRelativeLayer(layer, s.relativeLayerHandle, s.z)) {
3671 flags |= eTransactionNeeded|eTraversalNeeded;
3672 }
chaviw8b3871a2017-11-01 17:41:01 -07003673 }
3674 }
3675 if (what & layer_state_t::eSizeChanged) {
3676 if (layer->setSize(s.w, s.h)) {
3677 flags |= eTraversalNeeded;
3678 }
3679 }
3680 if (what & layer_state_t::eAlphaChanged) {
3681 if (layer->setAlpha(s.alpha))
3682 flags |= eTraversalNeeded;
3683 }
3684 if (what & layer_state_t::eColorChanged) {
3685 if (layer->setColor(s.color))
3686 flags |= eTraversalNeeded;
3687 }
Peiyong Lind3788632018-09-18 16:01:31 -07003688 if (what & layer_state_t::eColorTransformChanged) {
3689 if (layer->setColorTransform(s.colorTransform)) {
3690 flags |= eTraversalNeeded;
3691 }
3692 }
Valerie Haudd0b7572019-01-29 14:59:27 -08003693 if (what & layer_state_t::eBackgroundColorChanged) {
3694 if (layer->setBackgroundColor(s.color, s.bgColorAlpha, s.bgColorDataspace)) {
3695 flags |= eTraversalNeeded;
3696 }
3697 }
chaviw8b3871a2017-11-01 17:41:01 -07003698 if (what & layer_state_t::eMatrixChanged) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003699 // TODO: b/109894387
3700 //
3701 // SurfaceFlinger's renderer is not prepared to handle cropping in the face of arbitrary
3702 // rotation. To see the problem observe that if we have a square parent, and a child
3703 // of the same size, then we rotate the child 45 degrees around it's center, the child
3704 // must now be cropped to a non rectangular 8 sided region.
3705 //
3706 // Of course we can fix this in the future. For now, we are lucky, SurfaceControl is
3707 // private API, and the WindowManager only uses rotation in one case, which is on a top
3708 // level layer in which cropping is not an issue.
3709 //
3710 // However given that abuse of rotation matrices could lead to surfaces extending outside
3711 // of cropped areas, we need to prevent non-root clients without permission ACCESS_SURFACE_FLINGER
3712 // (a.k.a. everyone except WindowManager and tests) from setting non rectangle preserving
3713 // transformations.
Robert Carr14167e02019-02-13 13:50:55 -08003714 if (layer->setMatrix(s.matrix, privileged))
chaviw8b3871a2017-11-01 17:41:01 -07003715 flags |= eTraversalNeeded;
3716 }
3717 if (what & layer_state_t::eTransparentRegionChanged) {
3718 if (layer->setTransparentRegionHint(s.transparentRegion))
3719 flags |= eTraversalNeeded;
3720 }
3721 if (what & layer_state_t::eFlagsChanged) {
3722 if (layer->setFlags(s.flags, s.mask))
3723 flags |= eTraversalNeeded;
3724 }
Marissa Wallf58c14b2018-07-24 10:50:43 -07003725 if (what & layer_state_t::eCropChanged_legacy) {
chaviw214c89d2019-09-04 16:03:53 -07003726 if (layer->setCrop_legacy(s.crop_legacy)) flags |= eTraversalNeeded;
chaviw8b3871a2017-11-01 17:41:01 -07003727 }
Lucas Dupin1b6531c2018-07-05 17:18:21 -07003728 if (what & layer_state_t::eCornerRadiusChanged) {
3729 if (layer->setCornerRadius(s.cornerRadius))
3730 flags |= eTraversalNeeded;
3731 }
Lucas Dupin130e55c2020-05-26 16:11:18 -07003732 if (what & layer_state_t::eBackgroundBlurRadiusChanged && !mDisableBlurs && mSupportsBlur) {
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08003733 if (layer->setBackgroundBlurRadius(s.backgroundBlurRadius)) flags |= eTraversalNeeded;
3734 }
chaviw8b3871a2017-11-01 17:41:01 -07003735 if (what & layer_state_t::eLayerStackChanged) {
3736 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
3737 // We only allow setting layer stacks for top level layers,
3738 // everything else inherits layer stack from its parent.
3739 if (layer->hasParent()) {
3740 ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003741 layer->getDebugName());
chaviw8b3871a2017-11-01 17:41:01 -07003742 } else if (idx < 0) {
3743 ALOGE("Attempt to set layer stack on layer without parent (%s) that "
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003744 "that also does not appear in the top level layer list. Something"
3745 " has gone wrong.",
3746 layer->getDebugName());
chaviw8b3871a2017-11-01 17:41:01 -07003747 } else if (layer->setLayerStack(s.layerStack)) {
3748 mCurrentState.layersSortedByZ.removeAt(idx);
3749 mCurrentState.layersSortedByZ.add(layer);
3750 // we need traversal (state changed)
3751 // AND transaction (list changed)
Vishnu Nair6213bd92020-05-08 17:42:25 -07003752 flags |= eTransactionNeeded | eTraversalNeeded | eTransformHintUpdateNeeded;
chaviw8b3871a2017-11-01 17:41:01 -07003753 }
3754 }
Marissa Wallf58c14b2018-07-24 10:50:43 -07003755 if (what & layer_state_t::eDeferTransaction_legacy) {
3756 if (s.barrierHandle_legacy != nullptr) {
3757 layer->deferTransactionUntil_legacy(s.barrierHandle_legacy, s.frameNumber_legacy);
3758 } else if (s.barrierGbp_legacy != nullptr) {
3759 const sp<IGraphicBufferProducer>& gbp = s.barrierGbp_legacy;
chaviw8b3871a2017-11-01 17:41:01 -07003760 if (authenticateSurfaceTextureLocked(gbp)) {
3761 const auto& otherLayer =
3762 (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
Marissa Wallf58c14b2018-07-24 10:50:43 -07003763 layer->deferTransactionUntil_legacy(otherLayer, s.frameNumber_legacy);
chaviw8b3871a2017-11-01 17:41:01 -07003764 } else {
3765 ALOGE("Attempt to defer transaction to to an"
3766 " unrecognized GraphicBufferProducer");
Robert Carr1db73f62016-12-21 12:58:51 -08003767 }
3768 }
chaviw8b3871a2017-11-01 17:41:01 -07003769 // We don't trigger a traversal here because if no other state is
3770 // changed, we don't want this to cause any more work
3771 }
chaviw8b3871a2017-11-01 17:41:01 -07003772 if (what & layer_state_t::eReparentChildren) {
3773 if (layer->reparentChildren(s.reparentHandle)) {
3774 flags |= eTransactionNeeded|eTraversalNeeded;
Robert Carrc3574f72016-03-24 12:19:32 -07003775 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07003776 }
chaviw8b3871a2017-11-01 17:41:01 -07003777 if (what & layer_state_t::eDetachChildren) {
3778 layer->detachChildren();
3779 }
3780 if (what & layer_state_t::eOverrideScalingModeChanged) {
3781 layer->setOverrideScalingMode(s.overrideScalingMode);
3782 // We don't trigger a traversal here because if no other state is
3783 // changed, we don't want this to cause any more work
3784 }
Marissa Wall61c58622018-07-18 10:12:20 -07003785 if (what & layer_state_t::eTransformChanged) {
3786 if (layer->setTransform(s.transform)) flags |= eTraversalNeeded;
3787 }
3788 if (what & layer_state_t::eTransformToDisplayInverseChanged) {
3789 if (layer->setTransformToDisplayInverse(s.transformToDisplayInverse))
3790 flags |= eTraversalNeeded;
3791 }
3792 if (what & layer_state_t::eCropChanged) {
3793 if (layer->setCrop(s.crop)) flags |= eTraversalNeeded;
3794 }
Marissa Wall861616d2018-10-22 12:52:23 -07003795 if (what & layer_state_t::eFrameChanged) {
3796 if (layer->setFrame(s.frame)) flags |= eTraversalNeeded;
3797 }
Marissa Wall61c58622018-07-18 10:12:20 -07003798 if (what & layer_state_t::eAcquireFenceChanged) {
3799 if (layer->setAcquireFence(s.acquireFence)) flags |= eTraversalNeeded;
3800 }
3801 if (what & layer_state_t::eDataspaceChanged) {
3802 if (layer->setDataspace(s.dataspace)) flags |= eTraversalNeeded;
3803 }
3804 if (what & layer_state_t::eHdrMetadataChanged) {
3805 if (layer->setHdrMetadata(s.hdrMetadata)) flags |= eTraversalNeeded;
3806 }
3807 if (what & layer_state_t::eSurfaceDamageRegionChanged) {
3808 if (layer->setSurfaceDamageRegion(s.surfaceDamageRegion)) flags |= eTraversalNeeded;
3809 }
3810 if (what & layer_state_t::eApiChanged) {
3811 if (layer->setApi(s.api)) flags |= eTraversalNeeded;
3812 }
3813 if (what & layer_state_t::eSidebandStreamChanged) {
3814 if (layer->setSidebandStream(s.sidebandStream)) flags |= eTraversalNeeded;
3815 }
Robert Carr720e5062018-07-30 17:45:14 -07003816 if (what & layer_state_t::eInputInfoChanged) {
Vishnu Nairce5d0cc2019-02-28 14:38:41 -08003817 if (privileged) {
Robert Carr11ac2012019-01-22 09:05:25 -08003818 layer->setInputInfo(s.inputInfo);
3819 flags |= eTraversalNeeded;
3820 } else {
3821 ALOGE("Attempt to update InputWindowInfo without permission ACCESS_SURFACE_FLINGER");
3822 }
Robert Carr720e5062018-07-30 17:45:14 -07003823 }
Evan Rosky1f6d6d52018-12-06 10:47:26 -08003824 if (what & layer_state_t::eMetadataChanged) {
3825 if (layer->setMetadata(s.metadata)) flags |= eTraversalNeeded;
3826 }
Peiyong Linc502cb72019-03-01 15:00:23 -08003827 if (what & layer_state_t::eColorSpaceAgnosticChanged) {
3828 if (layer->setColorSpaceAgnostic(s.colorSpaceAgnostic)) {
3829 flags |= eTraversalNeeded;
3830 }
3831 }
Vishnu Nairc97b8db2019-10-29 18:19:35 -07003832 if (what & layer_state_t::eShadowRadiusChanged) {
3833 if (layer->setShadowRadius(s.shadowRadius)) flags |= eTraversalNeeded;
3834 }
Ana Krulecc84d09b2019-11-02 23:10:29 +01003835 if (what & layer_state_t::eFrameRateSelectionPriority) {
3836 if (privileged && layer->setFrameRateSelectionPriority(s.frameRateSelectionPriority)) {
3837 flags |= eTraversalNeeded;
3838 }
3839 }
Steven Thomas3172e202020-01-06 19:25:30 -08003840 if (what & layer_state_t::eFrameRateChanged) {
Steven Thomas62a4cf82020-01-31 12:04:03 -08003841 if (ValidateFrameRate(s.frameRate, s.frameRateCompatibility,
3842 "SurfaceFlinger::setClientStateLocked") &&
3843 layer->setFrameRate(Layer::FrameRate(s.frameRate,
3844 Layer::FrameRate::convertCompatibility(
3845 s.frameRateCompatibility)))) {
Ady Abraham71c437d2020-01-31 15:56:57 -08003846 flags |= eTraversalNeeded;
Steven Thomas62a4cf82020-01-31 12:04:03 -08003847 }
Steven Thomas3172e202020-01-06 19:25:30 -08003848 }
Vishnu Nair6213bd92020-05-08 17:42:25 -07003849 if (what & layer_state_t::eFixedTransformHintChanged) {
3850 if (layer->setFixedTransformHint(s.fixedTransformHint)) {
3851 flags |= eTraversalNeeded | eTransformHintUpdateNeeded;
3852 }
3853 }
Vishnu Nair14d76922019-08-05 08:41:20 -07003854 // This has to happen after we reparent children because when we reparent to null we remove
3855 // child layers from current state and remove its relative z. If the children are reparented in
3856 // the same transaction, then we have to make sure we reparent the children first so we do not
3857 // lose its relative z order.
3858 if (what & layer_state_t::eReparent) {
3859 bool hadParent = layer->hasParent();
3860 if (layer->reparent(s.parentHandleForChild)) {
3861 if (!hadParent) {
3862 mCurrentState.layersSortedByZ.remove(layer);
3863 }
3864 flags |= eTransactionNeeded | eTraversalNeeded;
3865 }
3866 }
Marissa Walle2ffb422018-10-12 11:33:52 -07003867 std::vector<sp<CallbackHandle>> callbackHandles;
Valerie Hau9dab9732019-08-20 09:29:25 -07003868 if ((what & layer_state_t::eHasListenerCallbacksChanged) && (!s.listeners.empty())) {
3869 for (auto& [listener, callbackIds] : s.listeners) {
Marissa Walle2ffb422018-10-12 11:33:52 -07003870 callbackHandles.emplace_back(new CallbackHandle(listener, callbackIds, s.surface));
3871 }
3872 }
Marissa Wall78b72202019-03-15 14:58:34 -07003873 bool bufferChanged = what & layer_state_t::eBufferChanged;
3874 bool cacheIdChanged = what & layer_state_t::eCachedBufferChanged;
3875 sp<GraphicBuffer> buffer;
Alec Mouri4545a8a2019-08-08 20:05:32 -07003876 if (bufferChanged && cacheIdChanged && s.buffer != nullptr) {
Marissa Wall78b72202019-03-15 14:58:34 -07003877 buffer = s.buffer;
Alec Mouri4545a8a2019-08-08 20:05:32 -07003878 bool success = ClientCache::getInstance().add(s.cachedBuffer, s.buffer);
3879 if (success) {
3880 getRenderEngine().cacheExternalTextureBuffer(s.buffer);
3881 success = ClientCache::getInstance()
3882 .registerErasedRecipient(s.cachedBuffer,
3883 wp<ClientCache::ErasedRecipient>(this));
3884 if (!success) {
3885 getRenderEngine().unbindExternalTextureBuffer(s.buffer->getId());
3886 }
3887 }
Marissa Wall78b72202019-03-15 14:58:34 -07003888 } else if (cacheIdChanged) {
Marissa Wall947d34e2019-03-29 14:03:53 -07003889 buffer = ClientCache::getInstance().get(s.cachedBuffer);
Marissa Wall78b72202019-03-15 14:58:34 -07003890 } else if (bufferChanged) {
3891 buffer = s.buffer;
Marissa Wall73411622019-01-25 10:45:41 -08003892 }
Marissa Wall78b72202019-03-15 14:58:34 -07003893 if (buffer) {
Valerie Haubf784642020-01-29 07:25:23 -08003894 if (layer->setBuffer(buffer, s.acquireFence, postTime, desiredPresentTime,
3895 s.cachedBuffer)) {
Valerie Haubc6ddb12019-03-08 11:10:15 -08003896 flags |= eTraversalNeeded;
Valerie Haubc6ddb12019-03-08 11:10:15 -08003897 }
Marissa Wallebc2c052019-01-16 19:16:55 -08003898 }
Marissa Walle2ffb422018-10-12 11:33:52 -07003899 if (layer->setTransactionCompletedListeners(callbackHandles)) flags |= eTraversalNeeded;
3900 // Do not put anything that updates layer state or modifies flags after
3901 // setTransactionCompletedListener
Mathias Agopiane57f2922012-08-09 16:29:12 -07003902 return flags;
3903}
3904
chaviw273171b2018-12-26 11:46:30 -08003905uint32_t SurfaceFlinger::addInputWindowCommands(const InputWindowCommands& inputWindowCommands) {
3906 uint32_t flags = 0;
chaviwa911b102019-02-14 10:18:33 -08003907 if (inputWindowCommands.syncInputWindows) {
3908 flags |= eTraversalNeeded;
3909 }
3910
Vishnu Nairec0ab382019-02-13 15:32:56 -08003911 mPendingInputWindowCommands.merge(inputWindowCommands);
chaviw273171b2018-12-26 11:46:30 -08003912 return flags;
3913}
3914
chaviwfe94a222019-08-21 13:52:59 -07003915status_t SurfaceFlinger::mirrorLayer(const sp<Client>& client, const sp<IBinder>& mirrorFromHandle,
3916 sp<IBinder>* outHandle) {
3917 if (!mirrorFromHandle) {
3918 return NAME_NOT_FOUND;
3919 }
3920
3921 sp<Layer> mirrorLayer;
3922 sp<Layer> mirrorFrom;
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003923 std::string uniqueName = getUniqueLayerName("MirrorRoot");
chaviwfe94a222019-08-21 13:52:59 -07003924
3925 {
3926 Mutex::Autolock _l(mStateLock);
Alec Mouri9a02eda2020-04-21 17:39:34 -07003927 mirrorFrom = fromHandleLocked(mirrorFromHandle).promote();
chaviwfe94a222019-08-21 13:52:59 -07003928 if (!mirrorFrom) {
3929 return NAME_NOT_FOUND;
3930 }
3931
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003932 status_t result = createContainerLayer(client, std::move(uniqueName), -1, -1, 0,
3933 LayerMetadata(), outHandle, &mirrorLayer);
chaviwfe94a222019-08-21 13:52:59 -07003934 if (result != NO_ERROR) {
3935 return result;
3936 }
3937
3938 mirrorLayer->mClonedChild = mirrorFrom->createClone();
3939 }
3940
Vishnu Nair6213bd92020-05-08 17:42:25 -07003941 return addClientLayer(client, *outHandle, nullptr, mirrorLayer, nullptr, nullptr, false,
3942 nullptr /* outTransformHint */);
chaviwfe94a222019-08-21 13:52:59 -07003943}
3944
Marissa Wall2d814fb2019-04-09 18:52:57 +00003945status_t SurfaceFlinger::createLayer(const String8& name, const sp<Client>& client, uint32_t w,
3946 uint32_t h, PixelFormat format, uint32_t flags,
3947 LayerMetadata metadata, sp<IBinder>* handle,
Robert Carrc0df3122019-04-11 13:18:21 -07003948 sp<IGraphicBufferProducer>* gbp,
Valerie Hau1acd6962019-10-28 16:35:48 -07003949 const sp<IBinder>& parentHandle, const sp<Layer>& parentLayer,
3950 uint32_t* outTransformHint) {
Mathias Agopian6e2d6482009-07-09 18:16:43 -07003951 if (int32_t(w|h) < 0) {
Mathias Agopian921e6ac2012-07-23 23:11:29 -07003952 ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
Mathias Agopian6e2d6482009-07-09 18:16:43 -07003953 int(w), int(h));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003954 return BAD_VALUE;
Mathias Agopian6e2d6482009-07-09 18:16:43 -07003955 }
Andreas Huber8b42e8a2010-08-16 08:49:37 -07003956
Robert Carrc0df3122019-04-11 13:18:21 -07003957 ALOG_ASSERT(parentLayer == nullptr || parentHandle == nullptr,
3958 "Expected only one of parentLayer or parentHandle to be non-null. "
3959 "Programmer error?");
3960
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003961 status_t result = NO_ERROR;
3962
3963 sp<Layer> layer;
3964
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003965 std::string uniqueName = getUniqueLayerName(name.string());
Cody Northropbc755282017-03-31 12:00:08 -06003966
Evan Roskya1f1e152019-01-24 16:17:46 -08003967 bool primaryDisplayOnly = false;
3968
3969 // window type is WINDOW_TYPE_DONT_SCREENSHOT from SurfaceControl.java
3970 // TODO b/64227542
3971 if (metadata.has(METADATA_WINDOW_TYPE)) {
3972 int32_t windowType = metadata.getInt32(METADATA_WINDOW_TYPE, 0);
3973 if (windowType == 441731) {
Ady Abraham8f1ee7f2019-04-05 10:32:50 -07003974 metadata.setInt32(METADATA_WINDOW_TYPE, InputWindowInfo::TYPE_NAVIGATION_BAR_PANEL);
Evan Roskya1f1e152019-01-24 16:17:46 -08003975 primaryDisplayOnly = true;
3976 }
3977 }
3978
Mathias Agopian3165cc22012-08-08 19:42:09 -07003979 switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
Marissa Wall61c58622018-07-18 10:12:20 -07003980 case ISurfaceComposerClient::eFXSurfaceBufferQueue:
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003981 result = createBufferQueueLayer(client, std::move(uniqueName), w, h, flags,
3982 std::move(metadata), format, handle, gbp, &layer);
David Sodman0c69cad2017-08-21 12:12:51 -07003983
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003984 break;
Marissa Wall61c58622018-07-18 10:12:20 -07003985 case ISurfaceComposerClient::eFXSurfaceBufferState:
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003986 result = createBufferStateLayer(client, std::move(uniqueName), w, h, flags,
Vishnu Nair6213bd92020-05-08 17:42:25 -07003987 std::move(metadata), handle, &layer);
Marissa Wall61c58622018-07-18 10:12:20 -07003988 break;
Vishnu Nairfa247b12020-02-11 08:58:26 -08003989 case ISurfaceComposerClient::eFXSurfaceEffect:
Vishnu Nair88a11f22018-11-28 18:30:57 -08003990 // check if buffer size is set for color layer.
3991 if (w > 0 || h > 0) {
3992 ALOGE("createLayer() failed, w or h cannot be set for color layer (w=%d, h=%d)",
3993 int(w), int(h));
3994 return BAD_VALUE;
3995 }
3996
Vishnu Nairfa247b12020-02-11 08:58:26 -08003997 result = createEffectLayer(client, std::move(uniqueName), w, h, flags,
3998 std::move(metadata), handle, &layer);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003999 break;
Robert Carr6b3f6c52018-08-13 13:05:17 -07004000 case ISurfaceComposerClient::eFXSurfaceContainer:
Vishnu Nair88a11f22018-11-28 18:30:57 -08004001 // check if buffer size is set for container layer.
4002 if (w > 0 || h > 0) {
4003 ALOGE("createLayer() failed, w or h cannot be set for container layer (w=%d, h=%d)",
4004 int(w), int(h));
4005 return BAD_VALUE;
4006 }
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004007 result = createContainerLayer(client, std::move(uniqueName), w, h, flags,
4008 std::move(metadata), handle, &layer);
Robert Carr6b3f6c52018-08-13 13:05:17 -07004009 break;
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004010 default:
4011 result = BAD_VALUE;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004012 break;
4013 }
4014
Dan Stoza7d89d062015-04-30 13:29:25 -07004015 if (result != NO_ERROR) {
4016 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004017 }
Dan Stoza7d89d062015-04-30 13:29:25 -07004018
Evan Roskya1f1e152019-01-24 16:17:46 -08004019 if (primaryDisplayOnly) {
4020 layer->setPrimaryDisplayOnly();
Chia-I Wuab0c3192017-08-01 11:29:00 -07004021 }
4022
Robert Carrb89ea9d2018-12-10 13:01:14 -08004023 bool addToCurrentState = callingThreadHasUnscopedSurfaceFlingerAccess();
Robert Carrc0df3122019-04-11 13:18:21 -07004024 result = addClientLayer(client, *handle, *gbp, layer, parentHandle, parentLayer,
Vishnu Nair6213bd92020-05-08 17:42:25 -07004025 addToCurrentState, outTransformHint);
Dan Stoza7d89d062015-04-30 13:29:25 -07004026 if (result != NO_ERROR) {
4027 return result;
4028 }
Lloyd Pique4dccc412018-01-22 17:21:36 -08004029 mInterceptor->saveSurfaceCreation(layer);
Dan Stoza7d89d062015-04-30 13:29:25 -07004030
4031 setTransactionFlags(eTransactionNeeded);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004032 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004033}
4034
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004035std::string SurfaceFlinger::getUniqueLayerName(const char* name) {
4036 unsigned dupeCounter = 0;
Cody Northropbc755282017-03-31 12:00:08 -06004037
4038 // Tack on our counter whether there is a hit or not, so everyone gets a tag
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004039 std::string uniqueName = base::StringPrintf("%s#%u", name, dupeCounter);
Cody Northropbc755282017-03-31 12:00:08 -06004040
Dan Stoza436ccf32018-06-21 12:10:12 -07004041 // Grab the state lock since we're accessing mCurrentState
4042 Mutex::Autolock lock(mStateLock);
4043
Cody Northropbc755282017-03-31 12:00:08 -06004044 // Loop over layers until we're sure there is no matching name
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004045 bool matchFound = true;
Cody Northropbc755282017-03-31 12:00:08 -06004046 while (matchFound) {
4047 matchFound = false;
Edgar Arriaga844fa672020-01-16 14:21:42 -08004048 mCurrentState.traverse([&](Layer* layer) {
Cody Northropbc755282017-03-31 12:00:08 -06004049 if (layer->getName() == uniqueName) {
4050 matchFound = true;
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004051 uniqueName = base::StringPrintf("%s#%u", name, ++dupeCounter);
Cody Northropbc755282017-03-31 12:00:08 -06004052 }
4053 });
4054 }
4055
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004056 ALOGV_IF(dupeCounter > 0, "duplicate layer name: changing %s to %s", name, uniqueName.c_str());
Cody Northropbc755282017-03-31 12:00:08 -06004057 return uniqueName;
4058}
4059
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004060status_t SurfaceFlinger::createBufferQueueLayer(const sp<Client>& client, std::string name,
Marissa Wallfd668622018-05-10 10:21:13 -07004061 uint32_t w, uint32_t h, uint32_t flags,
Evan Roskya1f1e152019-01-24 16:17:46 -08004062 LayerMetadata metadata, PixelFormat& format,
4063 sp<IBinder>* handle,
Marissa Wallfd668622018-05-10 10:21:13 -07004064 sp<IGraphicBufferProducer>* gbp,
4065 sp<Layer>* outLayer) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004066 // initialize the surfaces
Mathias Agopian92a979a2012-08-02 18:32:23 -07004067 switch (format) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004068 case PIXEL_FORMAT_TRANSPARENT:
4069 case PIXEL_FORMAT_TRANSLUCENT:
4070 format = PIXEL_FORMAT_RGBA_8888;
4071 break;
4072 case PIXEL_FORMAT_OPAQUE:
Mathias Agopian8f105402010-04-05 18:01:24 -07004073 format = PIXEL_FORMAT_RGBX_8888;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004074 break;
4075 }
4076
chaviwb4c6e582019-08-16 14:35:07 -07004077 sp<BufferQueueLayer> layer;
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004078 LayerCreationArgs args(this, client, std::move(name), w, h, flags, std::move(metadata));
chaviwb4c6e582019-08-16 14:35:07 -07004079 args.textureName = getNewTexture();
4080 {
4081 // Grab the SF state lock during this since it's the only safe way to access
4082 // RenderEngine when creating a BufferLayerConsumer
4083 // TODO: Check if this lock is still needed here
4084 Mutex::Autolock lock(mStateLock);
4085 layer = getFactory().createBufferQueueLayer(args);
4086 }
4087
Marissa Wallfd668622018-05-10 10:21:13 -07004088 status_t err = layer->setDefaultBufferProperties(w, h, format);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004089 if (err == NO_ERROR) {
David Sodman0c69cad2017-08-21 12:12:51 -07004090 *handle = layer->getHandle();
4091 *gbp = layer->getProducer();
4092 *outLayer = layer;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004093 }
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004094
Marissa Wallfd668622018-05-10 10:21:13 -07004095 ALOGE_IF(err, "createBufferQueueLayer() failed (%s)", strerror(-err));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004096 return err;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004097}
4098
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004099status_t SurfaceFlinger::createBufferStateLayer(const sp<Client>& client, std::string name,
Marissa Wall61c58622018-07-18 10:12:20 -07004100 uint32_t w, uint32_t h, uint32_t flags,
Evan Roskya1f1e152019-01-24 16:17:46 -08004101 LayerMetadata metadata, sp<IBinder>* handle,
Vishnu Nair6213bd92020-05-08 17:42:25 -07004102 sp<Layer>* outLayer) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004103 LayerCreationArgs args(this, client, std::move(name), w, h, flags, std::move(metadata));
chaviwb4c6e582019-08-16 14:35:07 -07004104 args.textureName = getNewTexture();
4105 sp<BufferStateLayer> layer = getFactory().createBufferStateLayer(args);
Marissa Wall61c58622018-07-18 10:12:20 -07004106 *handle = layer->getHandle();
4107 *outLayer = layer;
4108
4109 return NO_ERROR;
4110}
4111
Vishnu Nairfa247b12020-02-11 08:58:26 -08004112status_t SurfaceFlinger::createEffectLayer(const sp<Client>& client, std::string name, uint32_t w,
4113 uint32_t h, uint32_t flags, LayerMetadata metadata,
4114 sp<IBinder>* handle, sp<Layer>* outLayer) {
4115 *outLayer = getFactory().createEffectLayer(
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004116 {this, client, std::move(name), w, h, flags, std::move(metadata)});
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004117 *handle = (*outLayer)->getHandle();
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004118 return NO_ERROR;
Mathias Agopian118d0242011-10-13 16:02:48 -07004119}
4120
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004121status_t SurfaceFlinger::createContainerLayer(const sp<Client>& client, std::string name,
Evan Roskya1f1e152019-01-24 16:17:46 -08004122 uint32_t w, uint32_t h, uint32_t flags,
4123 LayerMetadata metadata, sp<IBinder>* handle,
4124 sp<Layer>* outLayer) {
4125 *outLayer = getFactory().createContainerLayer(
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004126 {this, client, std::move(name), w, h, flags, std::move(metadata)});
Robert Carr6b3f6c52018-08-13 13:05:17 -07004127 *handle = (*outLayer)->getHandle();
4128 return NO_ERROR;
4129}
4130
Robert Carr6fb1a7e2018-12-11 12:07:25 -08004131void SurfaceFlinger::markLayerPendingRemovalLocked(const sp<Layer>& layer) {
Robert Carr2e102c92018-10-23 12:11:15 -07004132 mLayersPendingRemoval.add(layer);
4133 mLayersRemoved = true;
4134 setTransactionFlags(eTransactionNeeded);
4135}
4136
Robert Carr695d5282018-12-18 15:27:58 -08004137void SurfaceFlinger::onHandleDestroyed(sp<Layer>& layer)
Rob Carr4bba3702018-10-08 21:53:30 +00004138{
Robert Carr2e102c92018-10-23 12:11:15 -07004139 Mutex::Autolock lock(mStateLock);
Robert Carr6fb1a7e2018-12-11 12:07:25 -08004140 // If a layer has a parent, we allow it to out-live it's handle
4141 // with the idea that the parent holds a reference and will eventually
4142 // be cleaned up. However no one cleans up the top-level so we do so
4143 // here.
4144 if (layer->getParent() == nullptr) {
4145 mCurrentState.layersSortedByZ.remove(layer);
4146 }
4147 markLayerPendingRemovalLocked(layer);
Robert Carrc0df3122019-04-11 13:18:21 -07004148
4149 auto it = mLayersByLocalBinderToken.begin();
4150 while (it != mLayersByLocalBinderToken.end()) {
4151 if (it->second == layer) {
4152 it = mLayersByLocalBinderToken.erase(it);
4153 } else {
4154 it++;
4155 }
4156 }
4157
Robert Carr695d5282018-12-18 15:27:58 -08004158 layer.clear();
Rob Carr4bba3702018-10-08 21:53:30 +00004159}
4160
Mathias Agopianb60314a2012-04-10 22:09:54 -07004161// ---------------------------------------------------------------------------
4162
Andy McFadden13a082e2012-08-24 10:16:42 -07004163void SurfaceFlinger::onInitializeDisplays() {
Dominik Laskowski83b88212018-12-11 13:34:06 -08004164 const auto display = getDefaultDisplayDeviceLocked();
4165 if (!display) return;
4166
4167 const sp<IBinder> token = display->getDisplayToken().promote();
4168 LOG_ALWAYS_FATAL_IF(token == nullptr);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004169
Jesse Hall01e29052013-02-19 16:13:35 -08004170 // reset screen orientation and use primary layer stack
Andy McFadden13a082e2012-08-24 10:16:42 -07004171 Vector<ComposerState> state;
4172 Vector<DisplayState> displays;
4173 DisplayState d;
Jesse Hall01e29052013-02-19 16:13:35 -08004174 d.what = DisplayState::eDisplayProjectionChanged |
4175 DisplayState::eLayerStackChanged;
Dominik Laskowski83b88212018-12-11 13:34:06 -08004176 d.token = token;
Jesse Hall01e29052013-02-19 16:13:35 -08004177 d.layerStack = 0;
Dominik Laskowski718f9602019-11-09 20:01:35 -08004178 d.orientation = ui::ROTATION_0;
Jeff Brown4c05dd12012-09-09 00:07:17 -07004179 d.frame.makeInvalid();
4180 d.viewport.makeInvalid();
Michael Lentine47e45402014-07-18 15:34:25 -07004181 d.width = 0;
4182 d.height = 0;
Andy McFadden13a082e2012-08-24 10:16:42 -07004183 displays.add(d);
Valerie Hau9dab9732019-08-20 09:29:25 -07004184 setTransactionState(state, displays, 0, nullptr, mPendingInputWindowCommands, -1, {}, false,
4185 {});
Jamie Gennis6547ff42013-07-16 20:12:42 -07004186
Peiyong Lin65248e02020-04-18 21:15:07 -07004187 setPowerModeInternal(display, hal::PowerMode::ON);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004188
Dominik Laskowski83b88212018-12-11 13:34:06 -08004189 const nsecs_t vsyncPeriod = getVsyncPeriod();
4190 mAnimFrameTracker.setDisplayRefreshPeriod(vsyncPeriod);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08004191
Brian Andersond0010582017-03-07 13:20:31 -08004192 // Use phase of 0 since phase is not known.
4193 // Use latency of 0, which will snap to the ideal latency.
Dominik Laskowski83b88212018-12-11 13:34:06 -08004194 DisplayStatInfo stats{0 /* vsyncTime */, vsyncPeriod};
Ana Krulece588e312018-09-18 12:32:24 -07004195 setCompositorTimingSnapped(stats, 0);
Andy McFadden13a082e2012-08-24 10:16:42 -07004196}
4197
4198void SurfaceFlinger::initializeDisplays() {
Dominik Laskowski8c001672018-05-30 16:52:06 -07004199 // Async since we may be called from the main thread.
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07004200 static_cast<void>(schedule([this]() MAIN_THREAD { onInitializeDisplays(); }));
Andy McFadden13a082e2012-08-24 10:16:42 -07004201}
4202
Peiyong Line9d809e2020-04-14 13:10:48 -07004203void SurfaceFlinger::setVsyncEnabledInHWC(DisplayId displayId, hal::Vsync enabled) {
Ady Abraham27c70212019-06-11 10:52:26 -07004204 if (mHWCVsyncState != enabled) {
4205 getHwComposer().setVsyncEnabled(displayId, enabled);
4206 mHWCVsyncState = enabled;
4207 }
4208}
4209
Peiyong Lin65248e02020-04-18 21:15:07 -07004210void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& display, hal::PowerMode mode) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004211 if (display->isVirtual()) {
4212 ALOGE("%s: Invalid operation on virtual display", __FUNCTION__);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004213 return;
4214 }
4215
Dominik Laskowski075d3172018-05-24 15:50:06 -07004216 const auto displayId = display->getId();
4217 LOG_ALWAYS_FATAL_IF(!displayId);
4218
Dominik Laskowski34157762018-10-31 13:07:19 -07004219 ALOGD("Setting power mode %d on display %s", mode, to_string(*displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004220
Peiyong Lin65248e02020-04-18 21:15:07 -07004221 const hal::PowerMode currentMode = display->getPowerMode();
Dominik Laskowski075d3172018-05-24 15:50:06 -07004222 if (mode == currentMode) {
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004223 return;
4224 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004225
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004226 display->setPowerMode(mode);
4227
Lloyd Pique4dccc412018-01-22 17:21:36 -08004228 if (mInterceptor->isEnabled()) {
Peiyong Lin65248e02020-04-18 21:15:07 -07004229 mInterceptor->savePowerModeUpdate(display->getSequenceId(), static_cast<int32_t>(mode));
Irvelffc9efc2016-07-27 15:16:37 -07004230 }
4231
Peiyong Lin65248e02020-04-18 21:15:07 -07004232 if (currentMode == hal::PowerMode::OFF) {
Martin Liu4a322352020-03-24 21:30:38 +08004233 if (SurfaceFlinger::setSchedFifo(true) != NO_ERROR) {
4234 ALOGW("Couldn't set SCHED_FIFO on display on: %s\n", strerror(errno));
4235 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07004236 getHwComposer().setPowerMode(*displayId, mode);
Peiyong Lin65248e02020-04-18 21:15:07 -07004237 if (display->isPrimary() && mode != hal::PowerMode::DOZE_SUSPEND) {
Ady Abraham27c70212019-06-11 10:52:26 -07004238 setVsyncEnabledInHWC(*displayId, mHWCVsyncPendingState);
Ana Krulecc2870422019-01-29 19:00:58 -08004239 mScheduler->onScreenAcquired(mAppConnectionHandle);
4240 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004241 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004242
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004243 mVisibleRegionsDirty = true;
Dan Stozab90cf072015-03-05 11:05:59 -08004244 mHasPoweredOff = true;
Dan Stozac7a25ad2018-04-12 11:45:09 -07004245 repaintEverything();
Peiyong Lin65248e02020-04-18 21:15:07 -07004246 } else if (mode == hal::PowerMode::OFF) {
Tim Murrayf9d4e442016-08-02 15:43:59 -07004247 // Turn off the display
Martin Liu4a322352020-03-24 21:30:38 +08004248 if (SurfaceFlinger::setSchedFifo(false) != NO_ERROR) {
4249 ALOGW("Couldn't set SCHED_OTHER on display off: %s\n", strerror(errno));
Tim Murrayf9d4e442016-08-02 15:43:59 -07004250 }
Peiyong Lin65248e02020-04-18 21:15:07 -07004251 if (display->isPrimary() && currentMode != hal::PowerMode::DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08004252 mScheduler->disableHardwareVsync(true);
4253 mScheduler->onScreenReleased(mAppConnectionHandle);
Mathias Agopiancde87a32012-09-13 14:09:01 -07004254 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004255
Ady Abraham27c70212019-06-11 10:52:26 -07004256 // Make sure HWVsync is disabled before turning off the display
Peiyong Line9d809e2020-04-14 13:10:48 -07004257 setVsyncEnabledInHWC(*displayId, hal::Vsync::DISABLE);
Ady Abraham27c70212019-06-11 10:52:26 -07004258
Dominik Laskowski075d3172018-05-24 15:50:06 -07004259 getHwComposer().setPowerMode(*displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004260 mVisibleRegionsDirty = true;
4261 // from this point on, SF will stop drawing on this display
Peiyong Lin65248e02020-04-18 21:15:07 -07004262 } else if (mode == hal::PowerMode::DOZE || mode == hal::PowerMode::ON) {
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004263 // Update display while dozing
Dominik Laskowski075d3172018-05-24 15:50:06 -07004264 getHwComposer().setPowerMode(*displayId, mode);
Peiyong Lin65248e02020-04-18 21:15:07 -07004265 if (display->isPrimary() && currentMode == hal::PowerMode::DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08004266 mScheduler->onScreenAcquired(mAppConnectionHandle);
4267 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004268 }
Peiyong Lin65248e02020-04-18 21:15:07 -07004269 } else if (mode == hal::PowerMode::DOZE_SUSPEND) {
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004270 // Leave display going to doze
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004271 if (display->isPrimary()) {
Ana Krulecc2870422019-01-29 19:00:58 -08004272 mScheduler->disableHardwareVsync(true);
4273 mScheduler->onScreenReleased(mAppConnectionHandle);
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004274 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07004275 getHwComposer().setPowerMode(*displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004276 } else {
Matthew Bouyack38d49612017-05-12 12:49:32 -07004277 ALOGE("Attempting to set unknown power mode: %d\n", mode);
Dominik Laskowski075d3172018-05-24 15:50:06 -07004278 getHwComposer().setPowerMode(*displayId, mode);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004279 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004280
Yiwei Zhang3a226d22018-10-16 09:23:03 -07004281 if (display->isPrimary()) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08004282 mTimeStats->setPowerMode(mode);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07004283 mRefreshRateStats->setPowerMode(mode);
Peiyong Lin65248e02020-04-18 21:15:07 -07004284 mScheduler->setDisplayPowerState(mode == hal::PowerMode::ON);
Yiwei Zhang3a226d22018-10-16 09:23:03 -07004285 }
4286
Dominik Laskowski34157762018-10-31 13:07:19 -07004287 ALOGD("Finished setting power mode %d on display %s", mode, to_string(*displayId).c_str());
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004288}
4289
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004290void SurfaceFlinger::setPowerMode(const sp<IBinder>& displayToken, int mode) {
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07004291 schedule([=]() MAIN_THREAD {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07004292 const auto display = getDisplayDeviceLocked(displayToken);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004293 if (!display) {
4294 ALOGE("Attempt to set power mode %d for invalid display token %p", mode,
4295 displayToken.get());
4296 } else if (display->isVirtual()) {
4297 ALOGW("Attempt to set power mode %d for virtual display", mode);
4298 } else {
Peiyong Lin65248e02020-04-18 21:15:07 -07004299 setPowerModeInternal(display, static_cast<hal::PowerMode>(mode));
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004300 }
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07004301 }).wait();
Mathias Agopianb60314a2012-04-10 22:09:54 -07004302}
4303
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07004304status_t SurfaceFlinger::doDump(int fd, const DumpArgs& args, bool asProto) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004305 std::string result;
Mathias Agopian99b49842011-06-27 16:05:52 -07004306
Mathias Agopianbd115332013-04-18 16:41:04 -07004307 IPCThreadState* ipc = IPCThreadState::self();
4308 const int pid = ipc->getCallingPid();
4309 const int uid = ipc->getCallingUid();
Vishnu Nair6a408532017-10-24 09:11:27 -07004310
Mathias Agopianbd115332013-04-18 16:41:04 -07004311 if ((uid != AID_SHELL) &&
4312 !PermissionCache::checkPermission(sDump, pid, uid)) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004313 StringAppendF(&result, "Permission Denial: can't dump SurfaceFlinger from pid=%d, uid=%d\n",
4314 pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004315 } else {
Dominik Laskowskic2867142019-01-21 11:33:38 -08004316 static const std::unordered_map<std::string, Dumper> dumpers = {
Dominik Laskowskic2867142019-01-21 11:33:38 -08004317 {"--display-id"s, dumper(&SurfaceFlinger::dumpDisplayIdentificationData)},
Dominik Laskowski98041832019-08-01 18:35:59 -07004318 {"--dispsync"s,
4319 dumper([this](std::string& s) { mScheduler->getPrimaryDispSync().dump(s); })},
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004320 {"--edid"s, argsDumper(&SurfaceFlinger::dumpRawDisplayIdentificationData)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08004321 {"--frame-events"s, dumper(&SurfaceFlinger::dumpFrameEventsLocked)},
4322 {"--latency"s, argsDumper(&SurfaceFlinger::dumpStatsLocked)},
4323 {"--latency-clear"s, argsDumper(&SurfaceFlinger::clearStatsLocked)},
4324 {"--list"s, dumper(&SurfaceFlinger::listLayersLocked)},
4325 {"--static-screen"s, dumper(&SurfaceFlinger::dumpStaticScreenStats)},
4326 {"--timestats"s, protoDumper(&SurfaceFlinger::dumpTimeStats)},
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004327 {"--vsync"s, dumper(&SurfaceFlinger::dumpVSync)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08004328 {"--wide-color"s, dumper(&SurfaceFlinger::dumpWideColorInfo)},
4329 };
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004330
Dominik Laskowskic2867142019-01-21 11:33:38 -08004331 const auto flag = args.empty() ? ""s : std::string(String8(args[0]));
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004332
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07004333 bool dumpLayers = true;
4334 {
4335 TimedLock lock(mStateLock, s2ns(1), __FUNCTION__);
4336 if (!lock.locked()) {
4337 StringAppendF(&result, "Dumping without lock after timeout: %s (%d)\n",
4338 strerror(-lock.status), lock.status);
4339 }
4340
4341 if (const auto it = dumpers.find(flag); it != dumpers.end()) {
4342 (it->second)(args, asProto, result);
4343 dumpLayers = false;
4344 } else if (!asProto) {
4345 dumpAllLocked(args, result);
4346 }
Mathias Agopian48b888a2011-01-19 16:15:53 -08004347 }
4348
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07004349 if (dumpLayers) {
Dominik Laskowski46470112019-08-02 13:13:11 -07004350 const LayersProto layersProto = dumpProtoFromMainThread();
4351 if (asProto) {
4352 result.append(layersProto.SerializeAsString());
4353 } else {
Vishnu Nair0f085c62019-08-30 08:49:12 -07004354 // Dump info that we need to access from the main thread
Dominik Laskowski46470112019-08-02 13:13:11 -07004355 const auto layerTree = LayerProtoParser::generateLayerTree(layersProto);
4356 result.append(LayerProtoParser::layerTreeToString(layerTree));
4357 result.append("\n");
Vishnu Nair0f085c62019-08-30 08:49:12 -07004358 dumpOffscreenLayers(result);
Dominik Laskowski46470112019-08-02 13:13:11 -07004359 }
Vishnu Nair8406fd72019-07-30 11:29:31 -07004360 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004361 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08004362 write(fd, result.c_str(), result.size());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004363 return NO_ERROR;
4364}
4365
Nataniel Borges8e7dc722019-02-28 15:10:28 -08004366status_t SurfaceFlinger::dumpCritical(int fd, const DumpArgs&, bool asProto) {
4367 if (asProto && mTracing.isEnabled()) {
4368 mTracing.writeToFileAsync();
4369 }
4370
4371 return doDump(fd, DumpArgs(), asProto);
4372}
4373
Dominik Laskowskic2867142019-01-21 11:33:38 -08004374void SurfaceFlinger::listLayersLocked(std::string& result) const {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004375 mCurrentState.traverseInZOrder(
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004376 [&](Layer* layer) { StringAppendF(&result, "%s\n", layer->getDebugName()); });
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004377}
4378
Dominik Laskowskic2867142019-01-21 11:33:38 -08004379void SurfaceFlinger::dumpStatsLocked(const DumpArgs& args, std::string& result) const {
Dominik Laskowski83b88212018-12-11 13:34:06 -08004380 StringAppendF(&result, "%" PRId64 "\n", getVsyncPeriod());
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004381
Dominik Laskowskic2867142019-01-21 11:33:38 -08004382 if (args.size() > 1) {
4383 const auto name = String8(args[1]);
Robert Carr2047fae2016-11-28 14:09:09 -08004384 mCurrentState.traverseInZOrder([&](Layer* layer) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004385 if (layer->getName() == name.string()) {
Svetoslavd85084b2014-03-20 10:28:31 -07004386 layer->dumpFrameStats(result);
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004387 }
Robert Carr2047fae2016-11-28 14:09:09 -08004388 });
Dominik Laskowskic2867142019-01-21 11:33:38 -08004389 } else {
4390 mAnimFrameTracker.dumpStats(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004391 }
4392}
4393
Dominik Laskowskic2867142019-01-21 11:33:38 -08004394void SurfaceFlinger::clearStatsLocked(const DumpArgs& args, std::string&) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004395 const bool clearAll = args.size() < 2;
4396 const auto name = clearAll ? String8() : String8(args[1]);
4397
Edgar Arriaga844fa672020-01-16 14:21:42 -08004398 mCurrentState.traverse([&](Layer* layer) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004399 if (clearAll || layer->getName() == name.string()) {
Svetoslavd85084b2014-03-20 10:28:31 -07004400 layer->clearFrameStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004401 }
Robert Carr2047fae2016-11-28 14:09:09 -08004402 });
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004403
Svetoslavd85084b2014-03-20 10:28:31 -07004404 mAnimFrameTracker.clearStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004405}
4406
Dominik Laskowskic2867142019-01-21 11:33:38 -08004407void SurfaceFlinger::dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const {
4408 mTimeStats->parseArgs(asProto, args, result);
4409}
4410
Jamie Gennis6547ff42013-07-16 20:12:42 -07004411// This should only be called from the main thread. Otherwise it would need
4412// the lock and should use mCurrentState rather than mDrawingState.
4413void SurfaceFlinger::logFrameStats() {
Edgar Arriaga844fa672020-01-16 14:21:42 -08004414 mDrawingState.traverse([&](Layer* layer) {
Jamie Gennis6547ff42013-07-16 20:12:42 -07004415 layer->logFrameStats();
Robert Carr2047fae2016-11-28 14:09:09 -08004416 });
Jamie Gennis6547ff42013-07-16 20:12:42 -07004417
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004418 mAnimFrameTracker.logAndResetStats("<win-anim>");
Jamie Gennis6547ff42013-07-16 20:12:42 -07004419}
4420
Yiwei Zhang5434a782018-12-05 18:06:32 -08004421void SurfaceFlinger::appendSfConfigString(std::string& result) const {
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004422 result.append(" [sf");
Fabien Sanglardc93afd52017-03-13 13:02:42 -07004423
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004424 if (isLayerTripleBufferingDisabled())
4425 result.append(" DISABLE_TRIPLE_BUFFERING");
Fabien Sanglardc45a7d92017-03-14 13:24:22 -07004426
Yiwei Zhang5434a782018-12-05 18:06:32 -08004427 StringAppendF(&result, " PRESENT_TIME_OFFSET=%" PRId64, dispSyncPresentTimeOffset);
4428 StringAppendF(&result, " FORCE_HWC_FOR_RBG_TO_YUV=%d", useHwcForRgbToYuv);
4429 StringAppendF(&result, " MAX_VIRT_DISPLAY_DIM=%" PRIu64, maxVirtualDisplaySize);
4430 StringAppendF(&result, " RUNNING_WITHOUT_SYNC_FRAMEWORK=%d", !hasSyncFramework);
4431 StringAppendF(&result, " NUM_FRAMEBUFFER_SURFACE_BUFFERS=%" PRId64,
4432 maxFrameBufferAcquiredBuffers);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004433 result.append("]");
Andy McFadden4803b742012-09-24 19:07:20 -07004434}
4435
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004436void SurfaceFlinger::dumpVSync(std::string& result) const {
Dominik Laskowski98041832019-08-01 18:35:59 -07004437 mScheduler->dump(result);
Dominik Laskowski98041832019-08-01 18:35:59 -07004438
Steven Thomas2bbaabe2019-08-28 16:08:35 -07004439 mRefreshRateStats->dump(result);
Dominik Laskowski98041832019-08-01 18:35:59 -07004440 result.append("\n");
4441
Ady Abraham9e16a482019-12-03 17:19:41 -08004442 mPhaseConfiguration->dump(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004443 StringAppendF(&result,
Dominik Laskowski98041832019-08-01 18:35:59 -07004444 " present offset: %9" PRId64 " ns\t VSYNC period: %9" PRId64 " ns\n\n",
Ana Krulec757f63a2019-01-25 10:46:18 -08004445 dispSyncPresentTimeOffset, getVsyncPeriod());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004446
Steven Thomasd4071902020-03-24 16:02:53 -07004447 scheduler::RefreshRateConfigs::Policy policy = mRefreshRateConfigs->getDisplayManagerPolicy();
Ana Krulec234bb162019-11-10 22:55:55 +01004448 StringAppendF(&result,
Ady Abraham07e54702020-04-16 15:05:37 -07004449 "DesiredDisplayConfigSpecs (DisplayManager): default config ID: %d"
Steven Thomasf734df42020-04-13 21:09:28 -07004450 ", primary range: [%.2f %.2f], app request range: [%.2f %.2f]\n\n",
4451 policy.defaultConfig.value(), policy.primaryRange.min, policy.primaryRange.max,
4452 policy.appRequestRange.min, policy.appRequestRange.max);
Ady Abraham42b3beb2019-07-09 18:09:52 -07004453 StringAppendF(&result, "(config override by backdoor: %s)\n\n",
4454 mDebugDisplayConfigSetByBackdoor ? "yes" : "no");
Ady Abraham07e54702020-04-16 15:05:37 -07004455 scheduler::RefreshRateConfigs::Policy currentPolicy = mRefreshRateConfigs->getCurrentPolicy();
4456 if (currentPolicy != policy) {
4457 StringAppendF(&result,
4458 "DesiredDisplayConfigSpecs (Override): default config ID: %d"
Steven Thomasf734df42020-04-13 21:09:28 -07004459 ", primary range: [%.2f %.2f], app request range: [%.2f %.2f]\n\n",
4460 currentPolicy.defaultConfig.value(), currentPolicy.primaryRange.min,
4461 currentPolicy.primaryRange.max, currentPolicy.appRequestRange.min,
4462 currentPolicy.appRequestRange.max);
Ady Abraham07e54702020-04-16 15:05:37 -07004463 }
Dominik Laskowski98041832019-08-01 18:35:59 -07004464
Ana Krulecc2870422019-01-29 19:00:58 -08004465 mScheduler->dump(mAppConnectionHandle, result);
Ady Abraham75398722020-04-07 14:08:45 -07004466 mScheduler->getPrimaryDispSync().dump(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004467}
4468
Yiwei Zhang5434a782018-12-05 18:06:32 -08004469void SurfaceFlinger::dumpStaticScreenStats(std::string& result) const {
4470 result.append("Static screen stats:\n");
David Sodman4a36e932017-11-07 14:29:47 -08004471 for (size_t b = 0; b < SurfaceFlingerBE::NUM_BUCKETS - 1; ++b) {
4472 float bucketTimeSec = getBE().mFrameBuckets[b] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08004473 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08004474 static_cast<float>(getBE().mFrameBuckets[b]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004475 StringAppendF(&result, " < %zd frames: %.3f s (%.1f%%)\n", b + 1, bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08004476 }
David Sodman4a36e932017-11-07 14:29:47 -08004477 float bucketTimeSec = getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08004478 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08004479 static_cast<float>(getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004480 StringAppendF(&result, " %zd+ frames: %.3f s (%.1f%%)\n", SurfaceFlingerBE::NUM_BUCKETS - 1,
4481 bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08004482}
4483
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004484void SurfaceFlinger::recordBufferingStats(const std::string& layerName,
4485 std::vector<OccupancyTracker::Segment>&& history) {
David Sodmancbaf0832017-11-07 14:21:36 -08004486 Mutex::Autolock lock(getBE().mBufferingStatsMutex);
4487 auto& stats = getBE().mBufferingStats[layerName];
Dan Stozae77c7662016-05-13 11:37:28 -07004488 for (const auto& segment : history) {
4489 if (!segment.usedThirdBuffer) {
4490 stats.twoBufferTime += segment.totalTime;
4491 }
4492 if (segment.occupancyAverage < 1.0f) {
4493 stats.doubleBufferedTime += segment.totalTime;
4494 } else if (segment.occupancyAverage < 2.0f) {
4495 stats.tripleBufferedTime += segment.totalTime;
4496 }
4497 ++stats.numSegments;
4498 stats.totalTime += segment.totalTime;
4499 }
4500}
4501
Yiwei Zhang5434a782018-12-05 18:06:32 -08004502void SurfaceFlinger::dumpFrameEventsLocked(std::string& result) {
4503 result.append("Layer frame timestamps:\n");
Brian Andersond6927fb2016-07-23 23:37:30 -07004504
4505 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
4506 const size_t count = currentLayers.size();
4507 for (size_t i=0 ; i<count ; i++) {
4508 currentLayers[i]->dumpFrameEvents(result);
4509 }
4510}
4511
Yiwei Zhang5434a782018-12-05 18:06:32 -08004512void SurfaceFlinger::dumpBufferingStats(std::string& result) const {
Dan Stozae77c7662016-05-13 11:37:28 -07004513 result.append("Buffering stats:\n");
4514 result.append(" [Layer name] <Active time> <Two buffer> "
4515 "<Double buffered> <Triple buffered>\n");
David Sodmancbaf0832017-11-07 14:21:36 -08004516 Mutex::Autolock lock(getBE().mBufferingStatsMutex);
Dan Stozae77c7662016-05-13 11:37:28 -07004517 typedef std::tuple<std::string, float, float, float> BufferTuple;
4518 std::map<float, BufferTuple, std::greater<float>> sorted;
David Sodmancbaf0832017-11-07 14:21:36 -08004519 for (const auto& statsPair : getBE().mBufferingStats) {
Dan Stozae77c7662016-05-13 11:37:28 -07004520 const char* name = statsPair.first.c_str();
David Sodmancbaf0832017-11-07 14:21:36 -08004521 const SurfaceFlingerBE::BufferingStats& stats = statsPair.second;
Dan Stozae77c7662016-05-13 11:37:28 -07004522 if (stats.numSegments == 0) {
4523 continue;
4524 }
4525 float activeTime = ns2ms(stats.totalTime) / 1000.0f;
4526 float twoBufferRatio = static_cast<float>(stats.twoBufferTime) /
4527 stats.totalTime;
4528 float doubleBufferRatio = static_cast<float>(
4529 stats.doubleBufferedTime) / stats.totalTime;
4530 float tripleBufferRatio = static_cast<float>(
4531 stats.tripleBufferedTime) / stats.totalTime;
4532 sorted.insert({activeTime, {name, twoBufferRatio,
4533 doubleBufferRatio, tripleBufferRatio}});
4534 }
4535 for (const auto& sortedPair : sorted) {
4536 float activeTime = sortedPair.first;
4537 const BufferTuple& values = sortedPair.second;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004538 StringAppendF(&result, " [%s] %.2f %.3f %.3f %.3f\n", std::get<0>(values).c_str(),
4539 activeTime, std::get<1>(values), std::get<2>(values), std::get<3>(values));
Dan Stozae77c7662016-05-13 11:37:28 -07004540 }
4541 result.append("\n");
4542}
4543
Yiwei Zhang5434a782018-12-05 18:06:32 -08004544void SurfaceFlinger::dumpDisplayIdentificationData(std::string& result) const {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004545 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004546 const auto displayId = display->getId();
4547 if (!displayId) {
4548 continue;
4549 }
4550 const auto hwcDisplayId = getHwComposer().fromPhysicalDisplayId(*displayId);
Dominik Laskowski7e045462018-05-30 13:02:02 -07004551 if (!hwcDisplayId) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004552 continue;
4553 }
4554
Yiwei Zhang5434a782018-12-05 18:06:32 -08004555 StringAppendF(&result,
4556 "Display %s (HWC display %" PRIu64 "): ", to_string(*displayId).c_str(),
4557 *hwcDisplayId);
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004558 uint8_t port;
4559 DisplayIdentificationData data;
Dominik Laskowski7e045462018-05-30 13:02:02 -07004560 if (!getHwComposer().getDisplayIdentificationData(*hwcDisplayId, &port, &data)) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004561 result.append("no identification data\n");
4562 continue;
4563 }
4564
4565 if (!isEdid(data)) {
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004566 result.append("unknown identification data\n");
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004567 continue;
4568 }
4569
4570 const auto edid = parseEdid(data);
4571 if (!edid) {
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004572 result.append("invalid EDID\n");
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004573 continue;
4574 }
4575
Yiwei Zhang5434a782018-12-05 18:06:32 -08004576 StringAppendF(&result, "port=%u pnpId=%s displayName=\"", port, edid->pnpId.data());
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004577 result.append(edid->displayName.data(), edid->displayName.length());
4578 result.append("\"\n");
4579 }
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004580}
4581
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004582void SurfaceFlinger::dumpRawDisplayIdentificationData(const DumpArgs& args,
4583 std::string& result) const {
Peiyong Line9d809e2020-04-14 13:10:48 -07004584 hal::HWDisplayId hwcDisplayId;
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004585 uint8_t port;
4586 DisplayIdentificationData data;
4587
4588 if (args.size() > 1 && base::ParseUint(String8(args[1]), &hwcDisplayId) &&
4589 getHwComposer().getDisplayIdentificationData(hwcDisplayId, &port, &data)) {
4590 result.append(reinterpret_cast<const char*>(data.data()), data.size());
4591 }
4592}
4593
Yiwei Zhang5434a782018-12-05 18:06:32 -08004594void SurfaceFlinger::dumpWideColorInfo(std::string& result) const {
Peiyong Linff84a152019-05-17 18:36:19 -07004595 StringAppendF(&result, "Device has wide color built-in display: %d\n", hasWideColorDisplay);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004596 StringAppendF(&result, "Device uses color management: %d\n", useColorManagement);
4597 StringAppendF(&result, "DisplayColorSetting: %s\n",
4598 decodeDisplayColorSetting(mDisplayColorSetting).c_str());
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004599
4600 // TODO: print out if wide-color mode is active or not
4601
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004602 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004603 const auto displayId = display->getId();
4604 if (!displayId) {
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004605 continue;
4606 }
4607
Yiwei Zhang5434a782018-12-05 18:06:32 -08004608 StringAppendF(&result, "Display %s color modes:\n", to_string(*displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004609 std::vector<ColorMode> modes = getHwComposer().getColorModes(*displayId);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004610 for (auto&& mode : modes) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004611 StringAppendF(&result, " %s (%d)\n", decodeColorMode(mode).c_str(), mode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004612 }
4613
Lloyd Pique32cbe282018-10-19 13:09:22 -07004614 ColorMode currentMode = display->getCompositionDisplay()->getState().colorMode;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004615 StringAppendF(&result, " Current color mode: %s (%d)\n",
4616 decodeColorMode(currentMode).c_str(), currentMode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004617 }
4618 result.append("\n");
4619}
4620
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07004621LayersProto SurfaceFlinger::dumpDrawingStateProto(uint32_t traceFlags) const {
4622 // If context is SurfaceTracing thread, mTracingLock blocks display transactions on main thread.
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07004623 const auto display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked());
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07004624
chaviw1d044282017-09-27 12:19:28 -07004625 LayersProto layersProto;
chaviw08f3cb22020-01-13 13:17:21 -08004626 for (const sp<Layer>& layer : mDrawingState.layersSortedByZ) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -07004627 layer->writeToProto(layersProto, traceFlags, display.get());
chaviw08f3cb22020-01-13 13:17:21 -08004628 }
Alec Mouri6b9e9912020-01-21 10:50:24 -08004629
chaviw1d044282017-09-27 12:19:28 -07004630 return layersProto;
4631}
4632
Alec Mouri6b9e9912020-01-21 10:50:24 -08004633void SurfaceFlinger::dumpHwc(std::string& result) const {
4634 getHwComposer().dump(result);
4635}
4636
Vishnu Nair0f085c62019-08-30 08:49:12 -07004637void SurfaceFlinger::dumpOffscreenLayersProto(LayersProto& layersProto, uint32_t traceFlags) const {
4638 // Add a fake invisible root layer to the proto output and parent all the offscreen layers to
4639 // it.
4640 LayerProto* rootProto = layersProto.add_layers();
4641 const int32_t offscreenRootLayerId = INT32_MAX - 2;
4642 rootProto->set_id(offscreenRootLayerId);
4643 rootProto->set_name("Offscreen Root");
Vishnu Naird5aeb612019-09-20 14:39:39 -07004644 rootProto->set_parent(-1);
Vishnu Nair0f085c62019-08-30 08:49:12 -07004645
4646 for (Layer* offscreenLayer : mOffscreenLayers) {
4647 // Add layer as child of the fake root
4648 rootProto->add_children(offscreenLayer->sequence);
4649
4650 // Add layer
Alec Mouri6b9e9912020-01-21 10:50:24 -08004651 LayerProto* layerProto =
4652 offscreenLayer->writeToProto(layersProto, traceFlags, nullptr /*device*/);
Vishnu Nair0f085c62019-08-30 08:49:12 -07004653 layerProto->set_parent(offscreenRootLayerId);
Vishnu Nair0f085c62019-08-30 08:49:12 -07004654 }
4655}
4656
Vishnu Nair8406fd72019-07-30 11:29:31 -07004657LayersProto SurfaceFlinger::dumpProtoFromMainThread(uint32_t traceFlags) {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07004658 return schedule([=] { return dumpDrawingStateProto(traceFlags); }).get();
Vishnu Nair8406fd72019-07-30 11:29:31 -07004659}
4660
Vishnu Nair0f085c62019-08-30 08:49:12 -07004661void SurfaceFlinger::dumpOffscreenLayers(std::string& result) {
4662 result.append("Offscreen Layers:\n");
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07004663 result.append(schedule([this] {
4664 std::string result;
4665 for (Layer* offscreenLayer : mOffscreenLayers) {
4666 offscreenLayer->traverse(LayerVector::StateSet::Drawing,
4667 [&](Layer* layer) {
4668 layer->dumpCallingUidPid(result);
4669 });
4670 }
4671 return result;
4672 }).get());
Vishnu Nair0f085c62019-08-30 08:49:12 -07004673}
4674
Dominik Laskowskic2867142019-01-21 11:33:38 -08004675void SurfaceFlinger::dumpAllLocked(const DumpArgs& args, std::string& result) const {
4676 const bool colorize = !args.empty() && args[0] == String16("--color");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004677 Colorizer colorizer(colorize);
4678
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004679 // figure out if we're stuck somewhere
4680 const nsecs_t now = systemTime();
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004681 const nsecs_t inTransaction(mDebugInTransaction);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004682 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
4683
4684 /*
Andy McFadden4803b742012-09-24 19:07:20 -07004685 * Dump library configuration.
4686 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004687
4688 colorizer.bold(result);
Andy McFadden4803b742012-09-24 19:07:20 -07004689 result.append("Build configuration:");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004690 colorizer.reset(result);
Andy McFadden4803b742012-09-24 19:07:20 -07004691 appendSfConfigString(result);
4692 appendUiConfigString(result);
4693 appendGuiConfigString(result);
4694 result.append("\n");
4695
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004696 result.append("\nDisplay identification data:\n");
4697 dumpDisplayIdentificationData(result);
4698
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004699 result.append("\nWide-Color information:\n");
4700 dumpWideColorInfo(result);
4701
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004702 colorizer.bold(result);
Mathias Agopianca088332013-03-28 17:44:13 -07004703 result.append("Sync configuration: ");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004704 colorizer.reset(result);
Mathias Agopianca088332013-03-28 17:44:13 -07004705 result.append(SyncFeatures::getInstance().toString());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004706 result.append("\n\n");
Mathias Agopianca088332013-03-28 17:44:13 -07004707
Andy McFadden41d67d72014-04-25 16:58:34 -07004708 colorizer.bold(result);
Dominik Laskowski98041832019-08-01 18:35:59 -07004709 result.append("Scheduler:\n");
Andy McFadden41d67d72014-04-25 16:58:34 -07004710 colorizer.reset(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004711 dumpVSync(result);
Dan Stozab90cf072015-03-05 11:05:59 -08004712 result.append("\n");
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004713
Dan Stozab90cf072015-03-05 11:05:59 -08004714 dumpStaticScreenStats(result);
4715 result.append("\n");
4716
Alec Mouri40189b02019-03-05 15:07:54 -08004717 StringAppendF(&result, "Total missed frame count: %u\n", mFrameMissedCount.load());
4718 StringAppendF(&result, "HWC missed frame count: %u\n", mHwcFrameMissedCount.load());
4719 StringAppendF(&result, "GPU missed frame count: %u\n\n", mGpuFrameMissedCount.load());
Marissa Wallcfcdaa52018-05-21 15:45:59 -07004720
Dan Stozae77c7662016-05-13 11:37:28 -07004721 dumpBufferingStats(result);
4722
Andy McFadden4803b742012-09-24 19:07:20 -07004723 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004724 * Dump the visible layer list
4725 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004726 colorizer.bold(result);
chaviweadf0d42019-08-12 13:28:29 -07004727 StringAppendF(&result, "Visible layers (count = %zu)\n", mNumLayers.load());
Yiwei Zhang5434a782018-12-05 18:06:32 -08004728 StringAppendF(&result, "GraphicBufferProducers: %zu, max %zu\n",
4729 mGraphicBufferProducerList.size(), mMaxGraphicBufferProducerListSize);
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004730 colorizer.reset(result);
chaviw1d044282017-09-27 12:19:28 -07004731
Chia-I Wu2f884132018-09-13 15:17:58 -07004732 {
Lloyd Pique207def92019-02-28 16:09:52 -08004733 StringAppendF(&result, "Composition layers\n");
4734 mDrawingState.traverseInZOrder([&](Layer* layer) {
Lloyd Piquede196652020-01-22 17:29:58 -08004735 auto* compositionState = layer->getCompositionState();
4736 if (!compositionState) return;
4737
4738 android::base::StringAppendF(&result, "* Layer %p (%s)\n", layer,
4739 layer->getDebugName() ? layer->getDebugName()
4740 : "<unknown>");
4741 compositionState->dump(result);
Lloyd Pique207def92019-02-28 16:09:52 -08004742 });
4743 }
4744
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004745 /*
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004746 * Dump Display state
4747 */
4748
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004749 colorizer.bold(result);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004750 StringAppendF(&result, "Displays (%zu entries)\n", mDisplays.size());
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004751 colorizer.reset(result);
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004752 for (const auto& [token, display] : mDisplays) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004753 display->dump(result);
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004754 }
Chia-I Wu1e043612018-03-01 09:45:09 -08004755 result.append("\n");
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004756
4757 /*
Lloyd Piquec3cb7292019-05-17 15:25:14 -07004758 * Dump CompositionEngine state
4759 */
4760
4761 mCompositionEngine->dump(result);
4762
4763 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004764 * Dump SurfaceFlinger global state
4765 */
4766
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004767 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02004768 result.append("SurfaceFlinger global state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004769 colorizer.reset(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004770
Lloyd Piqueb97e04f2018-10-18 17:07:05 -07004771 getRenderEngine().dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004772
Ady Abrahama3b08ef2019-07-15 18:43:10 -07004773 DebugEGLImageTracker::getInstance()->dump(result);
4774
Dominik Laskowski075d3172018-05-24 15:50:06 -07004775 if (const auto display = getDefaultDisplayDeviceLocked()) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07004776 display->getCompositionDisplay()->getState().undefinedRegion.dump(result,
4777 "undefinedRegion");
Dominik Laskowski718f9602019-11-09 20:01:35 -08004778 StringAppendF(&result, " orientation=%s, isPoweredOn=%d\n",
4779 toCString(display->getOrientation()), display->isPoweredOn());
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08004780 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08004781 StringAppendF(&result,
4782 " transaction-flags : %08x\n"
4783 " gpu_to_cpu_unsupported : %d\n",
4784 mTransactionFlags.load(), !mGpuToCpuSupported);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004785
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08004786 if (const auto displayId = getInternalDisplayIdLocked();
Dominik Laskowski075d3172018-05-24 15:50:06 -07004787 displayId && getHwComposer().isConnected(*displayId)) {
4788 const auto activeConfig = getHwComposer().getActiveConfig(*displayId);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004789 StringAppendF(&result,
4790 " refresh-rate : %f fps\n"
4791 " x-dpi : %f\n"
4792 " y-dpi : %f\n",
Ady Abraham3a77a7b2019-12-02 18:46:59 -08004793 1e9 / getHwComposer().getDisplayVsyncPeriod(*displayId),
4794 activeConfig->getDpiX(), activeConfig->getDpiY());
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004795 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004796
Yiwei Zhang5434a782018-12-05 18:06:32 -08004797 StringAppendF(&result, " transaction time: %f us\n", inTransactionDuration / 1000.0);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004798
Dan Stozae22aec72016-08-01 13:20:59 -07004799 /*
Yichi Chenadc69612018-09-15 14:51:18 +08004800 * Tracing state
4801 */
4802 mTracing.dump(result);
4803 result.append("\n");
4804
4805 /*
Dan Stozae22aec72016-08-01 13:20:59 -07004806 * HWC layer minidump
4807 */
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004808 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004809 const auto displayId = display->getId();
4810 if (!displayId) {
Dan Stozae22aec72016-08-01 13:20:59 -07004811 continue;
4812 }
4813
Yiwei Zhang5434a782018-12-05 18:06:32 -08004814 StringAppendF(&result, "Display %s HWC layers:\n", to_string(*displayId).c_str());
Dan Stozae22aec72016-08-01 13:20:59 -07004815 Layer::miniDumpHeader(result);
Dominik Laskowskib7251f42020-04-20 17:42:59 -07004816
4817 const DisplayDevice& ref = *display;
4818 mCurrentState.traverseInZOrder([&](Layer* layer) { layer->miniDump(result, ref); });
Dan Stozae22aec72016-08-01 13:20:59 -07004819 result.append("\n");
4820 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004821
4822 /*
4823 * Dump HWComposer state
4824 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004825 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02004826 result.append("h/w composer state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004827 colorizer.reset(result);
Dan Stoza9f26a9c2016-06-22 14:51:09 -07004828 bool hwcDisabled = mDebugDisableHWC || mDebugRegion;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004829 StringAppendF(&result, " h/w composer %s\n", hwcDisabled ? "disabled" : "enabled");
Dominik Laskowski075d3172018-05-24 15:50:06 -07004830 getHwComposer().dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004831
4832 /*
4833 * Dump gralloc state
4834 */
4835 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
4836 alloc.dump(result);
Karthik Ravi Shankar171155a2017-06-28 15:40:24 -07004837
4838 /*
4839 * Dump VrFlinger state if in use.
4840 */
4841 if (mVrFlingerRequestsDisplay && mVrFlinger) {
4842 result.append("VrFlinger state:\n");
Yiwei Zhang5434a782018-12-05 18:06:32 -08004843 result.append(mVrFlinger->Dump());
Karthik Ravi Shankar171155a2017-06-28 15:40:24 -07004844 result.append("\n");
4845 }
Ana Krulecb43429d2019-01-09 14:28:51 -08004846
Yiwei Zhang7eb58b72019-04-22 19:00:02 -07004847 result.append(mTimeStats->miniDump());
4848 result.append("\n");
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004849}
4850
Chia-I Wu28f320b2018-05-03 11:02:56 -07004851void SurfaceFlinger::updateColorMatrixLocked() {
4852 mat4 colorMatrix;
4853 if (mGlobalSaturationFactor != 1.0f) {
4854 // Rec.709 luma coefficients
4855 float3 luminance{0.213f, 0.715f, 0.072f};
4856 luminance *= 1.0f - mGlobalSaturationFactor;
4857 mat4 saturationMatrix = mat4(
4858 vec4{luminance.r + mGlobalSaturationFactor, luminance.r, luminance.r, 0.0f},
4859 vec4{luminance.g, luminance.g + mGlobalSaturationFactor, luminance.g, 0.0f},
4860 vec4{luminance.b, luminance.b, luminance.b + mGlobalSaturationFactor, 0.0f},
4861 vec4{0.0f, 0.0f, 0.0f, 1.0f}
4862 );
4863 colorMatrix = mClientColorMatrix * saturationMatrix * mDaltonizer();
4864 } else {
4865 colorMatrix = mClientColorMatrix * mDaltonizer();
4866 }
4867
4868 if (mCurrentState.colorMatrix != colorMatrix) {
4869 mCurrentState.colorMatrix = colorMatrix;
4870 mCurrentState.colorMatrixChanged = true;
4871 setTransactionFlags(eTransactionNeeded);
4872 }
4873}
4874
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07004875status_t SurfaceFlinger::CheckTransactCodeCredentials(uint32_t code) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004876#pragma clang diagnostic push
4877#pragma clang diagnostic error "-Wswitch-enum"
4878 switch (static_cast<ISurfaceComposerTag>(code)) {
4879 // These methods should at minimum make sure that the client requested
4880 // access to SF.
Dan Stozae3344402018-08-20 19:53:42 +00004881 case BOOT_FINISHED:
4882 case CLEAR_ANIMATION_FRAME_STATS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004883 case CREATE_DISPLAY:
4884 case DESTROY_DISPLAY:
Dan Stozae3344402018-08-20 19:53:42 +00004885 case ENABLE_VSYNC_INJECTIONS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004886 case GET_ANIMATION_FRAME_STATS:
4887 case GET_HDR_CAPABILITIES:
Ana Krulec0782b882019-10-15 17:34:54 -07004888 case SET_DESIRED_DISPLAY_CONFIG_SPECS:
Ana Krulec234bb162019-11-10 22:55:55 +01004889 case GET_DESIRED_DISPLAY_CONFIG_SPECS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004890 case SET_ACTIVE_COLOR_MODE:
Galia Peycheva5492cb52019-10-30 14:13:16 +01004891 case GET_AUTO_LOW_LATENCY_MODE_SUPPORT:
4892 case SET_AUTO_LOW_LATENCY_MODE:
4893 case GET_GAME_CONTENT_TYPE_SUPPORT:
4894 case SET_GAME_CONTENT_TYPE:
Chia-I Wu90f669f2017-10-05 14:24:41 -07004895 case INJECT_VSYNC:
Kevin DuBois9c0a1762018-10-16 13:32:31 -07004896 case SET_POWER_MODE:
Kevin DuBois74e53772018-11-19 10:52:38 -08004897 case GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES:
Kevin DuBois1d4249a2018-08-29 10:45:14 -07004898 case SET_DISPLAY_CONTENT_SAMPLING_ENABLED:
Ady Abraham8532d012019-05-08 14:50:56 -07004899 case GET_DISPLAYED_CONTENT_SAMPLE:
Vishnu Nairb13bb952019-11-15 10:24:08 -08004900 case NOTIFY_POWER_HINT:
Steven Thomasd4071902020-03-24 16:02:53 -07004901 case SET_GLOBAL_SHADOW_SETTINGS:
4902 case ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN: {
4903 // ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN is used by CTS tests, which acquire the
4904 // necessary permission dynamically. Don't use the permission cache for this check.
4905 bool usePermissionCache = code != ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN;
4906 if (!callingThreadHasUnscopedSurfaceFlingerAccess(usePermissionCache)) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07004907 IPCThreadState* ipc = IPCThreadState::self();
4908 ALOGE("Permission Denial: can't access SurfaceFlinger pid=%d, uid=%d",
4909 ipc->getCallingPid(), ipc->getCallingUid());
Mathias Agopian375f5632009-06-15 18:24:59 -07004910 return PERMISSION_DENIED;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004911 }
Robert Carr1db73f62016-12-21 12:58:51 -08004912 return OK;
4913 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004914 case GET_LAYER_DEBUG_INFO: {
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07004915 IPCThreadState* ipc = IPCThreadState::self();
4916 const int pid = ipc->getCallingPid();
4917 const int uid = ipc->getCallingUid();
Ana Krulec13be8ad2018-08-21 02:43:56 +00004918 if ((uid != AID_SHELL) && !PermissionCache::checkPermission(sDump, pid, uid)) {
4919 ALOGE("Layer debug info permission denied for pid=%d, uid=%d", pid, uid);
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07004920 return PERMISSION_DENIED;
4921 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004922 return OK;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004923 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004924 // Used by apps to hook Choreographer to SurfaceFlinger.
4925 case CREATE_DISPLAY_EVENT_CONNECTION:
4926 // The following calls are currently used by clients that do not
4927 // request necessary permissions. However, they do not expose any secret
4928 // information, so it is OK to pass them.
4929 case AUTHENTICATE_SURFACE:
Peiyong Lind1fedb42019-03-11 17:48:41 -07004930 case GET_ACTIVE_COLOR_MODE:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004931 case GET_ACTIVE_CONFIG:
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08004932 case GET_PHYSICAL_DISPLAY_IDS:
4933 case GET_PHYSICAL_DISPLAY_TOKEN:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004934 case GET_DISPLAY_COLOR_MODES:
Daniel Solomon42d04562019-01-20 21:03:19 -08004935 case GET_DISPLAY_NATIVE_PRIMARIES:
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08004936 case GET_DISPLAY_INFO:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004937 case GET_DISPLAY_CONFIGS:
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08004938 case GET_DISPLAY_STATE:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004939 case GET_DISPLAY_STATS:
4940 case GET_SUPPORTED_FRAME_TIMESTAMPS:
4941 // Calling setTransactionState is safe, because you need to have been
4942 // granted a reference to Client* and Handle* to do anything with it.
4943 case SET_TRANSACTION_STATE:
Robert Carrb89ea9d2018-12-10 13:01:14 -08004944 case CREATE_CONNECTION:
Ady Abraham37965d42018-11-01 13:43:32 -07004945 case GET_COLOR_MANAGEMENT:
Peiyong Lin3c2791e2019-01-14 17:05:18 -08004946 case GET_COMPOSITION_PREFERENCE:
Marissa Wallebc2c052019-01-16 19:16:55 -08004947 case GET_PROTECTED_CONTENT_SUPPORT:
Dan Gittik57e63c52019-01-18 16:37:54 +00004948 case IS_WIDE_COLOR_DISPLAY:
Steven Thomas62a4cf82020-01-31 12:04:03 -08004949 // setFrameRate() is deliberately available for apps to call without any
4950 // special permissions.
4951 case SET_FRAME_RATE:
Dan Gittik57e63c52019-01-18 16:37:54 +00004952 case GET_DISPLAY_BRIGHTNESS_SUPPORT:
4953 case SET_DISPLAY_BRIGHTNESS: {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004954 return OK;
4955 }
Chong Zhangd1690d12019-10-04 17:47:13 +00004956 case CAPTURE_LAYERS:
Dan Stoza84ab9372018-12-17 15:27:57 -08004957 case CAPTURE_SCREEN:
4958 case ADD_REGION_SAMPLING_LISTENER:
4959 case REMOVE_REGION_SAMPLING_LISTENER: {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004960 // codes that require permission check
chaviwa76b2712017-09-20 12:02:26 -07004961 IPCThreadState* ipc = IPCThreadState::self();
4962 const int pid = ipc->getCallingPid();
4963 const int uid = ipc->getCallingUid();
4964 if ((uid != AID_GRAPHICS) &&
4965 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
4966 ALOGE("Permission Denial: can't read framebuffer pid=%d, uid=%d", pid, uid);
4967 return PERMISSION_DENIED;
4968 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004969 return OK;
4970 }
chaviw93df2ea2019-04-30 16:45:12 -07004971 case CAPTURE_SCREEN_BY_ID: {
4972 IPCThreadState* ipc = IPCThreadState::self();
4973 const int uid = ipc->getCallingUid();
Peiyong Lin96cfebc2019-05-15 11:36:13 -07004974 if (uid == AID_ROOT || uid == AID_GRAPHICS || uid == AID_SYSTEM || uid == AID_SHELL) {
chaviw93df2ea2019-04-30 16:45:12 -07004975 return OK;
4976 }
4977 return PERMISSION_DENIED;
4978 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004979 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004980
4981 // These codes are used for the IBinder protocol to either interrogate the recipient
4982 // side of the transaction for its canonical interface descriptor or to dump its state.
4983 // We let them pass by default.
4984 if (code == IBinder::INTERFACE_TRANSACTION || code == IBinder::DUMP_TRANSACTION ||
4985 code == IBinder::PING_TRANSACTION || code == IBinder::SHELL_COMMAND_TRANSACTION ||
4986 code == IBinder::SYSPROPS_TRANSACTION) {
4987 return OK;
4988 }
Ady Abraham07e54702020-04-16 15:05:37 -07004989 // Numbers from 1000 to 1036 are currently used for backdoors. The code
Ana Krulec13be8ad2018-08-21 02:43:56 +00004990 // in onTransact verifies that the user is root, and has access to use SF.
Ady Abraham07e54702020-04-16 15:05:37 -07004991 if (code >= 1000 && code <= 1036) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004992 ALOGV("Accessing SurfaceFlinger through backdoor code: %u", code);
4993 return OK;
4994 }
4995 ALOGE("Permission Denial: SurfaceFlinger did not recognize request code: %u", code);
4996 return PERMISSION_DENIED;
4997#pragma clang diagnostic pop
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07004998}
4999
Ana Krulec13be8ad2018-08-21 02:43:56 +00005000status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
5001 uint32_t flags) {
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07005002 status_t credentialCheck = CheckTransactCodeCredentials(code);
5003 if (credentialCheck != OK) {
5004 return credentialCheck;
5005 }
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07005006
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005007 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
5008 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
Mathias Agopianb8a55602009-06-26 19:06:36 -07005009 CHECK_INTERFACE(ISurfaceComposer, data, reply);
Romain Guy8c6bbd62017-06-05 13:51:43 -07005010 IPCThreadState* ipc = IPCThreadState::self();
5011 const int uid = ipc->getCallingUid();
5012 if (CC_UNLIKELY(uid != AID_SYSTEM
5013 && !PermissionCache::checkCallingPermission(sHardwareTest))) {
Mathias Agopian375f5632009-06-15 18:24:59 -07005014 const int pid = ipc->getCallingPid();
Steve Blocke6f43dd2012-01-06 19:20:56 +00005015 ALOGE("Permission Denial: "
Mathias Agopian375f5632009-06-15 18:24:59 -07005016 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005017 return PERMISSION_DENIED;
5018 }
5019 int n;
5020 switch (code) {
Mathias Agopian01b76682009-04-16 20:04:08 -07005021 case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
Mathias Agopian35b48d12010-09-13 22:57:58 -07005022 case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005023 return NO_ERROR;
5024 case 1002: // SHOW_UPDATES
5025 n = data.readInt32();
5026 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
Mathias Agopian53331da2011-08-22 21:44:41 -07005027 invalidateHwcGeometry();
5028 repaintEverything();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005029 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005030 case 1004:{ // repaint everything
Mathias Agopian53331da2011-08-22 21:44:41 -07005031 repaintEverything();
Mathias Agopiancbb288b2009-09-07 16:32:45 -07005032 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005033 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -07005034 case 1005:{ // force transaction
Steven Thomas6d8110b2017-08-31 18:24:21 -07005035 Mutex::Autolock _l(mStateLock);
Mathias Agopiane57f2922012-08-09 16:29:12 -07005036 setTransactionFlags(
5037 eTransactionNeeded|
5038 eDisplayTransactionNeeded|
5039 eTraversalNeeded);
Mathias Agopiancbb288b2009-09-07 16:32:45 -07005040 return NO_ERROR;
5041 }
Mathias Agopian4d143ee2012-02-23 20:05:39 -08005042 case 1006:{ // send empty update
5043 signalRefresh();
5044 return NO_ERROR;
5045 }
Mathias Agopian53331da2011-08-22 21:44:41 -07005046 case 1008: // toggle use of hw composer
5047 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005048 mDebugDisableHWC = n != 0;
Mathias Agopian53331da2011-08-22 21:44:41 -07005049 invalidateHwcGeometry();
5050 repaintEverything();
5051 return NO_ERROR;
Mathias Agopiana4583642011-08-23 18:03:18 -07005052 case 1009: // toggle use of transform hint
5053 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005054 mDebugDisableTransformHint = n != 0;
Mathias Agopiana4583642011-08-23 18:03:18 -07005055 invalidateHwcGeometry();
5056 repaintEverything();
5057 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005058 case 1010: // interrogate.
Mathias Agopian01b76682009-04-16 20:04:08 -07005059 reply->writeInt32(0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005060 reply->writeInt32(0);
5061 reply->writeInt32(mDebugRegion);
Mathias Agopianb9494d52012-04-18 02:28:45 -07005062 reply->writeInt32(0);
Dianne Hackborn12839be2012-02-06 21:21:05 -08005063 reply->writeInt32(mDebugDisableHWC);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005064 return NO_ERROR;
5065 case 1013: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005066 const auto display = getDefaultDisplayDevice();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07005067 if (!display) {
5068 return NAME_NOT_FOUND;
5069 }
5070
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005071 reply->writeInt32(display->getPageFlipCount());
Mathias Agopianff2ed702013-09-01 21:36:12 -07005072 return NO_ERROR;
5073 }
5074 case 1014: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005075 Mutex::Autolock _l(mStateLock);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005076 // daltonize
5077 n = data.readInt32();
5078 switch (n % 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005079 case 1:
5080 mDaltonizer.setType(ColorBlindnessType::Protanomaly);
5081 break;
5082 case 2:
5083 mDaltonizer.setType(ColorBlindnessType::Deuteranomaly);
5084 break;
5085 case 3:
5086 mDaltonizer.setType(ColorBlindnessType::Tritanomaly);
5087 break;
5088 default:
5089 mDaltonizer.setType(ColorBlindnessType::None);
5090 break;
Mathias Agopianff2ed702013-09-01 21:36:12 -07005091 }
5092 if (n >= 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005093 mDaltonizer.setMode(ColorBlindnessMode::Correction);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005094 } else {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005095 mDaltonizer.setMode(ColorBlindnessMode::Simulation);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005096 }
Chia-I Wu28f320b2018-05-03 11:02:56 -07005097
5098 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005099 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005100 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005101 case 1015: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005102 Mutex::Autolock _l(mStateLock);
Alan Viverette9c5a3332013-09-12 20:04:35 -07005103 // apply a color matrix
5104 n = data.readInt32();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005105 if (n) {
Romain Guy0147a172017-06-01 13:53:56 -07005106 // color matrix is sent as a column-major mat4 matrix
Alan Viverette794c5ba2013-10-03 16:40:52 -07005107 for (size_t i = 0 ; i < 4; i++) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005108 for (size_t j = 0; j < 4; j++) {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005109 mClientColorMatrix[i][j] = data.readFloat();
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005110 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005111 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005112 } else {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005113 mClientColorMatrix = mat4();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005114 }
Romain Guy88d37dd2017-05-26 17:57:05 -07005115
5116 // Check that supplied matrix's last row is {0,0,0,1} so we can avoid
5117 // the division by w in the fragment shader
Chia-I Wu28f320b2018-05-03 11:02:56 -07005118 float4 lastRow(transpose(mClientColorMatrix)[3]);
Romain Guy88d37dd2017-05-26 17:57:05 -07005119 if (any(greaterThan(abs(lastRow - float4{0, 0, 0, 1}), float4{1e-4f}))) {
5120 ALOGE("The color transform's last row must be (0, 0, 0, 1)");
5121 }
5122
Chia-I Wu28f320b2018-05-03 11:02:56 -07005123 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005124 return NO_ERROR;
5125 }
Dominik Laskowski8d32ddc2019-08-07 11:25:35 -07005126 case 1016: { // Unused.
5127 return NAME_NOT_FOUND;
Ruchi Kandoif52b3c82014-04-24 16:42:35 -07005128 }
Dan Stozaee44edd2015-03-23 15:50:23 -07005129 case 1017: {
5130 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005131 mForceFullDamage = n != 0;
Dan Stozaee44edd2015-03-23 15:50:23 -07005132 return NO_ERROR;
5133 }
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005134 case 1018: { // Modify Choreographer's phase offset
5135 n = data.readInt32();
Ana Krulecc2870422019-01-29 19:00:58 -08005136 mScheduler->setPhaseOffset(mAppConnectionHandle, static_cast<nsecs_t>(n));
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005137 return NO_ERROR;
5138 }
5139 case 1019: { // Modify SurfaceFlinger's phase offset
5140 n = data.readInt32();
Ana Krulecc2870422019-01-29 19:00:58 -08005141 mScheduler->setPhaseOffset(mSfConnectionHandle, static_cast<nsecs_t>(n));
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005142 return NO_ERROR;
5143 }
Irvel468051e2016-06-13 16:44:44 -07005144 case 1020: { // Layer updates interceptor
5145 n = data.readInt32();
5146 if (n) {
5147 ALOGV("Interceptor enabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08005148 mInterceptor->enable(mDrawingState.layersSortedByZ, mDrawingState.displays);
Irvel468051e2016-06-13 16:44:44 -07005149 }
5150 else{
5151 ALOGV("Interceptor disabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08005152 mInterceptor->disable();
Irvel468051e2016-06-13 16:44:44 -07005153 }
5154 return NO_ERROR;
5155 }
Dan Stoza8cf150a2016-08-02 10:27:31 -07005156 case 1021: { // Disable HWC virtual displays
5157 n = data.readInt32();
5158 mUseHwcVirtualDisplays = !n;
5159 return NO_ERROR;
5160 }
Romain Guy0147a172017-06-01 13:53:56 -07005161 case 1022: { // Set saturation boost
Chia-I Wu28f320b2018-05-03 11:02:56 -07005162 Mutex::Autolock _l(mStateLock);
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005163 mGlobalSaturationFactor = std::max(0.0f, std::min(data.readFloat(), 2.0f));
Romain Guy0147a172017-06-01 13:53:56 -07005164
Chia-I Wu28f320b2018-05-03 11:02:56 -07005165 updateColorMatrixLocked();
Romain Guy0147a172017-06-01 13:53:56 -07005166 return NO_ERROR;
5167 }
Romain Guy54f154a2017-10-24 21:40:32 +01005168 case 1023: { // Set native mode
Daniel Solomon7c7ede22019-07-11 16:35:40 -07005169 int32_t colorMode;
5170
Chia-I Wu0d711262018-05-21 15:19:35 -07005171 mDisplayColorSetting = static_cast<DisplayColorSetting>(data.readInt32());
Daniel Solomon7c7ede22019-07-11 16:35:40 -07005172 if (data.readInt32(&colorMode) == NO_ERROR) {
5173 mForceColorMode = static_cast<ColorMode>(colorMode);
5174 }
Romain Guy54f154a2017-10-24 21:40:32 +01005175 invalidateHwcGeometry();
5176 repaintEverything();
5177 return NO_ERROR;
5178 }
Peiyong Lin4bac91c2018-10-25 09:48:33 -07005179 // Deprecate, use 1030 to check whether the device is color managed.
5180 case 1024: {
5181 return NAME_NOT_FOUND;
Romain Guy54f154a2017-10-24 21:40:32 +01005182 }
Vishnu Nair87704c92018-01-08 15:32:57 -08005183 case 1025: { // Set layer tracing
Adrian Roos1e1a1282017-11-01 19:05:31 +01005184 n = data.readInt32();
5185 if (n) {
Yichi Chenadc69612018-09-15 14:51:18 +08005186 ALOGD("LayerTracing enabled");
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07005187 mTracingEnabledChanged = mTracing.enable();
Adrian Roos1e1a1282017-11-01 19:05:31 +01005188 reply->writeInt32(NO_ERROR);
5189 } else {
Yichi Chenadc69612018-09-15 14:51:18 +08005190 ALOGD("LayerTracing disabled");
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07005191 mTracingEnabledChanged = mTracing.disable();
5192 if (mTracingEnabledChanged) {
Nataniel Borges2b796da2019-02-15 13:32:18 -08005193 reply->writeInt32(mTracing.writeToFile());
5194 } else {
5195 reply->writeInt32(NO_ERROR);
5196 }
Adrian Roos1e1a1282017-11-01 19:05:31 +01005197 }
5198 return NO_ERROR;
5199 }
Vishnu Nair87704c92018-01-08 15:32:57 -08005200 case 1026: { // Get layer tracing status
5201 reply->writeBool(mTracing.isEnabled());
5202 return NO_ERROR;
5203 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005204 // Is a DisplayColorSetting supported?
5205 case 1027: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005206 const auto display = getDefaultDisplayDevice();
5207 if (!display) {
Chia-I Wu0d711262018-05-21 15:19:35 -07005208 return NAME_NOT_FOUND;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005209 }
Chia-I Wu0d711262018-05-21 15:19:35 -07005210
5211 DisplayColorSetting setting = static_cast<DisplayColorSetting>(data.readInt32());
5212 switch (setting) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -08005213 case DisplayColorSetting::kManaged:
Peiyong Lin13effd12018-07-24 17:01:47 -07005214 reply->writeBool(useColorManagement);
Chia-I Wu0d711262018-05-21 15:19:35 -07005215 break;
Lloyd Pique6a3b4462019-03-07 20:58:12 -08005216 case DisplayColorSetting::kUnmanaged:
Chia-I Wu0d711262018-05-21 15:19:35 -07005217 reply->writeBool(true);
5218 break;
Lloyd Pique6a3b4462019-03-07 20:58:12 -08005219 case DisplayColorSetting::kEnhanced:
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005220 reply->writeBool(display->hasRenderIntent(RenderIntent::ENHANCE));
Chia-I Wu0d711262018-05-21 15:19:35 -07005221 break;
5222 default: // vendor display color setting
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005223 reply->writeBool(
5224 display->hasRenderIntent(static_cast<RenderIntent>(setting)));
Chia-I Wu0d711262018-05-21 15:19:35 -07005225 break;
5226 }
5227 return NO_ERROR;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005228 }
Steven Thomas97f1f4c2018-06-01 12:04:16 -07005229 // Is VrFlinger active?
5230 case 1028: {
5231 Mutex::Autolock _l(mStateLock);
Lloyd Pique441d5042018-10-18 16:49:51 -07005232 reply->writeBool(getHwComposer().isUsingVrComposer());
Steven Thomas97f1f4c2018-06-01 12:04:16 -07005233 return NO_ERROR;
5234 }
Nataniel Borges2b796da2019-02-15 13:32:18 -08005235 // Set buffer size for SF tracing (value in KB)
5236 case 1029: {
5237 n = data.readInt32();
5238 if (n <= 0 || n > MAX_TRACING_MEMORY) {
5239 ALOGW("Invalid buffer size: %d KB", n);
5240 reply->writeInt32(BAD_VALUE);
5241 return BAD_VALUE;
5242 }
5243
5244 ALOGD("Updating trace buffer to %d KB", n);
5245 mTracing.setBufferSize(n * 1024);
5246 reply->writeInt32(NO_ERROR);
5247 return NO_ERROR;
5248 }
Peiyong Lin13effd12018-07-24 17:01:47 -07005249 // Is device color managed?
5250 case 1030: {
5251 reply->writeBool(useColorManagement);
5252 return NO_ERROR;
5253 }
Peiyong Lin9d846a52018-11-05 13:18:20 -08005254 // Override default composition data space
5255 // adb shell service call SurfaceFlinger 1031 i32 1 DATASPACE_NUMBER DATASPACE_NUMBER \
5256 // && adb shell stop zygote && adb shell start zygote
5257 // to restore: adb shell service call SurfaceFlinger 1031 i32 0 && \
5258 // adb shell stop zygote && adb shell start zygote
5259 case 1031: {
5260 Mutex::Autolock _l(mStateLock);
5261 n = data.readInt32();
5262 if (n) {
5263 n = data.readInt32();
5264 if (n) {
5265 Dataspace dataspace = static_cast<Dataspace>(n);
5266 if (!validateCompositionDataspace(dataspace)) {
5267 return BAD_VALUE;
5268 }
5269 mDefaultCompositionDataspace = dataspace;
5270 }
5271 n = data.readInt32();
5272 if (n) {
5273 Dataspace dataspace = static_cast<Dataspace>(n);
5274 if (!validateCompositionDataspace(dataspace)) {
5275 return BAD_VALUE;
5276 }
5277 mWideColorGamutCompositionDataspace = dataspace;
5278 }
5279 } else {
5280 // restore composition data space.
5281 mDefaultCompositionDataspace = defaultCompositionDataspace;
5282 mWideColorGamutCompositionDataspace = wideColorGamutCompositionDataspace;
5283 }
5284 return NO_ERROR;
5285 }
Vishnu Nair9245d3b2019-03-22 13:38:56 -07005286 // Set trace flags
5287 case 1033: {
5288 n = data.readUint32();
5289 ALOGD("Updating trace flags to 0x%x", n);
5290 mTracing.setTraceFlags(n);
5291 reply->writeInt32(NO_ERROR);
5292 return NO_ERROR;
5293 }
Ady Abraham03b02dd2019-03-21 15:40:11 -07005294 case 1034: {
Dominik Laskowski20134642020-04-20 22:36:44 -07005295 switch (n = data.readInt32()) {
5296 case 0:
5297 case 1:
5298 enableRefreshRateOverlay(static_cast<bool>(n));
5299 break;
5300 default: {
5301 Mutex::Autolock lock(mStateLock);
5302 reply->writeBool(mRefreshRateOverlay != nullptr);
5303 }
Ady Abraham03b02dd2019-03-21 15:40:11 -07005304 }
5305 return NO_ERROR;
5306 }
Ady Abraham34392f72019-04-10 11:29:27 -07005307 case 1035: {
5308 n = data.readInt32();
5309 mDebugDisplayConfigSetByBackdoor = false;
5310 if (n >= 0) {
5311 const auto displayToken = getInternalDisplayToken();
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005312 status_t result = setActiveConfig(displayToken, n);
Ady Abraham34392f72019-04-10 11:29:27 -07005313 if (result != NO_ERROR) {
5314 return result;
5315 }
5316 mDebugDisplayConfigSetByBackdoor = true;
5317 }
5318 return NO_ERROR;
5319 }
Ady Abraham07e54702020-04-16 15:05:37 -07005320 case 1036: {
5321 if (data.readInt32() > 0) {
5322 status_t result =
5323 acquireFrameRateFlexibilityToken(&mDebugFrameRateFlexibilityToken);
5324 if (result != NO_ERROR) {
5325 return result;
5326 }
5327 } else {
5328 mDebugFrameRateFlexibilityToken = nullptr;
5329 }
5330 return NO_ERROR;
5331 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005332 }
5333 }
5334 return err;
5335}
5336
Steven Thomas6d8110b2017-08-31 18:24:21 -07005337void SurfaceFlinger::repaintEverything() {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07005338 mRepaintEverything = true;
Dan Stozac7a25ad2018-04-12 11:45:09 -07005339 signalTransaction();
Steven Thomas6d8110b2017-08-31 18:24:21 -07005340}
5341
Ana Krulec7d1d6832018-12-27 11:10:09 -08005342void SurfaceFlinger::repaintEverythingForHWC() {
5343 mRepaintEverything = true;
Dan Stoza030fbc12020-02-19 15:32:01 -08005344 mPowerAdvisor.notifyDisplayUpdateImminent();
Ady Abraham8532d012019-05-08 14:50:56 -07005345 mEventQueue->invalidate();
Ana Krulec7d1d6832018-12-27 11:10:09 -08005346}
5347
Ady Abrahama09852a2020-02-20 14:23:42 -08005348void SurfaceFlinger::kernelTimerChanged(bool expired) {
5349 static bool updateOverlay =
5350 property_get_bool("debug.sf.kernel_idle_timer_update_overlay", true);
Dominik Laskowski20134642020-04-20 22:36:44 -07005351 if (!updateOverlay) return;
5352 if (Mutex::Autolock lock(mStateLock); !mRefreshRateOverlay) return;
Ady Abrahama09852a2020-02-20 14:23:42 -08005353
5354 // Update the overlay on the main thread to avoid race conditions with
5355 // mRefreshRateConfigs->getCurrentRefreshRate()
Dominik Laskowski20134642020-04-20 22:36:44 -07005356 static_cast<void>(schedule([=] {
5357 const auto desiredActiveConfig = getDesiredActiveConfig();
5358 const auto& current = desiredActiveConfig
5359 ? mRefreshRateConfigs->getRefreshRateFromConfigId(desiredActiveConfig->configId)
5360 : mRefreshRateConfigs->getCurrentRefreshRate();
5361 const auto& min = mRefreshRateConfigs->getMinRefreshRate();
5362
5363 if (current != min) {
Ady Abrahama09852a2020-02-20 14:23:42 -08005364 const auto kernelTimerEnabled = property_get_bool(KERNEL_IDLE_TIMER_PROP, false);
5365 const bool timerExpired = kernelTimerEnabled && expired;
Ady Abrahama09852a2020-02-20 14:23:42 -08005366
Dominik Laskowski20134642020-04-20 22:36:44 -07005367 if (Mutex::Autolock lock(mStateLock); mRefreshRateOverlay) {
Ady Abrahama09852a2020-02-20 14:23:42 -08005368 mRefreshRateOverlay->changeRefreshRate(timerExpired ? min : current);
Ady Abrahama09852a2020-02-20 14:23:42 -08005369 }
Dominik Laskowski20134642020-04-20 22:36:44 -07005370 mEventQueue->invalidate();
Ady Abrahama09852a2020-02-20 14:23:42 -08005371 }
5372 }));
5373}
5374
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005375// A simple RAII class to disconnect from an ANativeWindow* when it goes out of scope
5376class WindowDisconnector {
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005377public:
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005378 WindowDisconnector(ANativeWindow* window, int api) : mWindow(window), mApi(api) {}
5379 ~WindowDisconnector() {
5380 native_window_api_disconnect(mWindow, mApi);
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005381 }
5382
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005383private:
5384 ANativeWindow* mWindow;
5385 const int mApi;
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005386};
5387
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005388status_t SurfaceFlinger::captureScreen(const sp<IBinder>& displayToken,
Robert Carr108b2c72019-04-02 16:32:58 -07005389 sp<GraphicBuffer>* outBuffer, bool& outCapturedSecureLayers,
Dominik Laskowski718f9602019-11-09 20:01:35 -08005390 Dataspace reqDataspace, ui::PixelFormat reqPixelFormat,
5391 const Rect& sourceCrop, uint32_t reqWidth,
5392 uint32_t reqHeight, bool useIdentityTransform,
5393 ui::Rotation rotation, bool captureSecureLayers) {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005394 ATRACE_CALL();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005395
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005396 if (!displayToken) return BAD_VALUE;
chaviwa76b2712017-09-20 12:02:26 -07005397
Dominik Laskowski718f9602019-11-09 20:01:35 -08005398 auto renderAreaRotation = ui::Transform::toRotationFlags(rotation);
5399 if (renderAreaRotation == ui::Transform::ROT_INVALID) {
5400 ALOGE("%s: Invalid rotation: %s", __FUNCTION__, toCString(rotation));
5401 renderAreaRotation = ui::Transform::ROT_0;
5402 }
Chia-I Wuc80dcbb2018-08-24 15:34:02 -07005403
Chia-I Wu20261cb2018-08-23 12:55:44 -07005404 sp<DisplayDevice> display;
5405 {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005406 Mutex::Autolock lock(mStateLock);
Garfield Tan3b1b8af2018-03-16 17:37:33 -07005407
Chia-I Wu20261cb2018-08-23 12:55:44 -07005408 display = getDisplayDeviceLocked(displayToken);
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005409 if (!display) return NAME_NOT_FOUND;
Chia-I Wu20261cb2018-08-23 12:55:44 -07005410
Chia-I Wucb023152018-08-28 12:57:23 -07005411 // set the requested width/height to the logical display viewport size
5412 // by default
5413 if (reqWidth == 0 || reqHeight == 0) {
5414 reqWidth = uint32_t(display->getViewport().width());
5415 reqHeight = uint32_t(display->getViewport().height());
Chia-I Wu20261cb2018-08-23 12:55:44 -07005416 }
Yiwei Zhang06a58e22018-08-20 16:42:23 -07005417 }
5418
Peiyong Lin0e003c92018-09-17 11:09:51 -07005419 DisplayRenderArea renderArea(display, sourceCrop, reqWidth, reqHeight, reqDataspace,
Robert Carrfa8855f2019-02-19 10:05:00 -08005420 renderAreaRotation, captureSecureLayers);
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08005421 auto traverseLayers = std::bind(&SurfaceFlinger::traverseLayersInDisplay, this, display,
5422 std::placeholders::_1);
Peiyong Lin0e003c92018-09-17 11:09:51 -07005423 return captureScreenCommon(renderArea, traverseLayers, outBuffer, reqPixelFormat,
Robert Carr108b2c72019-04-02 16:32:58 -07005424 useIdentityTransform, outCapturedSecureLayers);
chaviwa76b2712017-09-20 12:02:26 -07005425}
5426
chaviw93df2ea2019-04-30 16:45:12 -07005427static Dataspace pickDataspaceFromColorMode(const ColorMode colorMode) {
5428 switch (colorMode) {
5429 case ColorMode::DISPLAY_P3:
5430 case ColorMode::BT2100_PQ:
5431 case ColorMode::BT2100_HLG:
5432 case ColorMode::DISPLAY_BT2020:
5433 return Dataspace::DISPLAY_P3;
5434 default:
5435 return Dataspace::V0_SRGB;
5436 }
5437}
5438
Martin Liu4a322352020-03-24 21:30:38 +08005439status_t SurfaceFlinger::setSchedFifo(bool enabled) {
5440 static constexpr int kFifoPriority = 2;
5441 static constexpr int kOtherPriority = 0;
5442
5443 struct sched_param param = {0};
5444 int sched_policy;
5445 if (enabled) {
5446 sched_policy = SCHED_FIFO;
5447 param.sched_priority = kFifoPriority;
5448 } else {
5449 sched_policy = SCHED_OTHER;
5450 param.sched_priority = kOtherPriority;
5451 }
5452
5453 if (sched_setscheduler(0, sched_policy, &param) != 0) {
5454 return -errno;
5455 }
5456 return NO_ERROR;
5457}
5458
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07005459sp<DisplayDevice> SurfaceFlinger::getDisplayByIdOrLayerStack(uint64_t displayOrLayerStack) {
chaviw93df2ea2019-04-30 16:45:12 -07005460 const sp<IBinder> displayToken = getPhysicalDisplayTokenLocked(DisplayId{displayOrLayerStack});
5461 if (displayToken) {
5462 return getDisplayDeviceLocked(displayToken);
5463 }
5464 // Couldn't find display by displayId. Try to get display by layerStack since virtual displays
5465 // may not have a displayId.
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005466 return getDisplayByLayerStack(displayOrLayerStack);
5467}
5468
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07005469sp<DisplayDevice> SurfaceFlinger::getDisplayByLayerStack(uint64_t layerStack) {
chaviw93df2ea2019-04-30 16:45:12 -07005470 for (const auto& [token, display] : mDisplays) {
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005471 if (display->getLayerStack() == layerStack) {
chaviw93df2ea2019-04-30 16:45:12 -07005472 return display;
5473 }
5474 }
5475 return nullptr;
5476}
5477
5478status_t SurfaceFlinger::captureScreen(uint64_t displayOrLayerStack, Dataspace* outDataspace,
5479 sp<GraphicBuffer>* outBuffer) {
5480 sp<DisplayDevice> display;
5481 uint32_t width;
5482 uint32_t height;
Dominik Laskowski718f9602019-11-09 20:01:35 -08005483 ui::Transform::RotationFlags captureOrientation;
chaviw93df2ea2019-04-30 16:45:12 -07005484 {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005485 Mutex::Autolock lock(mStateLock);
chaviw93df2ea2019-04-30 16:45:12 -07005486 display = getDisplayByIdOrLayerStack(displayOrLayerStack);
5487 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005488 return NAME_NOT_FOUND;
chaviw93df2ea2019-04-30 16:45:12 -07005489 }
5490
5491 width = uint32_t(display->getViewport().width());
5492 height = uint32_t(display->getViewport().height());
5493
Dominik Laskowski718f9602019-11-09 20:01:35 -08005494 const auto orientation = display->getOrientation();
5495 captureOrientation = ui::Transform::toRotationFlags(orientation);
5496
5497 switch (captureOrientation) {
5498 case ui::Transform::ROT_90:
5499 captureOrientation = ui::Transform::ROT_270;
5500 break;
5501
5502 case ui::Transform::ROT_270:
5503 captureOrientation = ui::Transform::ROT_90;
5504 break;
5505
5506 case ui::Transform::ROT_INVALID:
5507 ALOGE("%s: Invalid orientation: %s", __FUNCTION__, toCString(orientation));
5508 captureOrientation = ui::Transform::ROT_0;
5509 break;
5510
5511 default:
5512 break;
Alec Mouri21fab752019-06-20 14:12:17 -07005513 }
chaviw93df2ea2019-04-30 16:45:12 -07005514 *outDataspace =
5515 pickDataspaceFromColorMode(display->getCompositionDisplay()->getState().colorMode);
5516 }
5517
5518 DisplayRenderArea renderArea(display, Rect(), width, height, *outDataspace, captureOrientation,
5519 false /* captureSecureLayers */);
5520
5521 auto traverseLayers = std::bind(&SurfaceFlinger::traverseLayersInDisplay, this, display,
5522 std::placeholders::_1);
5523 bool ignored = false;
5524 return captureScreenCommon(renderArea, traverseLayers, outBuffer, ui::PixelFormat::RGBA_8888,
5525 false /* useIdentityTransform */,
5526 ignored /* outCapturedSecureLayers */);
5527}
5528
Robert Carr866455f2019-04-02 16:28:26 -07005529status_t SurfaceFlinger::captureLayers(
5530 const sp<IBinder>& layerHandleBinder, sp<GraphicBuffer>* outBuffer,
5531 const Dataspace reqDataspace, const ui::PixelFormat reqPixelFormat, const Rect& sourceCrop,
5532 const std::unordered_set<sp<IBinder>, ISurfaceComposer::SpHash<IBinder>>& excludeHandles,
5533 float frameScale, bool childrenOnly) {
chaviwa76b2712017-09-20 12:02:26 -07005534 ATRACE_CALL();
5535
5536 class LayerRenderArea : public RenderArea {
5537 public:
Robert Carr578038f2018-03-09 12:25:24 -08005538 LayerRenderArea(SurfaceFlinger* flinger, const sp<Layer>& layer, const Rect crop,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005539 int32_t reqWidth, int32_t reqHeight, Dataspace reqDataSpace,
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005540 bool childrenOnly, const Rect& displayViewport)
5541 : RenderArea(reqWidth, reqHeight, CaptureFill::CLEAR, reqDataSpace, displayViewport),
Robert Carr578038f2018-03-09 12:25:24 -08005542 mLayer(layer),
5543 mCrop(crop),
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005544 mNeedsFiltering(false),
Robert Carr578038f2018-03-09 12:25:24 -08005545 mFlinger(flinger),
5546 mChildrenOnly(childrenOnly) {}
Peiyong Linefefaac2018-08-17 12:27:51 -07005547 const ui::Transform& getTransform() const override { return mTransform; }
Alec Mouri5a6d8572020-03-23 23:56:15 -07005548 Rect getBounds() const override { return mLayer->getBufferSize(mLayer->getDrawingState()); }
Marissa Wall61c58622018-07-18 10:12:20 -07005549 int getHeight() const override {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08005550 return mLayer->getBufferSize(mLayer->getDrawingState()).getHeight();
Marissa Wall61c58622018-07-18 10:12:20 -07005551 }
Vishnu Nair88a11f22018-11-28 18:30:57 -08005552 int getWidth() const override {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08005553 return mLayer->getBufferSize(mLayer->getDrawingState()).getWidth();
Vishnu Nair88a11f22018-11-28 18:30:57 -08005554 }
chaviwa76b2712017-09-20 12:02:26 -07005555 bool isSecure() const override { return false; }
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005556 bool needsFiltering() const override { return mNeedsFiltering; }
Dominik Laskowski718f9602019-11-09 20:01:35 -08005557 sp<const DisplayDevice> getDisplayDevice() const override { return nullptr; }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005558 Rect getSourceCrop() const override {
5559 if (mCrop.isEmpty()) {
5560 return getBounds();
5561 } else {
5562 return mCrop;
5563 }
5564 }
Robert Carr578038f2018-03-09 12:25:24 -08005565 class ReparentForDrawing {
5566 public:
5567 const sp<Layer>& oldParent;
5568 const sp<Layer>& newParent;
5569
Vishnu Nair4351ad52019-02-11 14:13:02 -08005570 ReparentForDrawing(const sp<Layer>& oldParent, const sp<Layer>& newParent,
5571 const Rect& drawingBounds)
Robert Carr578038f2018-03-09 12:25:24 -08005572 : oldParent(oldParent), newParent(newParent) {
Vishnu Nair4351ad52019-02-11 14:13:02 -08005573 // Compute and cache the bounds for the new parent layer.
Vishnu Nairc97b8db2019-10-29 18:19:35 -07005574 newParent->computeBounds(drawingBounds.toFloatRect(), ui::Transform(),
5575 0.f /* shadowRadius */);
Robert Carr15eae092018-03-23 13:43:53 -07005576 oldParent->setChildrenDrawingParent(newParent);
Robert Carr578038f2018-03-09 12:25:24 -08005577 }
Vishnu Nairbce6ffd2019-02-14 10:58:59 -08005578 ~ReparentForDrawing() { oldParent->setChildrenDrawingParent(oldParent); }
Robert Carr578038f2018-03-09 12:25:24 -08005579 };
5580
5581 void render(std::function<void()> drawLayers) override {
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005582 const Rect sourceCrop = getSourceCrop();
5583 // no need to check rotation because there is none
5584 mNeedsFiltering = sourceCrop.width() != getReqWidth() ||
5585 sourceCrop.height() != getReqHeight();
5586
Robert Carr578038f2018-03-09 12:25:24 -08005587 if (!mChildrenOnly) {
5588 mTransform = mLayer->getTransform().inverse();
5589 drawLayers();
5590 } else {
Alec Mouri5a6d8572020-03-23 23:56:15 -07005591 uint32_t w = static_cast<uint32_t>(getWidth());
5592 uint32_t h = static_cast<uint32_t>(getHeight());
chaviw32811fd2019-08-12 13:16:09 -07005593 // In the "childrenOnly" case we reparent the children to a screenshot
5594 // layer which has no properties set and which does not draw.
5595 sp<ContainerLayer> screenshotParentLayer =
Dominik Laskowski87a07e42019-10-10 20:38:02 -07005596 mFlinger->getFactory().createContainerLayer({mFlinger, nullptr,
5597 "Screenshot Parent"s, w, h, 0,
5598 LayerMetadata()});
Robert Carr578038f2018-03-09 12:25:24 -08005599
Vishnu Nair4351ad52019-02-11 14:13:02 -08005600 ReparentForDrawing reparent(mLayer, screenshotParentLayer, sourceCrop);
Robert Carr578038f2018-03-09 12:25:24 -08005601 drawLayers();
5602 }
5603 }
chaviwa76b2712017-09-20 12:02:26 -07005604
chaviwa76b2712017-09-20 12:02:26 -07005605 private:
chaviw7206d492017-11-10 16:16:12 -08005606 const sp<Layer> mLayer;
5607 const Rect mCrop;
Robert Carr578038f2018-03-09 12:25:24 -08005608
Peiyong Linefefaac2018-08-17 12:27:51 -07005609 ui::Transform mTransform;
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005610 bool mNeedsFiltering;
Robert Carr578038f2018-03-09 12:25:24 -08005611
5612 SurfaceFlinger* mFlinger;
5613 const bool mChildrenOnly;
chaviwa76b2712017-09-20 12:02:26 -07005614 };
5615
Robert Carrc0df3122019-04-11 13:18:21 -07005616 int reqWidth = 0;
5617 int reqHeight = 0;
5618 sp<Layer> parent;
chaviw7206d492017-11-10 16:16:12 -08005619 Rect crop(sourceCrop);
Robert Carrc0df3122019-04-11 13:18:21 -07005620 std::unordered_set<sp<Layer>, ISurfaceComposer::SpHash<Layer>> excludeLayers;
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005621 Rect displayViewport;
Robert Carrc0df3122019-04-11 13:18:21 -07005622 {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005623 Mutex::Autolock lock(mStateLock);
chaviw7206d492017-11-10 16:16:12 -08005624
Alec Mouri9a02eda2020-04-21 17:39:34 -07005625 parent = fromHandleLocked(layerHandleBinder).promote();
Robert Carrc0df3122019-04-11 13:18:21 -07005626 if (parent == nullptr || parent->isRemovedFromCurrentState()) {
5627 ALOGE("captureLayers called with an invalid or removed parent");
5628 return NAME_NOT_FOUND;
5629 }
5630
5631 const int uid = IPCThreadState::self()->getCallingUid();
5632 const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
5633 if (!forSystem && parent->getCurrentState().flags & layer_state_t::eLayerSecure) {
5634 ALOGW("Attempting to capture secure layer: PERMISSION_DENIED");
5635 return PERMISSION_DENIED;
5636 }
5637
Vishnu Nairefc42e22019-12-03 17:36:12 -08005638 Rect parentSourceBounds = parent->getCroppedBufferSize(parent->getCurrentState());
Robert Carrc0df3122019-04-11 13:18:21 -07005639 if (sourceCrop.width() <= 0) {
5640 crop.left = 0;
Vishnu Nairefc42e22019-12-03 17:36:12 -08005641 crop.right = parentSourceBounds.getWidth();
Robert Carrc0df3122019-04-11 13:18:21 -07005642 }
5643
5644 if (sourceCrop.height() <= 0) {
5645 crop.top = 0;
Vishnu Nairefc42e22019-12-03 17:36:12 -08005646 crop.bottom = parentSourceBounds.getHeight();
5647 }
5648
5649 if (crop.isEmpty() || frameScale <= 0.0f) {
5650 // Error out if the layer has no source bounds (i.e. they are boundless) and a source
5651 // crop was not specified, or an invalid frame scale was provided.
5652 return BAD_VALUE;
Robert Carrc0df3122019-04-11 13:18:21 -07005653 }
5654 reqWidth = crop.width() * frameScale;
5655 reqHeight = crop.height() * frameScale;
5656
5657 for (const auto& handle : excludeHandles) {
Alec Mouri9a02eda2020-04-21 17:39:34 -07005658 sp<Layer> excludeLayer = fromHandleLocked(handle).promote();
Robert Carrc0df3122019-04-11 13:18:21 -07005659 if (excludeLayer != nullptr) {
5660 excludeLayers.emplace(excludeLayer);
5661 } else {
5662 ALOGW("Invalid layer handle passed as excludeLayer to captureLayers");
5663 return NAME_NOT_FOUND;
5664 }
5665 }
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005666
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005667 const auto display = getDisplayByLayerStack(parent->getLayerStack());
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005668 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005669 return NAME_NOT_FOUND;
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005670 }
5671
5672 displayViewport = display->getViewport();
Robert Carrc0df3122019-04-11 13:18:21 -07005673 } // mStateLock
chaviw7206d492017-11-10 16:16:12 -08005674
Chia-I Wu20261cb2018-08-23 12:55:44 -07005675 // really small crop or frameScale
5676 if (reqWidth <= 0) {
5677 reqWidth = 1;
5678 }
5679 if (reqHeight <= 0) {
5680 reqHeight = 1;
5681 }
5682
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005683 LayerRenderArea renderArea(this, parent, crop, reqWidth, reqHeight, reqDataspace, childrenOnly,
5684 displayViewport);
Robert Carr866455f2019-04-02 16:28:26 -07005685 auto traverseLayers = [parent, childrenOnly,
5686 &excludeLayers](const LayerVector::Visitor& visitor) {
chaviwa76b2712017-09-20 12:02:26 -07005687 parent->traverseChildrenInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
5688 if (!layer->isVisible()) {
5689 return;
Robert Carr578038f2018-03-09 12:25:24 -08005690 } else if (childrenOnly && layer == parent.get()) {
5691 return;
chaviwa76b2712017-09-20 12:02:26 -07005692 }
Robert Carr866455f2019-04-02 16:28:26 -07005693
5694 sp<Layer> p = layer;
5695 while (p != nullptr) {
5696 if (excludeLayers.count(p) != 0) {
5697 return;
5698 }
5699 p = p->getParent();
5700 }
5701
chaviwa76b2712017-09-20 12:02:26 -07005702 visitor(layer);
5703 });
5704 };
Robert Carr108b2c72019-04-02 16:32:58 -07005705
5706 bool outCapturedSecureLayers = false;
5707 return captureScreenCommon(renderArea, traverseLayers, outBuffer, reqPixelFormat, false,
5708 outCapturedSecureLayers);
chaviwa76b2712017-09-20 12:02:26 -07005709}
5710
5711status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea,
5712 TraverseLayersFunction traverseLayers,
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005713 sp<GraphicBuffer>* outBuffer,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005714 const ui::PixelFormat reqPixelFormat,
Robert Carr108b2c72019-04-02 16:32:58 -07005715 bool useIdentityTransform,
5716 bool& outCapturedSecureLayers) {
chaviwa76b2712017-09-20 12:02:26 -07005717 ATRACE_CALL();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005718
Peiyong Lin0e003c92018-09-17 11:09:51 -07005719 // TODO(b/116112787) Make buffer usage a parameter.
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005720 const uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
5721 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
Lloyd Pique90c115d2018-09-18 21:39:42 -07005722 *outBuffer =
5723 getFactory().createGraphicBuffer(renderArea.getReqWidth(), renderArea.getReqHeight(),
5724 static_cast<android_pixel_format>(reqPixelFormat), 1,
5725 usage, "screenshot");
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005726
Robert Carr108b2c72019-04-02 16:32:58 -07005727 return captureScreenCommon(renderArea, traverseLayers, *outBuffer, useIdentityTransform,
Lucas Dupinf11eba52020-04-20 18:42:31 -07005728 false /* regionSampling */, outCapturedSecureLayers);
Dan Stozaec460082018-12-17 15:35:09 -08005729}
5730
Kevin DuBois7cbcc372019-02-25 14:53:28 -08005731status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea,
5732 TraverseLayersFunction traverseLayers,
5733 const sp<GraphicBuffer>& buffer,
Lucas Dupinf11eba52020-04-20 18:42:31 -07005734 bool useIdentityTransform, bool regionSampling,
Robert Carr108b2c72019-04-02 16:32:58 -07005735 bool& outCapturedSecureLayers) {
Robert Carr03480e22018-01-04 16:02:06 -08005736 const int uid = IPCThreadState::self()->getCallingUid();
5737 const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
5738
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07005739 status_t result;
5740 int syncFd;
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005741
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07005742 do {
5743 std::tie(result, syncFd) =
5744 schedule([&] {
5745 if (mRefreshPending) {
5746 ATRACE_NAME("Skipping screenshot for now");
5747 return std::make_pair(EAGAIN, -1);
5748 }
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005749
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07005750 status_t result = NO_ERROR;
5751 int fd = -1;
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005752
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07005753 Mutex::Autolock lock(mStateLock);
5754 renderArea.render([&] {
5755 result = captureScreenImplLocked(renderArea, traverseLayers, buffer.get(),
5756 useIdentityTransform, forSystem, &fd,
5757 regionSampling, outCapturedSecureLayers);
5758 });
5759
5760 return std::make_pair(result, fd);
5761 }).get();
5762 } while (result == EAGAIN);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005763
5764 if (result == NO_ERROR) {
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005765 sync_wait(syncFd, -1);
5766 close(syncFd);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005767 }
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005768
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005769 return result;
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005770}
5771
chaviwa76b2712017-09-20 12:02:26 -07005772void SurfaceFlinger::renderScreenImplLocked(const RenderArea& renderArea,
Chia-I Wu1be50b52018-08-29 10:44:48 -07005773 TraverseLayersFunction traverseLayers,
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005774 ANativeWindowBuffer* buffer, bool useIdentityTransform,
Lucas Dupinf11eba52020-04-20 18:42:31 -07005775 bool regionSampling, int* outSyncFd) {
Mathias Agopian180f10d2013-04-10 22:55:41 -07005776 ATRACE_CALL();
chaviwa76b2712017-09-20 12:02:26 -07005777
chaviwa76b2712017-09-20 12:02:26 -07005778 const auto reqWidth = renderArea.getReqWidth();
5779 const auto reqHeight = renderArea.getReqHeight();
Alec Mouriadb75f42019-03-28 21:42:24 -07005780 const auto sourceCrop = renderArea.getSourceCrop();
Alec Mouri5a6d8572020-03-23 23:56:15 -07005781 const auto transform = renderArea.getTransform();
5782 const auto rotation = renderArea.getRotationFlags();
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005783 const auto& displayViewport = renderArea.getDisplayViewport();
Dan Stozac1879002014-05-22 15:59:05 -07005784
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005785 renderengine::DisplaySettings clientCompositionDisplay;
Vishnu Nair9b079a22020-01-21 14:36:08 -08005786 std::vector<compositionengine::LayerFE::LayerSettings> clientCompositionLayers;
Romain Guy88d37dd2017-05-26 17:57:05 -07005787
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005788 // assume that bounds are never offset, and that they are the same as the
5789 // buffer bounds.
5790 clientCompositionDisplay.physicalDisplay = Rect(reqWidth, reqHeight);
Alec Mouriadb75f42019-03-28 21:42:24 -07005791 clientCompositionDisplay.clip = sourceCrop;
Alec Mouri5a6d8572020-03-23 23:56:15 -07005792 clientCompositionDisplay.orientation = rotation;
Alec Mouriadb75f42019-03-28 21:42:24 -07005793
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005794 clientCompositionDisplay.outputDataspace = renderArea.getReqDataSpace();
5795 clientCompositionDisplay.maxLuminance = DisplayDevice::sDefaultMaxLumiance;
Mathias Agopian180f10d2013-04-10 22:55:41 -07005796
chaviw50da5042018-04-09 13:49:37 -07005797 const float alpha = RenderArea::getCaptureFillValue(renderArea.getCaptureFill());
Mathias Agopian180f10d2013-04-10 22:55:41 -07005798
Vishnu Nair9b079a22020-01-21 14:36:08 -08005799 compositionengine::LayerFE::LayerSettings fillLayer;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005800 fillLayer.source.buffer.buffer = nullptr;
5801 fillLayer.source.solidColor = half3(0.0, 0.0, 0.0);
Alec Mouri5a6d8572020-03-23 23:56:15 -07005802 fillLayer.geometry.boundaries =
5803 FloatRect(sourceCrop.left, sourceCrop.top, sourceCrop.right, sourceCrop.bottom);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005804 fillLayer.alpha = half(alpha);
5805 clientCompositionLayers.push_back(fillLayer);
5806
Dominik Laskowskib7251f42020-04-20 17:42:59 -07005807 const auto display = renderArea.getDisplayDevice();
Yichi Chen40773d92020-04-01 10:10:18 +08005808 std::vector<Layer*> renderedLayers;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005809 Region clearRegion = Region::INVALID_REGION;
chaviwa76b2712017-09-20 12:02:26 -07005810 traverseLayers([&](Layer* layer) {
Lloyd Piquef16688f2019-02-19 17:47:57 -08005811 const bool supportProtectedContent = false;
5812 Region clip(renderArea.getBounds());
5813 compositionengine::LayerFE::ClientCompositionTargetSettings targetSettings{
5814 clip,
5815 useIdentityTransform,
Dominik Laskowskib7251f42020-04-20 17:42:59 -07005816 layer->needsFilteringForScreenshots(display.get(), transform) ||
Alec Mouri5a6d8572020-03-23 23:56:15 -07005817 renderArea.needsFiltering(),
Lloyd Piquef16688f2019-02-19 17:47:57 -08005818 renderArea.isSecure(),
5819 supportProtectedContent,
5820 clearRegion,
Vishnu Nairb87d94f2020-02-13 09:17:36 -08005821 displayViewport,
5822 clientCompositionDisplay.outputDataspace,
5823 true, /* realContentIsVisible */
5824 false, /* clearContent */
Lloyd Piquef16688f2019-02-19 17:47:57 -08005825 };
Vishnu Nairb87d94f2020-02-13 09:17:36 -08005826 std::vector<compositionengine::LayerFE::LayerSettings> results =
5827 layer->prepareClientCompositionList(targetSettings);
Yichi Chen40773d92020-04-01 10:10:18 +08005828 if (results.size() > 0) {
Alec Mouri5a6d8572020-03-23 23:56:15 -07005829 for (auto& settings : results) {
5830 settings.geometry.positionTransform =
5831 transform.asMatrix4() * settings.geometry.positionTransform;
Lucas Dupinf11eba52020-04-20 18:42:31 -07005832 // There's no need to process blurs when we're executing region sampling,
5833 // we're just trying to understand what we're drawing, and doing so without
5834 // blurs is already a pretty good approximation.
5835 if (regionSampling) {
5836 settings.backgroundBlurRadius = 0;
5837 }
Alec Mouri5a6d8572020-03-23 23:56:15 -07005838 }
Yichi Chen40773d92020-04-01 10:10:18 +08005839 clientCompositionLayers.insert(clientCompositionLayers.end(),
5840 std::make_move_iterator(results.begin()),
5841 std::make_move_iterator(results.end()));
5842 renderedLayers.push_back(layer);
5843 }
chaviwa76b2712017-09-20 12:02:26 -07005844 });
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005845
Yichi Chen40773d92020-04-01 10:10:18 +08005846 std::vector<const renderengine::LayerSettings*> clientCompositionLayerPointers(
5847 clientCompositionLayers.size());
Vishnu Nair9b079a22020-01-21 14:36:08 -08005848 std::transform(clientCompositionLayers.begin(), clientCompositionLayers.end(),
Yichi Chen40773d92020-04-01 10:10:18 +08005849 clientCompositionLayerPointers.begin(),
5850 std::pointer_traits<renderengine::LayerSettings*>::pointer_to);
Vishnu Nair9b079a22020-01-21 14:36:08 -08005851
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005852 clientCompositionDisplay.clearRegion = clearRegion;
Alec Mouri6338c9d2019-02-07 16:57:51 -08005853 // Use an empty fence for the buffer fence, since we just created the buffer so
5854 // there is no need for synchronization with the GPU.
5855 base::unique_fd bufferFence;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005856 base::unique_fd drawFence;
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08005857 getRenderEngine().useProtectedContext(false);
Vishnu Nair9b079a22020-01-21 14:36:08 -08005858 getRenderEngine().drawLayers(clientCompositionDisplay, clientCompositionLayerPointers, buffer,
Alec Mourife0d72b2019-03-21 14:05:56 -07005859 /*useFramebufferCache=*/false, std::move(bufferFence), &drawFence);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005860
5861 *outSyncFd = drawFence.release();
Yichi Chen40773d92020-04-01 10:10:18 +08005862
5863 if (*outSyncFd >= 0) {
5864 sp<Fence> releaseFence = new Fence(dup(*outSyncFd));
5865 for (auto* layer : renderedLayers) {
5866 layer->onLayerDisplayed(releaseFence);
5867 }
5868 }
Mathias Agopian180f10d2013-04-10 22:55:41 -07005869}
5870
chaviwa76b2712017-09-20 12:02:26 -07005871status_t SurfaceFlinger::captureScreenImplLocked(const RenderArea& renderArea,
5872 TraverseLayersFunction traverseLayers,
5873 ANativeWindowBuffer* buffer,
Robert Carr108b2c72019-04-02 16:32:58 -07005874 bool useIdentityTransform, bool forSystem,
Lucas Dupinf11eba52020-04-20 18:42:31 -07005875 int* outSyncFd, bool regionSampling,
5876 bool& outCapturedSecureLayers) {
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005877 ATRACE_CALL();
5878
chaviwa76b2712017-09-20 12:02:26 -07005879 traverseLayers([&](Layer* layer) {
Robert Carr108b2c72019-04-02 16:32:58 -07005880 outCapturedSecureLayers =
5881 outCapturedSecureLayers || (layer->isVisible() && layer->isSecure());
chaviwa76b2712017-09-20 12:02:26 -07005882 });
Pablo Ceballosb5b35632016-02-23 11:18:51 -08005883
Robert Carr03480e22018-01-04 16:02:06 -08005884 // We allow the system server to take screenshots of secure layers for
5885 // use in situations like the Screen-rotation animation and place
5886 // the impetus on WindowManager to not persist them.
Robert Carr108b2c72019-04-02 16:32:58 -07005887 if (outCapturedSecureLayers && !forSystem) {
Pablo Ceballosb5b35632016-02-23 11:18:51 -08005888 ALOGW("FB is protected: PERMISSION_DENIED");
5889 return PERMISSION_DENIED;
5890 }
Lucas Dupinf11eba52020-04-20 18:42:31 -07005891 renderScreenImplLocked(renderArea, traverseLayers, buffer, useIdentityTransform, regionSampling,
5892 outSyncFd);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005893 return NO_ERROR;
Mathias Agopian74c40c02010-09-29 13:02:36 -07005894}
5895
chaviw95ef3c42019-02-14 10:55:09 -08005896void SurfaceFlinger::setInputWindowsFinished() {
5897 Mutex::Autolock _l(mStateLock);
5898
5899 mPendingSyncInputWindows = false;
Rob Carr9a2cc992020-03-06 12:44:45 -08005900
chaviw95ef3c42019-02-14 10:55:09 -08005901 mTransactionCV.broadcast();
5902}
chaviw5f21a5e2019-02-14 10:00:34 -08005903
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07005904// ---------------------------------------------------------------------------
5905
Edgar Arriaga844fa672020-01-16 14:21:42 -08005906void SurfaceFlinger::State::traverse(const LayerVector::Visitor& visitor) const {
5907 layersSortedByZ.traverse(visitor);
5908}
5909
Dan Stoza412903f2017-04-27 13:42:17 -07005910void SurfaceFlinger::State::traverseInZOrder(const LayerVector::Visitor& visitor) const {
5911 layersSortedByZ.traverseInZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07005912}
5913
Dan Stoza412903f2017-04-27 13:42:17 -07005914void SurfaceFlinger::State::traverseInReverseZOrder(const LayerVector::Visitor& visitor) const {
5915 layersSortedByZ.traverseInReverseZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07005916}
5917
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005918void SurfaceFlinger::traverseLayersInDisplay(const sp<const DisplayDevice>& display,
chaviwa76b2712017-09-20 12:02:26 -07005919 const LayerVector::Visitor& visitor) {
5920 // We loop through the first level of layers without traversing,
chaviw0e3479f2018-09-10 16:49:30 -07005921 // as we need to determine which layers belong to the requested display.
chaviwa76b2712017-09-20 12:02:26 -07005922 for (const auto& layer : mDrawingState.layersSortedByZ) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005923 if (!layer->belongsToDisplay(display->getLayerStack(), false)) {
chaviwa76b2712017-09-20 12:02:26 -07005924 continue;
5925 }
Chia-I Wuec2d9852017-11-21 09:21:01 -08005926 // relative layers are traversed in Layer::traverseInZOrder
chaviwa76b2712017-09-20 12:02:26 -07005927 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005928 if (!layer->belongsToDisplay(display->getLayerStack(), false)) {
Adrian Roos8acf5a02018-01-17 21:28:19 +01005929 return;
5930 }
chaviwa76b2712017-09-20 12:02:26 -07005931 if (!layer->isVisible()) {
5932 return;
5933 }
5934 visitor(layer);
5935 });
5936 }
5937}
5938
Steven Thomasd4071902020-03-24 16:02:53 -07005939status_t SurfaceFlinger::setDesiredDisplayConfigSpecsInternal(
5940 const sp<DisplayDevice>& display,
5941 const std::optional<scheduler::RefreshRateConfigs::Policy>& policy, bool overridePolicy) {
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005942 Mutex::Autolock lock(mStateLock);
5943
Steven Thomasd4071902020-03-24 16:02:53 -07005944 LOG_ALWAYS_FATAL_IF(!display->isPrimary() && overridePolicy,
5945 "Can only set override policy on the primary display");
5946 LOG_ALWAYS_FATAL_IF(!policy && !overridePolicy, "Can only clear the override policy");
5947
Dominik Laskowski22488f62019-03-28 09:53:04 -07005948 if (!display->isPrimary()) {
Ady Abraham3a77a7b2019-12-02 18:46:59 -08005949 // TODO(b/144711714): For non-primary displays we should be able to set an active config
5950 // as well. For now, just call directly to setActiveConfigWithConstraints but ideally
5951 // it should go thru setDesiredActiveConfig, similar to primary display.
5952 ALOGV("setAllowedDisplayConfigsInternal for non-primary display");
5953 const auto displayId = display->getId();
5954 LOG_ALWAYS_FATAL_IF(!displayId);
5955
Peiyong Line9d809e2020-04-14 13:10:48 -07005956 hal::VsyncPeriodChangeConstraints constraints;
Ady Abraham3a77a7b2019-12-02 18:46:59 -08005957 constraints.desiredTimeNanos = systemTime();
5958 constraints.seamlessRequired = false;
5959
Peiyong Line9d809e2020-04-14 13:10:48 -07005960 hal::VsyncPeriodChangeTimeline timeline = {0, 0, 0};
Steven Thomasd4071902020-03-24 16:02:53 -07005961 if (getHwComposer().setActiveConfigWithConstraints(*displayId,
5962 policy->defaultConfig.value(),
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005963 constraints, &timeline) < 0) {
5964 return BAD_VALUE;
5965 }
Ady Abraham3a77a7b2019-12-02 18:46:59 -08005966 if (timeline.refreshRequired) {
5967 repaintEverythingForHWC();
5968 }
5969
Steven Thomasd4071902020-03-24 16:02:53 -07005970 display->setActiveConfig(policy->defaultConfig);
5971 const nsecs_t vsyncPeriod = getHwComposer()
5972 .getConfigs(*displayId)[policy->defaultConfig.value()]
5973 ->getVsyncPeriod();
Ady Abrahamdfd62162020-06-10 16:11:56 -07005974 mScheduler->onNonPrimaryDisplayConfigChanged(mAppConnectionHandle, display->getId()->value,
5975 policy->defaultConfig, vsyncPeriod);
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005976 return NO_ERROR;
Ady Abraham838de062019-02-04 10:24:03 -08005977 }
5978
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005979 if (mDebugDisplayConfigSetByBackdoor) {
5980 // ignore this request as config is overridden by backdoor
5981 return NO_ERROR;
Adrian Salidoab6ef6c2019-08-28 10:02:49 -07005982 }
5983
Steven Thomasd4071902020-03-24 16:02:53 -07005984 status_t setPolicyResult = overridePolicy
5985 ? mRefreshRateConfigs->setOverridePolicy(policy)
5986 : mRefreshRateConfigs->setDisplayManagerPolicy(*policy);
5987 if (setPolicyResult < 0) {
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005988 return BAD_VALUE;
5989 }
Steven Thomasd4071902020-03-24 16:02:53 -07005990 if (setPolicyResult == scheduler::RefreshRateConfigs::CURRENT_POLICY_UNCHANGED) {
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005991 return NO_ERROR;
5992 }
Steven Thomasd4071902020-03-24 16:02:53 -07005993 scheduler::RefreshRateConfigs::Policy currentPolicy = mRefreshRateConfigs->getCurrentPolicy();
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005994
Steven Thomasf734df42020-04-13 21:09:28 -07005995 ALOGV("Setting desired display config specs: defaultConfig: %d primaryRange: [%.0f %.0f]"
5996 " expandedRange: [%.0f %.0f]",
5997 currentPolicy.defaultConfig.value(), currentPolicy.primaryRange.min,
5998 currentPolicy.primaryRange.max, currentPolicy.appRequestRange.min,
5999 currentPolicy.appRequestRange.max);
Adrian Salidoab6ef6c2019-08-28 10:02:49 -07006000
6001 // TODO(b/140204874): This hack triggers a notification that something has changed, so
6002 // that listeners that care about a change in allowed configs can get the notification.
6003 // Giving current ActiveConfig so that most other listeners would just drop the event
Alec Mouri60aee1c2019-10-28 16:18:59 -07006004 const nsecs_t vsyncPeriod =
Ady Abrahamabc27602020-04-08 17:20:29 -07006005 mRefreshRateConfigs->getRefreshRateFromConfigId(display->getActiveConfig())
6006 .getVsyncPeriod();
Ady Abrahamdfd62162020-06-10 16:11:56 -07006007 mScheduler->onPrimaryDisplayConfigChanged(mAppConnectionHandle, display->getId()->value,
6008 display->getActiveConfig(), vsyncPeriod);
Ady Abraham838de062019-02-04 10:24:03 -08006009
Ana Krulec3f6a2062020-01-23 15:48:01 -08006010 auto configId = mScheduler->getPreferredConfigId();
Ady Abraham2e1dd892020-03-05 13:48:36 -08006011 auto& preferredRefreshRate = configId
Ana Krulec3f6a2062020-01-23 15:48:01 -08006012 ? mRefreshRateConfigs->getRefreshRateFromConfigId(*configId)
6013 // NOTE: Choose the default config ID, if Scheduler doesn't have one in mind.
Steven Thomasd4071902020-03-24 16:02:53 -07006014 : mRefreshRateConfigs->getRefreshRateFromConfigId(currentPolicy.defaultConfig);
Ana Krulec3f6a2062020-01-23 15:48:01 -08006015 ALOGV("trying to switch to Scheduler preferred config %d (%s)",
Ady Abrahamabc27602020-04-08 17:20:29 -07006016 preferredRefreshRate.getConfigId().value(), preferredRefreshRate.getName().c_str());
Ana Krulec3f6a2062020-01-23 15:48:01 -08006017
Ady Abrahamabc27602020-04-08 17:20:29 -07006018 if (isDisplayConfigAllowed(preferredRefreshRate.getConfigId())) {
6019 ALOGV("switching to Scheduler preferred config %d",
6020 preferredRefreshRate.getConfigId().value());
6021 setDesiredActiveConfig(
6022 {preferredRefreshRate.getConfigId(), Scheduler::ConfigEvent::Changed});
Ady Abraham2139f732019-11-13 18:56:40 -08006023 } else {
Ady Abrahamabc27602020-04-08 17:20:29 -07006024 LOG_ALWAYS_FATAL("Desired config not allowed: %d",
6025 preferredRefreshRate.getConfigId().value());
Dominik Laskowski4f1dd8c2019-04-17 15:54:30 -07006026 }
6027
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08006028 return NO_ERROR;
6029}
6030
Ana Krulec0782b882019-10-15 17:34:54 -07006031status_t SurfaceFlinger::setDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken,
Steven Thomasf734df42020-04-13 21:09:28 -07006032 int32_t defaultConfig,
6033 float primaryRefreshRateMin,
6034 float primaryRefreshRateMax,
6035 float appRequestRefreshRateMin,
6036 float appRequestRefreshRateMax) {
Ana Krulec0782b882019-10-15 17:34:54 -07006037 ATRACE_CALL();
6038
6039 if (!displayToken) {
6040 return BAD_VALUE;
6041 }
6042
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006043 auto future = schedule([=]() -> status_t {
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07006044 const auto display = ON_MAIN_THREAD(getDisplayDeviceLocked(displayToken));
Ana Krulec234bb162019-11-10 22:55:55 +01006045 if (!display) {
6046 ALOGE("Attempt to set desired display configs for invalid display token %p",
6047 displayToken.get());
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006048 return NAME_NOT_FOUND;
Ana Krulec234bb162019-11-10 22:55:55 +01006049 } else if (display->isVirtual()) {
6050 ALOGW("Attempt to set desired display configs for virtual display");
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006051 return INVALID_OPERATION;
Ana Krulec234bb162019-11-10 22:55:55 +01006052 } else {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006053 using Policy = scheduler::RefreshRateConfigs::Policy;
Steven Thomasf734df42020-04-13 21:09:28 -07006054 const Policy policy{HwcConfigIndexType(defaultConfig),
6055 {primaryRefreshRateMin, primaryRefreshRateMax},
6056 {appRequestRefreshRateMin, appRequestRefreshRateMax}};
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006057 constexpr bool kOverridePolicy = false;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006058
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006059 return setDesiredDisplayConfigSpecsInternal(display, policy, kOverridePolicy);
6060 }
6061 });
6062
6063 return future.get();
Ana Krulec234bb162019-11-10 22:55:55 +01006064}
6065
6066status_t SurfaceFlinger::getDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken,
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006067 int32_t* outDefaultConfig,
Steven Thomasf734df42020-04-13 21:09:28 -07006068 float* outPrimaryRefreshRateMin,
6069 float* outPrimaryRefreshRateMax,
6070 float* outAppRequestRefreshRateMin,
6071 float* outAppRequestRefreshRateMax) {
Ana Krulec234bb162019-11-10 22:55:55 +01006072 ATRACE_CALL();
6073
Steven Thomasf734df42020-04-13 21:09:28 -07006074 if (!displayToken || !outDefaultConfig || !outPrimaryRefreshRateMin ||
6075 !outPrimaryRefreshRateMax || !outAppRequestRefreshRateMin || !outAppRequestRefreshRateMax) {
Ana Krulec234bb162019-11-10 22:55:55 +01006076 return BAD_VALUE;
6077 }
6078
6079 Mutex::Autolock lock(mStateLock);
6080 const auto display = getDisplayDeviceLocked(displayToken);
6081 if (!display) {
6082 return NAME_NOT_FOUND;
6083 }
6084
6085 if (display->isPrimary()) {
Steven Thomasd4071902020-03-24 16:02:53 -07006086 scheduler::RefreshRateConfigs::Policy policy =
6087 mRefreshRateConfigs->getDisplayManagerPolicy();
6088 *outDefaultConfig = policy.defaultConfig.value();
Steven Thomasf734df42020-04-13 21:09:28 -07006089 *outPrimaryRefreshRateMin = policy.primaryRange.min;
6090 *outPrimaryRefreshRateMax = policy.primaryRange.max;
6091 *outAppRequestRefreshRateMin = policy.appRequestRange.min;
6092 *outAppRequestRefreshRateMax = policy.appRequestRange.max;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006093 return NO_ERROR;
6094 } else if (display->isVirtual()) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07006095 return INVALID_OPERATION;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006096 } else {
6097 const auto displayId = display->getId();
Dominik Laskowski470df5f2020-04-02 22:27:42 -07006098 LOG_FATAL_IF(!displayId);
6099
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006100 *outDefaultConfig = getHwComposer().getActiveConfigIndex(*displayId);
6101 auto vsyncPeriod = getHwComposer().getActiveConfig(*displayId)->getVsyncPeriod();
Steven Thomasf734df42020-04-13 21:09:28 -07006102 *outPrimaryRefreshRateMin = 1e9f / vsyncPeriod;
6103 *outPrimaryRefreshRateMax = 1e9f / vsyncPeriod;
6104 *outAppRequestRefreshRateMin = 1e9f / vsyncPeriod;
6105 *outAppRequestRefreshRateMax = 1e9f / vsyncPeriod;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006106 return NO_ERROR;
Ana Krulec234bb162019-11-10 22:55:55 +01006107 }
Ana Krulec0782b882019-10-15 17:34:54 -07006108}
6109
Dominik Laskowski9dab3432019-03-27 13:21:10 -07006110void SurfaceFlinger::SetInputWindowsListener::onSetInputWindowsFinished() {
chaviw291d88a2019-02-14 10:33:58 -08006111 mFlinger->setInputWindowsFinished();
6112}
6113
Alec Mouri9a02eda2020-04-21 17:39:34 -07006114wp<Layer> SurfaceFlinger::fromHandle(const sp<IBinder>& handle) {
6115 Mutex::Autolock _l(mStateLock);
6116 return fromHandleLocked(handle);
6117}
6118
6119wp<Layer> SurfaceFlinger::fromHandleLocked(const sp<IBinder>& handle) {
Valerie Hau09e60052019-12-15 14:51:15 -08006120 BBinder* b = nullptr;
6121 if (handle) {
6122 b = handle->localBinder();
6123 }
Robert Carrc0df3122019-04-11 13:18:21 -07006124 if (b == nullptr) {
6125 return nullptr;
6126 }
6127 auto it = mLayersByLocalBinderToken.find(b);
6128 if (it != mLayersByLocalBinderToken.end()) {
Alec Mouri9a02eda2020-04-21 17:39:34 -07006129 return it->second;
Robert Carrc0df3122019-04-11 13:18:21 -07006130 }
6131 return nullptr;
6132}
6133
Dominik Laskowski75848362019-11-11 17:57:20 -08006134void SurfaceFlinger::onLayerFirstRef(Layer* layer) {
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -07006135 mNumLayers++;
6136 mScheduler->registerLayer(layer);
6137}
6138
6139void SurfaceFlinger::onLayerDestroyed(Layer* layer) {
6140 mNumLayers--;
Valerie Hauc5686802019-11-22 14:18:09 -08006141 removeFromOffscreenLayers(layer);
6142}
6143
6144// WARNING: ONLY CALL THIS FROM LAYER DTOR
6145// Here we add children in the current state to offscreen layers and remove the
6146// layer itself from the offscreen layer list. Since
6147// this is the dtor, it is safe to access the current state. This keeps us
6148// from dangling children layers such that they are not reachable from the
6149// Drawing state nor the offscreen layer list
6150// See b/141111965
6151void SurfaceFlinger::removeFromOffscreenLayers(Layer* layer) {
6152 for (auto& child : layer->getCurrentChildren()) {
6153 mOffscreenLayers.emplace(child.get());
6154 }
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -07006155 mOffscreenLayers.erase(layer);
6156}
6157
Alec Mouri4545a8a2019-08-08 20:05:32 -07006158void SurfaceFlinger::bufferErased(const client_cache_t& clientCacheId) {
6159 getRenderEngine().unbindExternalTextureBuffer(clientCacheId.id);
6160}
6161
Vishnu Nair08f6eae2019-11-26 14:01:39 -08006162status_t SurfaceFlinger::setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
6163 float lightPosY, float lightPosZ,
6164 float lightRadius) {
6165 Mutex::Autolock _l(mStateLock);
6166 mCurrentState.globalShadowSettings.ambientColor = vec4(ambientColor);
6167 mCurrentState.globalShadowSettings.spotColor = vec4(spotColor);
6168 mCurrentState.globalShadowSettings.lightPos.y = lightPosY;
6169 mCurrentState.globalShadowSettings.lightPos.z = lightPosZ;
6170 mCurrentState.globalShadowSettings.lightRadius = lightRadius;
6171
6172 // these values are overridden when calculating the shadow settings for a layer.
6173 mCurrentState.globalShadowSettings.lightPos.x = 0.f;
6174 mCurrentState.globalShadowSettings.length = 0.f;
Vishnu Nairb13bb952019-11-15 10:24:08 -08006175 return NO_ERROR;
6176}
6177
Lloyd Pique8d9f8362020-02-11 19:13:09 -08006178const std::unordered_map<std::string, uint32_t>& SurfaceFlinger::getGenericLayerMetadataKeyMap()
6179 const {
6180 // TODO(b/149500060): Remove this fixed/static mapping. Please prefer taking
6181 // on the work to remove the table in that bug rather than adding more to
6182 // it.
6183 static const std::unordered_map<std::string, uint32_t> genericLayerMetadataKeyMap{
6184 // Note: METADATA_OWNER_UID and METADATA_WINDOW_TYPE are officially
6185 // supported, and exposed via the
6186 // IVrComposerClient::VrCommand::SET_LAYER_INFO command.
6187 {"org.chromium.arc.V1_0.TaskId", METADATA_TASK_ID},
6188 {"org.chromium.arc.V1_0.CursorInfo", METADATA_MOUSE_CURSOR},
6189 };
6190 return genericLayerMetadataKeyMap;
6191}
6192
Steven Thomas62a4cf82020-01-31 12:04:03 -08006193status_t SurfaceFlinger::setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,
6194 int8_t compatibility) {
6195 if (!ValidateFrameRate(frameRate, compatibility, "SurfaceFlinger::setFrameRate")) {
6196 return BAD_VALUE;
6197 }
6198
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07006199 static_cast<void>(schedule([=] {
Ady Abraham60e42ea2020-03-09 19:17:31 -07006200 Mutex::Autolock lock(mStateLock);
6201 if (authenticateSurfaceTextureLocked(surface)) {
6202 sp<Layer> layer = (static_cast<MonitoredProducer*>(surface.get()))->getLayer();
6203 if (layer->setFrameRate(
6204 Layer::FrameRate(frameRate,
6205 Layer::FrameRate::convertCompatibility(compatibility)))) {
6206 setTransactionFlags(eTraversalNeeded);
6207 }
6208 } else {
6209 ALOGE("Attempt to set frame rate on an unrecognized IGraphicBufferProducer");
6210 return BAD_VALUE;
Steven Thomas62a4cf82020-01-31 12:04:03 -08006211 }
Ady Abraham60e42ea2020-03-09 19:17:31 -07006212 return NO_ERROR;
6213 }));
6214
Steven Thomas62a4cf82020-01-31 12:04:03 -08006215 return NO_ERROR;
6216}
6217
Steven Thomasd4071902020-03-24 16:02:53 -07006218status_t SurfaceFlinger::acquireFrameRateFlexibilityToken(sp<IBinder>* outToken) {
6219 if (!outToken) {
6220 return BAD_VALUE;
6221 }
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006222
6223 auto future = schedule([this] {
6224 status_t result = NO_ERROR;
6225 sp<IBinder> token;
6226
Steven Thomasd4071902020-03-24 16:02:53 -07006227 if (mFrameRateFlexibilityTokenCount == 0) {
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07006228 const auto display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked());
Steven Thomasd4071902020-03-24 16:02:53 -07006229
6230 // This is a little racy, but not in a way that hurts anything. As we grab the
6231 // defaultConfig from the display manager policy, we could be setting a new display
6232 // manager policy, leaving us using a stale defaultConfig. The defaultConfig doesn't
6233 // matter for the override policy though, since we set allowGroupSwitching to true, so
6234 // it's not a problem.
6235 scheduler::RefreshRateConfigs::Policy overridePolicy;
6236 overridePolicy.defaultConfig =
6237 mRefreshRateConfigs->getDisplayManagerPolicy().defaultConfig;
6238 overridePolicy.allowGroupSwitching = true;
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006239 constexpr bool kOverridePolicy = true;
6240 result = setDesiredDisplayConfigSpecsInternal(display, overridePolicy, kOverridePolicy);
Steven Thomasd4071902020-03-24 16:02:53 -07006241 }
6242
6243 if (result == NO_ERROR) {
6244 mFrameRateFlexibilityTokenCount++;
6245 // Handing out a reference to the SurfaceFlinger object, as we're doing in the line
6246 // below, is something to consider carefully. The lifetime of the
6247 // FrameRateFlexibilityToken isn't tied to SurfaceFlinger object lifetime, so if this
6248 // SurfaceFlinger object were to be destroyed while the token still exists, the token
6249 // destructor would be accessing a stale SurfaceFlinger reference, and crash. This is ok
6250 // in this case, for two reasons:
6251 // 1. Once SurfaceFlinger::run() is called by main_surfaceflinger.cpp, the only way
6252 // the program exits is via a crash. So we won't have a situation where the
6253 // SurfaceFlinger object is dead but the process is still up.
6254 // 2. The frame rate flexibility token is acquired/released only by CTS tests, so even
6255 // if condition 1 were changed, the problem would only show up when running CTS tests,
6256 // not on end user devices, so we could spot it and fix it without serious impact.
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006257 token = new FrameRateFlexibilityToken(
Steven Thomasd4071902020-03-24 16:02:53 -07006258 [this]() { onFrameRateFlexibilityTokenReleased(); });
6259 ALOGD("Frame rate flexibility token acquired. count=%d",
6260 mFrameRateFlexibilityTokenCount);
6261 }
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006262
6263 return std::make_pair(result, token);
6264 });
6265
6266 status_t result;
6267 std::tie(result, *outToken) = future.get();
Steven Thomasd4071902020-03-24 16:02:53 -07006268 return result;
6269}
6270
6271void SurfaceFlinger::onFrameRateFlexibilityTokenReleased() {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006272 static_cast<void>(schedule([this] {
Steven Thomasd4071902020-03-24 16:02:53 -07006273 LOG_ALWAYS_FATAL_IF(mFrameRateFlexibilityTokenCount == 0,
6274 "Failed tracking frame rate flexibility tokens");
6275 mFrameRateFlexibilityTokenCount--;
6276 ALOGD("Frame rate flexibility token released. count=%d", mFrameRateFlexibilityTokenCount);
6277 if (mFrameRateFlexibilityTokenCount == 0) {
Dominik Laskowskia19f4b62020-04-21 00:27:31 -07006278 const auto display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked());
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006279 constexpr bool kOverridePolicy = true;
6280 status_t result = setDesiredDisplayConfigSpecsInternal(display, {}, kOverridePolicy);
Steven Thomasd4071902020-03-24 16:02:53 -07006281 LOG_ALWAYS_FATAL_IF(result < 0, "Failed releasing frame rate flexibility token");
6282 }
6283 }));
6284}
6285
Dominik Laskowski20134642020-04-20 22:36:44 -07006286void SurfaceFlinger::enableRefreshRateOverlay(bool enable) {
6287 static_cast<void>(schedule([=] {
6288 std::unique_ptr<RefreshRateOverlay> overlay;
6289 if (enable) {
6290 overlay = std::make_unique<RefreshRateOverlay>(*this);
6291 }
6292
6293 {
6294 Mutex::Autolock lock(mStateLock);
6295
6296 // Destroy the layer of the current overlay, if any, outside the lock.
6297 mRefreshRateOverlay.swap(overlay);
6298 if (!mRefreshRateOverlay) return;
6299
6300 if (const auto display = getDefaultDisplayDeviceLocked()) {
6301 mRefreshRateOverlay->setViewport(display->getSize());
6302 }
6303
6304 mRefreshRateOverlay->changeRefreshRate(mRefreshRateConfigs->getCurrentRefreshRate());
6305 }
6306 }));
6307}
6308
Dominik Laskowski9dab3432019-03-27 13:21:10 -07006309} // namespace android
Lloyd Pique074e8122018-07-26 12:57:23 -07006310
Mathias Agopian3f844832013-08-07 21:24:32 -07006311#if defined(__gl_h_)
6312#error "don't include gl/gl.h in this file"
6313#endif
6314
6315#if defined(__gl2_h_)
6316#error "don't include gl2/gl2.h in this file"
Chia-I Wu767fcf72017-11-30 22:07:38 -08006317#endif
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08006318
6319// TODO(b/129481165): remove the #pragma below and fix conversion issues
6320#pragma clang diagnostic pop // ignored "-Wconversion"