blob: a2e9e2f6da3733e18f853cd8d1a853bf1f0b92d8 [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"
Lloyd Pique90c115d2018-09-18 21:39:42 -0700118#include "Scheduler/MessageQueue.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700119#include "Scheduler/PhaseOffsets.h"
Ana Krulec98b5b242018-08-10 15:03:23 -0700120#include "Scheduler/Scheduler.h"
Alec Mouri989ddbe2020-02-06 09:26:19 -0800121#include "StartPropertySetThread.h"
122#include "SurfaceFlingerProperties.h"
123#include "SurfaceInterceptor.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800124#include "TimeStats/TimeStats.h"
Dominik Laskowskib6e54372019-09-04 14:06:28 -0700125#include "android-base/parseint.h"
David Sodman7e4ae112018-02-09 15:02:28 -0800126#include "android-base/stringprintf.h"
127
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800128namespace android {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700129
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700130using namespace std::string_literals;
131
Jaesoo Lee43518572017-01-23 19:03:16 +0900132using namespace android::hardware::configstore;
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900133using namespace android::hardware::configstore::V1_0;
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900134using namespace android::sysprop;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -0800135
Ady Abraham8532d012019-05-08 14:50:56 -0700136using android::hardware::power::V1_0::PowerHint;
Yiwei Zhang5434a782018-12-05 18:06:32 -0800137using base::StringAppendF;
Peiyong Lin9f034472018-03-28 15:29:00 -0700138using ui::ColorMode;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700139using ui::Dataspace;
Daniel Solomon42d04562019-01-20 21:03:19 -0800140using ui::DisplayPrimaries;
Peiyong Lin62665892018-04-16 11:07:44 -0700141using ui::Hdr;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700142using ui::RenderIntent;
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900143
Peiyong Line9d809e2020-04-14 13:10:48 -0700144namespace hal = android::hardware::graphics::composer::hal;
145
Steven Thomasb02664d2017-07-26 18:48:28 -0700146namespace {
Peiyong Linfca547f2018-07-09 13:03:33 -0700147
148#pragma clang diagnostic push
149#pragma clang diagnostic error "-Wswitch-enum"
150
151bool isWideColorMode(const ColorMode colorMode) {
152 switch (colorMode) {
153 case ColorMode::DISPLAY_P3:
154 case ColorMode::ADOBE_RGB:
155 case ColorMode::DCI_P3:
156 case ColorMode::BT2020:
Valerie Hau9758ae02018-10-09 16:05:09 -0700157 case ColorMode::DISPLAY_BT2020:
Peiyong Linfca547f2018-07-09 13:03:33 -0700158 case ColorMode::BT2100_PQ:
159 case ColorMode::BT2100_HLG:
160 return true;
161 case ColorMode::NATIVE:
162 case ColorMode::STANDARD_BT601_625:
163 case ColorMode::STANDARD_BT601_625_UNADJUSTED:
164 case ColorMode::STANDARD_BT601_525:
165 case ColorMode::STANDARD_BT601_525_UNADJUSTED:
166 case ColorMode::STANDARD_BT709:
167 case ColorMode::SRGB:
168 return false;
169 }
170 return false;
171}
172
173#pragma clang diagnostic pop
174
Dominik Laskowski542c9dc2020-04-10 12:42:02 -0700175template <typename Mutex>
176struct ConditionalLockGuard {
177 ConditionalLockGuard(Mutex& mutex, bool lock) : mutex(mutex), lock(lock) {
178 if (lock) mutex.lock();
Steven Thomasb02664d2017-07-26 18:48:28 -0700179 }
Dominik Laskowski542c9dc2020-04-10 12:42:02 -0700180
181 ~ConditionalLockGuard() {
182 if (lock) mutex.unlock();
183 }
184
185 Mutex& mutex;
186 const bool lock;
Steven Thomasb02664d2017-07-26 18:48:28 -0700187};
Peiyong Linfca547f2018-07-09 13:03:33 -0700188
Dominik Laskowski542c9dc2020-04-10 12:42:02 -0700189using ConditionalLock = ConditionalLockGuard<Mutex>;
190
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800191// TODO(b/141333600): Consolidate with HWC2::Display::Config::Builder::getDefaultDensity.
192constexpr float FALLBACK_DENSITY = ACONFIGURATION_DENSITY_TV / 160.f;
193
194float getDensityFromProperty(const char* property, bool required) {
195 char value[PROPERTY_VALUE_MAX];
196 const float density = property_get(property, value, nullptr) > 0 ? std::atof(value) : 0.f;
197 if (!density && required) {
198 ALOGE("%s must be defined as a build property", property);
199 return FALLBACK_DENSITY;
200 }
201 return density / 160.f;
202}
203
Peiyong Lin9d846a52018-11-05 13:18:20 -0800204// Currently we only support V0_SRGB and DISPLAY_P3 as composition preference.
205bool validateCompositionDataspace(Dataspace dataspace) {
206 return dataspace == Dataspace::V0_SRGB || dataspace == Dataspace::DISPLAY_P3;
207}
208
Steven Thomasd4071902020-03-24 16:02:53 -0700209class FrameRateFlexibilityToken : public BBinder {
210public:
211 FrameRateFlexibilityToken(std::function<void()> callback) : mCallback(callback) {}
212 virtual ~FrameRateFlexibilityToken() { mCallback(); }
213
214private:
215 std::function<void()> mCallback;
216};
217
Steven Thomasb02664d2017-07-26 18:48:28 -0700218} // namespace anonymous
219
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800220// ---------------------------------------------------------------------------
221
Mathias Agopian99b49842011-06-27 16:05:52 -0700222const String16 sHardwareTest("android.permission.HARDWARE_TEST");
223const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER");
224const String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER");
225const String16 sDump("android.permission.DUMP");
Ady Abrahama09852a2020-02-20 14:23:42 -0800226const char* KERNEL_IDLE_TIMER_PROP = "vendor.display.enable_kernel_idle_timer";
Mathias Agopian99b49842011-06-27 16:05:52 -0700227
228// ---------------------------------------------------------------------------
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700229int64_t SurfaceFlinger::dispSyncPresentTimeOffset;
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700230bool SurfaceFlinger::useHwcForRgbToYuv;
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800231uint64_t SurfaceFlinger::maxVirtualDisplaySize;
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800232bool SurfaceFlinger::hasSyncFramework;
Steven Thomas050b2c82017-03-06 11:45:16 -0800233bool SurfaceFlinger::useVrFlinger;
Fabien Sanglard1971b632017-03-10 14:50:03 -0800234int64_t SurfaceFlinger::maxFrameBufferAcquiredBuffers;
Brian Lindahla13f2d52020-03-05 11:54:17 +0100235uint32_t SurfaceFlinger::maxGraphicsWidth;
236uint32_t SurfaceFlinger::maxGraphicsHeight;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600237bool SurfaceFlinger::hasWideColorDisplay;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800238ui::Rotation SurfaceFlinger::internalDisplayOrientation = ui::ROTATION_0;
Peiyong Lin13effd12018-07-24 17:01:47 -0700239bool SurfaceFlinger::useColorManagement;
Peiyong Linb3839ad2018-09-05 15:37:19 -0700240bool SurfaceFlinger::useContextPriority;
Peiyong Linc6780972018-10-28 15:24:08 -0700241Dataspace SurfaceFlinger::defaultCompositionDataspace = Dataspace::V0_SRGB;
242ui::PixelFormat SurfaceFlinger::defaultCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
243Dataspace SurfaceFlinger::wideColorGamutCompositionDataspace = Dataspace::V0_SRGB;
244ui::PixelFormat SurfaceFlinger::wideColorGamutCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
Ana Krulec3803b8d2020-02-03 16:35:46 -0800245bool SurfaceFlinger::useFrameRateApi;
Mathias Agopian99b49842011-06-27 16:05:52 -0700246
Kalle Raitaa099a242017-01-11 11:17:29 -0800247std::string getHwcServiceName() {
248 char value[PROPERTY_VALUE_MAX] = {};
249 property_get("debug.sf.hwc_service_name", value, "default");
250 ALOGI("Using HWComposer service: '%s'", value);
251 return std::string(value);
252}
253
254bool useTrebleTestingOverride() {
255 char value[PROPERTY_VALUE_MAX] = {};
256 property_get("debug.sf.treble_testing_override", value, "false");
257 ALOGI("Treble testing override: '%s'", value);
258 return std::string(value) == "true";
259}
260
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800261std::string decodeDisplayColorSetting(DisplayColorSetting displayColorSetting) {
262 switch(displayColorSetting) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800263 case DisplayColorSetting::kManaged:
Chia-I Wu0d711262018-05-21 15:19:35 -0700264 return std::string("Managed");
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800265 case DisplayColorSetting::kUnmanaged:
Chia-I Wu0d711262018-05-21 15:19:35 -0700266 return std::string("Unmanaged");
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800267 case DisplayColorSetting::kEnhanced:
Chia-I Wu0d711262018-05-21 15:19:35 -0700268 return std::string("Enhanced");
269 default:
270 return std::string("Unknown ") +
271 std::to_string(static_cast<int>(displayColorSetting));
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800272 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800273}
274
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700275SurfaceFlingerBE::SurfaceFlingerBE() : mHwcServiceName(getHwcServiceName()) {}
David Sodmanbc815282017-11-05 18:57:52 -0800276
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700277SurfaceFlinger::SurfaceFlinger(Factory& factory, SkipInitializationTag)
278 : mFactory(factory),
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700279 mInterceptor(mFactory.createSurfaceInterceptor(this)),
Yiwei Zhangf0229a72019-09-09 19:28:02 -0700280 mTimeStats(std::make_shared<impl::TimeStats>()),
Mikael Pessa90092f42019-08-26 17:22:04 -0700281 mFrameTracer(std::make_unique<FrameTracer>()),
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700282 mEventQueue(mFactory.createMessageQueue()),
Dominik Laskowskieddeda12019-07-19 11:54:13 -0700283 mCompositionEngine(mFactory.createCompositionEngine()),
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800284 mInternalDisplayDensity(getDensityFromProperty("ro.sf.lcd_density", true)),
285 mEmulatedDisplayDensity(getDensityFromProperty("qemu.sf.lcd_density", false)) {}
Lloyd Piqueac648ee2018-01-17 13:42:24 -0800286
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700287SurfaceFlinger::SurfaceFlinger(Factory& factory) : SurfaceFlinger(factory, SkipInitialization) {
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800288 ALOGI("SurfaceFlinger is starting");
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800289
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900290 hasSyncFramework = running_without_sync_framework(true);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800291
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900292 dispSyncPresentTimeOffset = present_time_offset_from_vsync_ns(0);
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700293
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900294 useHwcForRgbToYuv = force_hwc_copy_for_virtual_displays(false);
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700295
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900296 maxVirtualDisplaySize = max_virtual_display_dimension(0);
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800297
Steven Thomas050b2c82017-03-06 11:45:16 -0800298 // Vr flinger is only enabled on Daydream ready devices.
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900299 useVrFlinger = use_vr_flinger(false);
Steven Thomas050b2c82017-03-06 11:45:16 -0800300
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900301 maxFrameBufferAcquiredBuffers = max_frame_buffer_acquired_buffers(2);
Fabien Sanglard1971b632017-03-10 14:50:03 -0800302
Brian Lindahla13f2d52020-03-05 11:54:17 +0100303 maxGraphicsWidth = std::max(max_graphics_width(0), 0);
304 maxGraphicsHeight = std::max(max_graphics_height(0), 0);
305
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900306 hasWideColorDisplay = has_wide_color_display(false);
Peiyong Lin0256f722018-08-31 15:45:10 -0700307
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900308 useColorManagement = use_color_management(false);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600309
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900310 mDefaultCompositionDataspace =
311 static_cast<ui::Dataspace>(default_composition_dataspace(Dataspace::V0_SRGB));
Peiyong Lin8cabfc32019-06-14 14:25:43 -0700312 mWideColorGamutCompositionDataspace = static_cast<ui::Dataspace>(wcg_composition_dataspace(
313 hasWideColorDisplay ? Dataspace::DISPLAY_P3 : Dataspace::V0_SRGB));
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900314 defaultCompositionDataspace = mDefaultCompositionDataspace;
315 wideColorGamutCompositionDataspace = mWideColorGamutCompositionDataspace;
316 defaultCompositionPixelFormat = static_cast<ui::PixelFormat>(
317 default_composition_pixel_format(ui::PixelFormat::RGBA_8888));
318 wideColorGamutCompositionPixelFormat =
319 static_cast<ui::PixelFormat>(wcg_composition_pixel_format(ui::PixelFormat::RGBA_8888));
Peiyong Linb3839ad2018-09-05 15:37:19 -0700320
Yichi Chenda901bf2019-06-28 14:58:27 +0800321 mColorSpaceAgnosticDataspace =
322 static_cast<ui::Dataspace>(color_space_agnostic_dataspace(Dataspace::UNKNOWN));
323
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900324 useContextPriority = use_context_priority(true);
Iris Chang7501ed62018-04-30 14:45:42 +0800325
Dominik Laskowski718f9602019-11-09 20:01:35 -0800326 using Values = SurfaceFlingerProperties::primary_display_orientation_values;
327 switch (primary_display_orientation(Values::ORIENTATION_0)) {
328 case Values::ORIENTATION_0:
Iris Chang7501ed62018-04-30 14:45:42 +0800329 break;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800330 case Values::ORIENTATION_90:
331 internalDisplayOrientation = ui::ROTATION_90;
Iris Chang7501ed62018-04-30 14:45:42 +0800332 break;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800333 case Values::ORIENTATION_180:
334 internalDisplayOrientation = ui::ROTATION_180;
Iris Chang7501ed62018-04-30 14:45:42 +0800335 break;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800336 case Values::ORIENTATION_270:
337 internalDisplayOrientation = ui::ROTATION_270;
Iris Chang7501ed62018-04-30 14:45:42 +0800338 break;
339 }
Dominik Laskowski718f9602019-11-09 20:01:35 -0800340 ALOGV("Internal Display Orientation: %s", toCString(internalDisplayOrientation));
Iris Chang7501ed62018-04-30 14:45:42 +0800341
Sundong Ahn85131bd2019-02-18 15:51:53 +0900342 mInternalDisplayPrimaries = sysprop::getDisplayNativePrimaries();
Daniel Solomon42d04562019-01-20 21:03:19 -0800343
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800344 // debugging stuff...
345 char value[PROPERTY_VALUE_MAX];
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700346
Mathias Agopianb4b17302013-03-20 18:36:41 -0700347 property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");
Mathias Agopian50210b92013-03-21 21:13:21 -0700348 mGpuToCpuSupported = !atoi(value);
Mathias Agopianb4b17302013-03-20 18:36:41 -0700349
Alec Mouri989ddbe2020-02-06 09:26:19 -0800350 property_get("ro.build.type", value, "user");
351 mIsUserBuild = strcmp(value, "user") == 0;
352
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800353 property_get("debug.sf.showupdates", value, "0");
354 mDebugRegion = atoi(value);
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700355
Mathias Agopianc1d359d2012-08-04 20:09:03 -0700356 ALOGI_IF(mDebugRegion, "showupdates enabled");
Orion Hodson34397da2019-02-04 09:36:10 +0000357
358 // DDMS debugging deprecated (b/120782499)
359 property_get("debug.sf.ddms", value, "0");
360 int debugDdms = atoi(value);
361 ALOGI_IF(debugDdms, "DDMS debugging not supported");
Dan Stozac5da2712016-07-20 15:38:12 -0700362
363 property_get("debug.sf.disable_backpressure", value, "0");
364 mPropagateBackpressure = !atoi(value);
365 ALOGI_IF(!mPropagateBackpressure, "Disabling backpressure propagation");
Dan Stoza8cf150a2016-08-02 10:27:31 -0700366
Ady Abrahamadb9a992019-09-19 21:21:55 +0000367 property_get("debug.sf.enable_gl_backpressure", value, "0");
368 mPropagateBackpressureClientComposition = atoi(value);
369 ALOGI_IF(mPropagateBackpressureClientComposition,
370 "Enabling backpressure propagation for Client Composition");
371
Fabien Sanglard642b23d2017-02-09 12:29:39 -0800372 property_get("debug.sf.enable_hwc_vds", value, "0");
373 mUseHwcVirtualDisplays = atoi(value);
Chia-I Wu11d10612018-06-21 15:41:13 +0800374 ALOGI_IF(mUseHwcVirtualDisplays, "Enabling HWC virtual displays");
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800375
Yiwei Zhangb770ed32018-12-17 17:44:28 -0800376 property_get("ro.sf.disable_triple_buffer", value, "0");
Fabien Sanglardc65dafa2017-02-07 14:06:39 -0800377 mLayerTripleBufferingDisabled = atoi(value);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800378 ALOGI_IF(mLayerTripleBufferingDisabled, "Disabling Triple Buffering");
Romain Guy3054f002017-06-05 18:38:53 -0700379
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800380 property_get("ro.surface_flinger.supports_background_blur", value, "0");
381 bool supportsBlurs = atoi(value);
Lucas Dupin00f16422020-03-11 11:33:04 -0700382 mSupportsBlur = supportsBlurs;
383 ALOGI_IF(!mSupportsBlur, "Disabling blur effects, they are not supported.");
Lucas Dupin2dd6f392020-02-18 17:43:36 -0800384 property_get("ro.sf.blurs_are_expensive", value, "0");
385 mBlursAreExpensive = atoi(value);
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800386
Ady Abraham0a525092020-03-03 12:51:24 -0800387 const size_t defaultListSize = ISurfaceComposer::MAX_LAYERS;
Dan Stoza0a0158c2018-03-16 13:38:54 -0700388 auto listSize = property_get_int32("debug.sf.max_igbp_list_size", int32_t(defaultListSize));
389 mMaxGraphicBufferProducerListSize = (listSize > 0) ? size_t(listSize) : defaultListSize;
390
Dan Stozaec460082018-12-17 15:35:09 -0800391 property_get("debug.sf.luma_sampling", value, "1");
392 mLumaSampling = atoi(value);
393
Vishnu Nairb2a999b2020-01-23 13:43:02 -0800394 property_get("debug.sf.disable_client_composition_cache", value, "0");
Vishnu Nair9b079a22020-01-21 14:36:08 -0800395 mDisableClientCompositionCache = atoi(value);
396
Romain Guy11d63f42017-07-20 12:47:14 -0700397 // We should be reading 'persist.sys.sf.color_saturation' here
398 // but since /data may be encrypted, we need to wait until after vold
399 // comes online to attempt to read the property. The property is
400 // instead read after the boot animation
Kalle Raitaa099a242017-01-11 11:17:29 -0800401
402 if (useTrebleTestingOverride()) {
403 // Without the override SurfaceFlinger cannot connect to HIDL
404 // services that are not listed in the manifests. Considered
405 // deriving the setting from the set service name, but it
406 // would be brittle if the name that's not 'default' is used
407 // for production purposes later on.
408 setenv("TREBLE_TESTING_OVERRIDE", "true", true);
409 }
Ana Krulec3803b8d2020-02-03 16:35:46 -0800410
411 useFrameRateApi = use_frame_rate_api(true);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800412}
413
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700414SurfaceFlinger::~SurfaceFlinger() = default;
415
416void SurfaceFlinger::onFirstRef() {
Lloyd Pique3fcdef12018-01-22 17:14:00 -0800417 mEventQueue->init(this);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800418}
419
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700420void SurfaceFlinger::binderDied(const wp<IBinder>&) {
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800421 // the window manager died on us. prepare its eulogy.
Rob Carr2aa78cb2020-03-10 14:27:49 -0700422 mBootFinished = false;
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800423
Andy McFadden13a082e2012-08-24 10:16:42 -0700424 // restore initial conditions (default device unblank, etc)
425 initializeDisplays();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800426
427 // restart the boot-animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700428 startBootAnim();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800429}
430
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700431void SurfaceFlinger::run() {
432 while (true) {
433 mEventQueue->waitMessage();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800434 }
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700435}
436
437template <typename F, typename T>
438inline std::future<T> SurfaceFlinger::schedule(F&& f) {
439 auto [task, future] = makeTask(std::move(f));
440 mEventQueue->postMessage(std::move(task));
441 return std::move(future);
Robert Carr1db73f62016-12-21 12:58:51 -0800442}
443
444sp<ISurfaceComposerClient> SurfaceFlinger::createConnection() {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700445 const sp<Client> client = new Client(this);
446 return client->initCheck() == NO_ERROR ? client : nullptr;
Robert Carr1db73f62016-12-21 12:58:51 -0800447}
448
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700449sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName, bool secure) {
Mathias Agopiane57f2922012-08-09 16:29:12 -0700450 class DisplayToken : public BBinder {
451 sp<SurfaceFlinger> flinger;
452 virtual ~DisplayToken() {
453 // no more references, this display must be terminated
454 Mutex::Autolock _l(flinger->mStateLock);
455 flinger->mCurrentState.displays.removeItem(this);
456 flinger->setTransactionFlags(eDisplayTransactionNeeded);
457 }
458 public:
Chih-Hung Hsiehc4067912016-05-03 14:03:27 -0700459 explicit DisplayToken(const sp<SurfaceFlinger>& flinger)
Mathias Agopiane57f2922012-08-09 16:29:12 -0700460 : flinger(flinger) {
461 }
462 };
463
464 sp<BBinder> token = new DisplayToken(this);
465
466 Mutex::Autolock _l(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700467 // Display ID is assigned when virtual display is allocated by HWC.
468 DisplayDeviceState state;
469 state.isSecure = secure;
470 state.displayName = displayName;
471 mCurrentState.displays.add(token, state);
472 mInterceptor->saveDisplayCreation(state);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700473 return token;
474}
475
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700476void SurfaceFlinger::destroyDisplay(const sp<IBinder>& displayToken) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700477 Mutex::Autolock lock(mStateLock);
Jesse Hall6c913be2013-08-08 12:15:49 -0700478
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700479 const ssize_t index = mCurrentState.displays.indexOfKey(displayToken);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700480 if (index < 0) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700481 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
Jesse Hall6c913be2013-08-08 12:15:49 -0700482 return;
483 }
484
Dominik Laskowski075d3172018-05-24 15:50:06 -0700485 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700486 if (state.physical) {
487 ALOGE("%s: Invalid operation on physical display", __FUNCTION__);
Jesse Hall6c913be2013-08-08 12:15:49 -0700488 return;
489 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700490 mInterceptor->saveDisplayDeletion(state.sequenceId);
491 mCurrentState.displays.removeItemsAt(index);
Jesse Hall6c913be2013-08-08 12:15:49 -0700492 setTransactionFlags(eDisplayTransactionNeeded);
493}
494
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800495std::vector<PhysicalDisplayId> SurfaceFlinger::getPhysicalDisplayIds() const {
496 Mutex::Autolock lock(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700497
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800498 const auto internalDisplayId = getInternalDisplayIdLocked();
499 if (!internalDisplayId) {
500 return {};
Dominik Laskowski075d3172018-05-24 15:50:06 -0700501 }
502
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800503 std::vector<PhysicalDisplayId> displayIds;
504 displayIds.reserve(mPhysicalDisplayTokens.size());
505 displayIds.push_back(internalDisplayId->value);
506
507 for (const auto& [id, token] : mPhysicalDisplayTokens) {
508 if (id != *internalDisplayId) {
509 displayIds.push_back(id.value);
510 }
Mathias Agopiane57f2922012-08-09 16:29:12 -0700511 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700512
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800513 return displayIds;
514}
515
516sp<IBinder> SurfaceFlinger::getPhysicalDisplayToken(PhysicalDisplayId displayId) const {
517 Mutex::Autolock lock(mStateLock);
518 return getPhysicalDisplayTokenLocked(DisplayId{displayId});
Mathias Agopiane57f2922012-08-09 16:29:12 -0700519}
520
Ady Abraham37965d42018-11-01 13:43:32 -0700521status_t SurfaceFlinger::getColorManagement(bool* outGetColorManagement) const {
522 if (!outGetColorManagement) {
523 return BAD_VALUE;
524 }
525 *outGetColorManagement = useColorManagement;
526 return NO_ERROR;
Ady Abraham2a6ab2a2018-10-26 14:25:30 -0700527}
528
Lloyd Pique441d5042018-10-18 16:49:51 -0700529HWComposer& SurfaceFlinger::getHwComposer() const {
530 return mCompositionEngine->getHwComposer();
531}
532
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700533renderengine::RenderEngine& SurfaceFlinger::getRenderEngine() const {
534 return mCompositionEngine->getRenderEngine();
535}
536
Lloyd Pique70d91362018-10-18 16:02:55 -0700537compositionengine::CompositionEngine& SurfaceFlinger::getCompositionEngine() const {
538 return *mCompositionEngine.get();
539}
540
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800541void SurfaceFlinger::bootFinished()
542{
Rob Carr2aa78cb2020-03-10 14:27:49 -0700543 if (mBootFinished == true) {
544 ALOGE("Extra call to bootFinished");
545 return;
546 }
547 mBootFinished = true;
Wei Wangf9b05ee2017-07-19 20:59:39 -0700548 if (mStartPropertySetThread->join() != NO_ERROR) {
549 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800550 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800551 const nsecs_t now = systemTime();
552 const nsecs_t duration = now - mBootTime;
Steve Blocka19954a2012-01-04 20:05:49 +0000553 ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700554
Mikael Pessa90092f42019-08-26 17:22:04 -0700555 mFrameTracer->initialize();
Alec Mouri8e2f31b2020-01-16 22:04:35 +0000556 mTimeStats->onBootFinished();
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700557
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700558 // wait patiently for the window manager death
559 const String16 name("window");
Steven Morelanda904bb92019-07-02 17:37:23 -0700560 mWindowManager = defaultServiceManager()->getService(name);
561 if (mWindowManager != 0) {
562 mWindowManager->linkToDeath(static_cast<IBinder::DeathRecipient*>(this));
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700563 }
Robert Carr720e5062018-07-30 17:45:14 -0700564 sp<IBinder> input(defaultServiceManager()->getService(
565 String16("inputflinger")));
566 if (input == nullptr) {
567 ALOGE("Failed to link to input service");
568 } else {
569 mInputFlinger = interface_cast<IInputFlinger>(input);
570 }
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700571
Steven Thomas050b2c82017-03-06 11:45:16 -0800572 if (mVrFlinger) {
573 mVrFlinger->OnBootFinished();
574 }
575
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700576 // stop boot animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700577 // formerly we would just kill the process, but we now ask it to exit so it
578 // can choose where to stop the animation.
579 property_set("service.bootanim.exit", "1");
Yusuke Sato0a688f52015-07-30 23:05:39 -0700580
581 const int LOGTAG_SF_STOP_BOOTANIM = 60110;
582 LOG_EVENT_LONG(LOGTAG_SF_STOP_BOOTANIM,
583 ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
Romain Guy11d63f42017-07-20 12:47:14 -0700584
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700585 static_cast<void>(schedule([this]() NO_THREAD_SAFETY_ANALYSIS {
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800586 readPersistentProperties();
Dan Stoza29e7bdf2020-03-23 14:43:09 -0700587 mPowerAdvisor.onBootFinished();
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800588 mBootStage = BootStage::FINISHED;
Ana Krulecbd6654b2019-02-15 15:18:15 -0800589
Ady Abraham8a82ba62020-01-17 12:43:17 -0800590 if (property_get_bool("sf.debug.show_refresh_rate_overlay", false)) {
591 mRefreshRateOverlay = std::make_unique<RefreshRateOverlay>(*this);
592 mRefreshRateOverlay->changeRefreshRate(mRefreshRateConfigs->getCurrentRefreshRate());
593 }
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800594 }));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800595}
596
Dan Stoza436ccf32018-06-21 12:10:12 -0700597uint32_t SurfaceFlinger::getNewTexture() {
598 {
599 std::lock_guard lock(mTexturePoolMutex);
600 if (!mTexturePool.empty()) {
601 uint32_t name = mTexturePool.back();
602 mTexturePool.pop_back();
603 ATRACE_INT("TexturePoolSize", mTexturePool.size());
604 return name;
605 }
606
607 // The pool was too small, so increase it for the future
608 ++mTexturePoolSize;
609 }
610
611 // The pool was empty, so we need to get a new texture name directly using a
612 // blocking call to the main thread
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700613 return schedule([this] {
614 uint32_t name = 0;
615 getRenderEngine().genTextures(1, &name);
616 return name;
617 })
618 .get();
Dan Stoza436ccf32018-06-21 12:10:12 -0700619}
620
Mathias Agopian3f844832013-08-07 21:24:32 -0700621void SurfaceFlinger::deleteTextureAsync(uint32_t texture) {
Dan Stoza67765d82019-05-07 14:58:27 -0700622 std::lock_guard lock(mTexturePoolMutex);
623 // We don't change the pool size, so the fix-up logic in postComposition will decide whether
624 // to actually delete this or not based on mTexturePoolSize
625 mTexturePool.push_back(texture);
626 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700627}
628
Wei Wangf9b05ee2017-07-19 20:59:39 -0700629// Do not call property_set on main thread which will be blocked by init
630// Use StartPropertySetThread instead.
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700631void SurfaceFlinger::init() {
Mathias Agopiana4912602012-07-12 14:25:33 -0700632 ALOGI( "SurfaceFlinger's main thread ready to run. "
633 "Initializing graphics H/W...");
Steven Thomasb02664d2017-07-26 18:48:28 -0700634 Mutex::Autolock _l(mStateLock);
Kevin DuBois413287f2019-02-25 08:46:47 -0800635
Steven Thomasb02664d2017-07-26 18:48:28 -0700636 // Get a RenderEngine for the given display / config (can't fail)
Peiyong Lin0256f722018-08-31 15:45:10 -0700637 // TODO(b/77156734): We need to stop casting and use HAL types when possible.
Alec Mourida4cf3b2019-02-12 15:33:01 -0800638 // Sending maxFrameBufferAcquiredBuffers as the cache size is tightly tuned to single-display.
Peiyong Lin4137a1d72019-10-09 10:39:09 -0700639 mCompositionEngine->setRenderEngine(renderengine::RenderEngine::create(
640 renderengine::RenderEngineCreationArgs::Builder()
641 .setPixelFormat(static_cast<int32_t>(defaultCompositionPixelFormat))
642 .setImageCacheSize(maxFrameBufferAcquiredBuffers)
643 .setUseColorManagerment(useColorManagement)
644 .setEnableProtectedContext(enable_protected_contents(false))
645 .setPrecacheToneMapperShaderOnly(false)
Lucas Dupin00f16422020-03-11 11:33:04 -0700646 .setSupportsBackgroundBlur(mSupportsBlur)
Peiyong Lin4137a1d72019-10-09 10:39:09 -0700647 .setContextPriority(useContextPriority
648 ? renderengine::RenderEngine::ContextPriority::HIGH
649 : renderengine::RenderEngine::ContextPriority::MEDIUM)
650 .build()));
Alec Mourie4034bb2019-11-19 12:45:54 -0800651 mCompositionEngine->setTimeStats(mTimeStats);
Steven Thomasb02664d2017-07-26 18:48:28 -0700652
653 LOG_ALWAYS_FATAL_IF(mVrFlingerRequestsDisplay,
654 "Starting with vr flinger active is not currently supported.");
Lloyd Pique441d5042018-10-18 16:49:51 -0700655 mCompositionEngine->setHwComposer(getFactory().createHWComposer(getBE().mHwcServiceName));
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800656 mCompositionEngine->getHwComposer().setConfiguration(this, getBE().mComposerSequenceId);
Lloyd Piqueba04e622017-12-14 17:11:26 -0800657 // Process any initial hotplug and resulting display changes.
658 processDisplayHotplugEventsLocked();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700659 const auto display = getDefaultDisplayDeviceLocked();
660 LOG_ALWAYS_FATAL_IF(!display, "Missing internal display after registering composer callback.");
Dominik Laskowski075d3172018-05-24 15:50:06 -0700661 LOG_ALWAYS_FATAL_IF(!getHwComposer().isConnected(*display->getId()),
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700662 "Internal display is disconnected.");
Jesse Hall692c7232012-11-08 15:41:56 -0800663
Steven Thomas050b2c82017-03-06 11:45:16 -0800664 if (useVrFlinger) {
Dominik Laskowski8c001672018-05-30 16:52:06 -0700665 auto vrFlingerRequestDisplayCallback = [this](bool requestDisplay) {
Steven Thomasbe6cbae2017-09-28 15:30:23 -0700666 // This callback is called from the vr flinger dispatch thread. We
667 // need to call signalTransaction(), which requires holding
668 // mStateLock when we're not on the main thread. Acquiring
669 // mStateLock from the vr flinger dispatch thread might trigger a
670 // deadlock in surface flinger (see b/66916578), so post a message
671 // to be handled on the main thread instead.
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700672 static_cast<void>(schedule([=] {
Steven Thomasbe6cbae2017-09-28 15:30:23 -0700673 ALOGI("VR request display mode: requestDisplay=%d", requestDisplay);
674 mVrFlingerRequestsDisplay = requestDisplay;
675 signalTransaction();
Dominik Laskowski8c001672018-05-30 16:52:06 -0700676 }));
Steven Thomas050b2c82017-03-06 11:45:16 -0800677 };
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700678 mVrFlinger = dvr::VrFlinger::Create(getHwComposer().getComposer(),
679 getHwComposer()
Dominik Laskowski075d3172018-05-24 15:50:06 -0700680 .fromPhysicalDisplayId(*display->getId())
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700681 .value_or(0),
682 vrFlingerRequestDisplayCallback);
Steven Thomas050b2c82017-03-06 11:45:16 -0800683 if (!mVrFlinger) {
684 ALOGE("Failed to start vrflinger");
685 }
686 }
687
Mathias Agopian92a979a2012-08-02 18:32:23 -0700688 // initialize our drawing state
689 mDrawingState = mCurrentState;
Mathias Agopian86303202012-07-24 22:46:10 -0700690
Andy McFadden13a082e2012-08-24 10:16:42 -0700691 // set initial conditions (e.g. unblank default device)
692 initializeDisplays();
693
Steven Thomas137d4bc2019-07-25 16:55:14 -0700694 char primeShaderCache[PROPERTY_VALUE_MAX];
695 property_get("service.sf.prime_shader_cache", primeShaderCache, "1");
696 if (atoi(primeShaderCache)) {
697 getRenderEngine().primeCache();
698 }
Dan Stoza4e637772016-07-28 13:31:51 -0700699
Wei Wangf9b05ee2017-07-19 20:59:39 -0700700 // Inform native graphics APIs whether the present timestamp is supported:
Lloyd Pique90c115d2018-09-18 21:39:42 -0700701
702 const bool presentFenceReliable =
Peiyong Line9d809e2020-04-14 13:10:48 -0700703 !getHwComposer().hasCapability(hal::Capability::PRESENT_FENCE_IS_NOT_RELIABLE);
Lloyd Pique90c115d2018-09-18 21:39:42 -0700704 mStartPropertySetThread = getFactory().createStartPropertySetThread(presentFenceReliable);
Wei Wangf9b05ee2017-07-19 20:59:39 -0700705
706 if (mStartPropertySetThread->Start() != NO_ERROR) {
707 ALOGE("Run StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800708 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800709
Dan Stoza9e56aa02015-11-02 13:00:03 -0800710 ALOGV("Done initializing");
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700711}
712
Romain Guy11d63f42017-07-20 12:47:14 -0700713void SurfaceFlinger::readPersistentProperties() {
Chia-I Wu28f320b2018-05-03 11:02:56 -0700714 Mutex::Autolock _l(mStateLock);
715
Romain Guy11d63f42017-07-20 12:47:14 -0700716 char value[PROPERTY_VALUE_MAX];
717
718 property_get("persist.sys.sf.color_saturation", value, "1.0");
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800719 mGlobalSaturationFactor = atof(value);
Chia-I Wu28f320b2018-05-03 11:02:56 -0700720 updateColorMatrixLocked();
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800721 ALOGV("Saturation is set to %.2f", mGlobalSaturationFactor);
Romain Guy54f154a2017-10-24 21:40:32 +0100722
723 property_get("persist.sys.sf.native_mode", value, "0");
Chia-I Wu0d711262018-05-21 15:19:35 -0700724 mDisplayColorSetting = static_cast<DisplayColorSetting>(atoi(value));
Peiyong Lina3ea5592019-02-10 14:45:00 -0800725
726 property_get("persist.sys.sf.color_mode", value, "0");
727 mForceColorMode = static_cast<ColorMode>(atoi(value));
Lucas Dupin00f16422020-03-11 11:33:04 -0700728
729 property_get("persist.sys.sf.disable_blurs", value, "0");
730 bool disableBlurs = atoi(value);
731 mDisableBlurs = disableBlurs;
732 ALOGI_IF(disableBlurs, "Disabling blur effects, user preference.");
Romain Guy11d63f42017-07-20 12:47:14 -0700733}
734
Mathias Agopiana67e4182012-06-19 17:26:12 -0700735void SurfaceFlinger::startBootAnim() {
Wei Wangb254fa32017-01-31 17:43:23 -0800736 // Start boot animation service by setting a property mailbox
737 // if property setting thread is already running, Start() will be just a NOP
Wei Wangf9b05ee2017-07-19 20:59:39 -0700738 mStartPropertySetThread->Start();
Wei Wangb254fa32017-01-31 17:43:23 -0800739 // Wait until property was set
Wei Wangf9b05ee2017-07-19 20:59:39 -0700740 if (mStartPropertySetThread->join() != NO_ERROR) {
741 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800742 }
Mathias Agopiana67e4182012-06-19 17:26:12 -0700743}
744
Mathias Agopian875d8e12013-06-07 15:35:48 -0700745size_t SurfaceFlinger::getMaxTextureSize() const {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700746 return getRenderEngine().getMaxTextureSize();
Mathias Agopiana4912602012-07-12 14:25:33 -0700747}
748
Mathias Agopian875d8e12013-06-07 15:35:48 -0700749size_t SurfaceFlinger::getMaxViewportDims() const {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700750 return getRenderEngine().getMaxViewportDims();
Mathias Agopiana4912602012-07-12 14:25:33 -0700751}
752
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800753// ----------------------------------------------------------------------------
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800754
Jamie Gennis582270d2011-08-17 18:19:00 -0700755bool SurfaceFlinger::authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800756 const sp<IGraphicBufferProducer>& bufferProducer) const {
Jamie Gennis134f0422011-03-08 12:18:54 -0800757 Mutex::Autolock _l(mStateLock);
Robert Carr0d480722017-01-10 16:42:54 -0800758 return authenticateSurfaceTextureLocked(bufferProducer);
759}
760
761bool SurfaceFlinger::authenticateSurfaceTextureLocked(
762 const sp<IGraphicBufferProducer>& bufferProducer) const {
Marco Nelissen097ca272014-11-14 08:01:01 -0800763 sp<IBinder> surfaceTextureBinder(IInterface::asBinder(bufferProducer));
Dan Stoza101d8dc2018-02-27 15:42:25 -0800764 return mGraphicBufferProducerList.count(surfaceTextureBinder.get()) > 0;
Jamie Gennis134f0422011-03-08 12:18:54 -0800765}
766
Brian Anderson6b376712017-04-04 10:51:39 -0700767status_t SurfaceFlinger::getSupportedFrameTimestamps(
768 std::vector<FrameEvent>* outSupported) const {
769 *outSupported = {
770 FrameEvent::REQUESTED_PRESENT,
771 FrameEvent::ACQUIRE,
772 FrameEvent::LATCH,
773 FrameEvent::FIRST_REFRESH_START,
774 FrameEvent::LAST_REFRESH_START,
775 FrameEvent::GPU_COMPOSITION_DONE,
776 FrameEvent::DEQUEUE_READY,
777 FrameEvent::RELEASE,
778 };
Steven Thomas6d8110b2017-08-31 18:24:21 -0700779 ConditionalLock _l(mStateLock,
780 std::this_thread::get_id() != mMainThreadId);
Peiyong Line9d809e2020-04-14 13:10:48 -0700781 if (!getHwComposer().hasCapability(hal::Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
Brian Anderson6b376712017-04-04 10:51:39 -0700782 outSupported->push_back(FrameEvent::DISPLAY_PRESENT);
783 }
784 return NO_ERROR;
785}
786
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800787status_t SurfaceFlinger::getDisplayState(const sp<IBinder>& displayToken, ui::DisplayState* state) {
788 if (!displayToken || !state) {
789 return BAD_VALUE;
790 }
791
792 Mutex::Autolock lock(mStateLock);
793
794 const auto display = getDisplayDeviceLocked(displayToken);
795 if (!display) {
796 return NAME_NOT_FOUND;
797 }
798
799 state->layerStack = display->getLayerStack();
800 state->orientation = display->getOrientation();
801
802 const Rect viewport = display->getViewport();
803 state->viewport = viewport.isValid() ? viewport.getSize() : display->getSize();
804
805 return NO_ERROR;
806}
807
808status_t SurfaceFlinger::getDisplayInfo(const sp<IBinder>& displayToken, DisplayInfo* info) {
809 if (!displayToken || !info) {
810 return BAD_VALUE;
811 }
812
813 Mutex::Autolock lock(mStateLock);
814
815 const auto display = getDisplayDeviceLocked(displayToken);
816 if (!display) {
817 return NAME_NOT_FOUND;
818 }
819
Dominik Laskowski55c85402020-01-21 16:25:47 -0800820 if (const auto connectionType = display->getConnectionType())
821 info->connectionType = *connectionType;
822 else {
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800823 return INVALID_OPERATION;
824 }
825
826 if (mEmulatedDisplayDensity) {
827 info->density = mEmulatedDisplayDensity;
828 } else {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800829 info->density = info->connectionType == DisplayConnectionType::Internal
830 ? mInternalDisplayDensity
831 : FALLBACK_DENSITY;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800832 }
833
834 info->secure = display->isSecure();
Marin Shalamanovf5de90d2019-10-08 10:57:25 +0200835 info->deviceProductInfo = getDeviceProductInfoLocked(*display);
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800836
837 return NO_ERROR;
838}
839
Dominik Laskowski22488f62019-03-28 09:53:04 -0700840status_t SurfaceFlinger::getDisplayConfigs(const sp<IBinder>& displayToken,
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800841 Vector<DisplayConfig>* configs) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700842 if (!displayToken || !configs) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700843 return BAD_VALUE;
844 }
845
Dominik Laskowski22488f62019-03-28 09:53:04 -0700846 Mutex::Autolock lock(mStateLock);
847
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800848 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700849 if (!displayId) {
850 return NAME_NOT_FOUND;
Mathias Agopianc666cae2012-07-25 18:56:13 -0700851 }
Mathias Agopian8b736f12012-08-13 17:54:26 -0700852
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800853 const bool isInternal = (displayId == getInternalDisplayIdLocked());
Mathias Agopian1604f772012-09-18 21:54:42 -0700854
Dan Stoza7f7da322014-05-02 15:26:25 -0700855 configs->clear();
Mathias Agopian1604f772012-09-18 21:54:42 -0700856
Dominik Laskowski075d3172018-05-24 15:50:06 -0700857 for (const auto& hwConfig : getHwComposer().getConfigs(*displayId)) {
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800858 DisplayConfig config;
Dan Stoza7f7da322014-05-02 15:26:25 -0700859
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800860 auto width = hwConfig->getWidth();
861 auto height = hwConfig->getHeight();
Dan Stoza7f7da322014-05-02 15:26:25 -0700862
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800863 auto xDpi = hwConfig->getDpiX();
864 auto yDpi = hwConfig->getDpiY();
Yiwei Zhang27de5df2018-08-23 17:04:51 -0700865
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800866 if (isInternal &&
867 (internalDisplayOrientation == ui::ROTATION_90 ||
868 internalDisplayOrientation == ui::ROTATION_270)) {
869 std::swap(width, height);
870 std::swap(xDpi, yDpi);
Dan Stoza7f7da322014-05-02 15:26:25 -0700871 }
872
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800873 config.resolution = ui::Size(width, height);
Ady Abraham2139f732019-11-13 18:56:40 -0800874
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800875 if (mEmulatedDisplayDensity) {
876 config.xDpi = mEmulatedDisplayDensity;
877 config.yDpi = mEmulatedDisplayDensity;
878 } else {
879 config.xDpi = xDpi;
880 config.yDpi = yDpi;
881 }
882
883 const nsecs_t period = hwConfig->getVsyncPeriod();
884 config.refreshRate = 1e9f / period;
885
886 const auto offsets = mPhaseConfiguration->getOffsetsForRefreshRate(config.refreshRate);
887 config.appVsyncOffset = offsets.late.app;
888 config.sfVsyncOffset = offsets.late.sf;
Ady Abrahamff731d82020-02-18 17:22:46 -0800889 config.configGroup = hwConfig->getConfigGroup();
Dan Stoza9e56aa02015-11-02 13:00:03 -0800890
Andy McFadden91b2ca82014-06-13 14:04:23 -0700891 // This is how far in advance a buffer must be queued for
892 // presentation at a given time. If you want a buffer to appear
893 // on the screen at time N, you must submit the buffer before
894 // (N - presentationDeadline).
895 //
896 // Normally it's one full refresh period (to give SF a chance to
897 // latch the buffer), but this can be reduced by configuring a
898 // DispSync offset. Any additional delays introduced by the hardware
899 // composer or panel must be accounted for here.
900 //
901 // We add an additional 1ms to allow for processing time and
902 // differences between the ideal and actual refresh rate.
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800903 config.presentationDeadline = period - config.sfVsyncOffset + 1000000;
Dan Stoza7f7da322014-05-02 15:26:25 -0700904
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800905 configs->push_back(config);
Mathias Agopian8b736f12012-08-13 17:54:26 -0700906 }
907
Dan Stoza7f7da322014-05-02 15:26:25 -0700908 return NO_ERROR;
909}
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700910
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700911status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>&, DisplayStatInfo* stats) {
912 if (!stats) {
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700913 return BAD_VALUE;
914 }
915
Ana Krulecc2870422019-01-29 19:00:58 -0800916 mScheduler->getDisplayStatInfo(stats);
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700917 return NO_ERROR;
918}
919
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700920int SurfaceFlinger::getActiveConfig(const sp<IBinder>& displayToken) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700921 int activeConfig;
922 bool isPrimary;
923
924 {
925 Mutex::Autolock lock(mStateLock);
926
927 if (const auto display = getDisplayDeviceLocked(displayToken)) {
928 activeConfig = display->getActiveConfig().value();
929 isPrimary = display->isPrimary();
930 } else {
931 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
932 return NAME_NOT_FOUND;
933 }
Jinguang Dong9f8b9ae2016-11-29 13:55:57 +0800934 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700935
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700936 if (isPrimary) {
Steven Thomasc9098452019-09-30 17:15:05 -0700937 std::lock_guard<std::mutex> lock(mActiveConfigLock);
938 if (mDesiredActiveConfigChanged) {
Ady Abraham2139f732019-11-13 18:56:40 -0800939 return mDesiredActiveConfig.configId.value();
Steven Thomasc9098452019-09-30 17:15:05 -0700940 }
Steven Thomasc9098452019-09-30 17:15:05 -0700941 }
Ady Abraham2139f732019-11-13 18:56:40 -0800942
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700943 return activeConfig;
Dan Stoza7f7da322014-05-02 15:26:25 -0700944}
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700945
Ady Abraham03b02dd2019-03-21 15:40:11 -0700946void SurfaceFlinger::setDesiredActiveConfig(const ActiveConfigInfo& info) {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800947 ATRACE_CALL();
Ady Abraham2e1dd892020-03-05 13:48:36 -0800948 auto& refreshRate = mRefreshRateConfigs->getRefreshRateFromConfigId(info.configId);
Ady Abrahamabc27602020-04-08 17:20:29 -0700949 ALOGV("setDesiredActiveConfig(%s)", refreshRate.getName().c_str());
Ana Krulec7d1d6832018-12-27 11:10:09 -0800950
Ady Abrahamb838aed2019-02-12 15:30:16 -0800951 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Ady Abraham59db0a32020-03-02 18:04:20 -0800952 if (mDesiredActiveConfigChanged) {
953 // If a config change is pending, just cache the latest request in
954 // mDesiredActiveConfig
955 const Scheduler::ConfigEvent prevConfig = mDesiredActiveConfig.event;
956 mDesiredActiveConfig = info;
957 mDesiredActiveConfig.event = mDesiredActiveConfig.event | prevConfig;
958 } else {
959 // Check is we are already at the desired config
960 const auto display = getDefaultDisplayDeviceLocked();
Ady Abrahamabc27602020-04-08 17:20:29 -0700961 if (!display || display->getActiveConfig() == refreshRate.getConfigId()) {
Ady Abraham59db0a32020-03-02 18:04:20 -0800962 return;
963 }
Ady Abrahamb838aed2019-02-12 15:30:16 -0800964
Ady Abraham59db0a32020-03-02 18:04:20 -0800965 // Initiate a config change.
966 mDesiredActiveConfigChanged = true;
967 mDesiredActiveConfig = info;
968
Ady Abrahamb838aed2019-02-12 15:30:16 -0800969 // This will trigger HWC refresh without resetting the idle timer.
970 repaintEverythingForHWC();
Alec Mouri754c98a2019-03-18 18:53:42 -0700971 // Start receiving vsync samples now, so that we can detect a period
972 // switch.
Ady Abrahamabc27602020-04-08 17:20:29 -0700973 mScheduler->resyncToHardwareVsync(true, refreshRate.getVsyncPeriod());
Ady Abraham53852a52019-05-28 18:07:44 -0700974 // As we called to set period, we will call to onRefreshRateChangeCompleted once
975 // DispSync model is locked.
Dominik Laskowskieddeda12019-07-19 11:54:13 -0700976 mVSyncModulator->onRefreshRateChangeInitiated();
Ady Abraham2139f732019-11-13 18:56:40 -0800977
Ady Abrahamabc27602020-04-08 17:20:29 -0700978 mPhaseConfiguration->setRefreshRateFps(refreshRate.getFps());
Ady Abraham9e16a482019-12-03 17:19:41 -0800979 mVSyncModulator->setPhaseOffsets(mPhaseConfiguration->getCurrentOffsets());
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800980 }
Ady Abraham03b02dd2019-03-21 15:40:11 -0700981
982 if (mRefreshRateOverlay) {
Ady Abraham2139f732019-11-13 18:56:40 -0800983 mRefreshRateOverlay->changeRefreshRate(refreshRate);
Ady Abraham03b02dd2019-03-21 15:40:11 -0700984 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800985}
986
987status_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& displayToken, int mode) {
988 ATRACE_CALL();
Ady Abraham838de062019-02-04 10:24:03 -0800989
Ana Kruleced3a8cc2019-11-14 00:55:07 +0100990 if (!displayToken) {
991 return BAD_VALUE;
992 }
Ady Abraham838de062019-02-04 10:24:03 -0800993
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700994 auto future = schedule([=]() -> status_t {
Ana Kruleced3a8cc2019-11-14 00:55:07 +0100995 const auto display = getDisplayDeviceLocked(displayToken);
996 if (!display) {
997 ALOGE("Attempt to set allowed display configs for invalid display token %p",
998 displayToken.get());
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700999 return NAME_NOT_FOUND;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001000 } else if (display->isVirtual()) {
1001 ALOGW("Attempt to set allowed display configs for virtual display");
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001002 return INVALID_OPERATION;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001003 } else {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001004 const HwcConfigIndexType config(mode);
1005 const float fps = mRefreshRateConfigs->getRefreshRateFromConfigId(config).getFps();
Steven Thomasf734df42020-04-13 21:09:28 -07001006 const scheduler::RefreshRateConfigs::Policy policy{config, {fps, fps}};
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001007 constexpr bool kOverridePolicy = false;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001008
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001009 return setDesiredDisplayConfigSpecsInternal(display, policy, kOverridePolicy);
1010 }
1011 });
1012
1013 return future.get();
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001014}
1015
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001016void SurfaceFlinger::setActiveConfigInternal() {
1017 ATRACE_CALL();
1018
Dominik Laskowski22488f62019-03-28 09:53:04 -07001019 const auto display = getDefaultDisplayDeviceLocked();
1020 if (!display) {
1021 return;
1022 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001023
Alec Mouri8de697e2020-03-19 10:52:01 -07001024 auto& oldRefreshRate =
1025 mRefreshRateConfigs->getRefreshRateFromConfigId(display->getActiveConfig());
1026
Dominik Laskowski22488f62019-03-28 09:53:04 -07001027 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Ady Abraham2139f732019-11-13 18:56:40 -08001028 mRefreshRateConfigs->setCurrentConfigId(mUpcomingActiveConfig.configId);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07001029 mRefreshRateStats->setConfigMode(mUpcomingActiveConfig.configId);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001030 display->setActiveConfig(mUpcomingActiveConfig.configId);
1031
Ady Abraham2e1dd892020-03-05 13:48:36 -08001032 auto& refreshRate =
Ady Abraham2139f732019-11-13 18:56:40 -08001033 mRefreshRateConfigs->getRefreshRateFromConfigId(mUpcomingActiveConfig.configId);
Ady Abrahamabc27602020-04-08 17:20:29 -07001034 if (refreshRate.getVsyncPeriod() != oldRefreshRate.getVsyncPeriod()) {
Alec Mouri8de697e2020-03-19 10:52:01 -07001035 mTimeStats->incrementRefreshRateSwitches();
1036 }
Ady Abrahamabc27602020-04-08 17:20:29 -07001037 mPhaseConfiguration->setRefreshRateFps(refreshRate.getFps());
Ady Abraham9e16a482019-12-03 17:19:41 -08001038 mVSyncModulator->setPhaseOffsets(mPhaseConfiguration->getCurrentOffsets());
Ady Abrahamabc27602020-04-08 17:20:29 -07001039 ATRACE_INT("ActiveConfigFPS", refreshRate.getFps());
Dominik Laskowski22488f62019-03-28 09:53:04 -07001040
Ana Krulec8d3e4f32019-03-05 10:40:33 -08001041 if (mUpcomingActiveConfig.event != Scheduler::ConfigEvent::None) {
Alec Mouri60aee1c2019-10-28 16:18:59 -07001042 const nsecs_t vsyncPeriod =
1043 mRefreshRateConfigs->getRefreshRateFromConfigId(mUpcomingActiveConfig.configId)
Ady Abrahamabc27602020-04-08 17:20:29 -07001044 .getVsyncPeriod();
Ady Abraham447052e2019-02-13 16:07:27 -08001045 mScheduler->onConfigChanged(mAppConnectionHandle, display->getId()->value,
Alec Mouri60aee1c2019-10-28 16:18:59 -07001046 mUpcomingActiveConfig.configId, vsyncPeriod);
Ady Abraham447052e2019-02-13 16:07:27 -08001047 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001048}
1049
Ady Abraham53852a52019-05-28 18:07:44 -07001050void SurfaceFlinger::desiredActiveConfigChangeDone() {
1051 std::lock_guard<std::mutex> lock(mActiveConfigLock);
1052 mDesiredActiveConfig.event = Scheduler::ConfigEvent::None;
1053 mDesiredActiveConfigChanged = false;
Ady Abraham53852a52019-05-28 18:07:44 -07001054
Ady Abraham2e1dd892020-03-05 13:48:36 -08001055 const auto& refreshRate =
Ady Abraham2139f732019-11-13 18:56:40 -08001056 mRefreshRateConfigs->getRefreshRateFromConfigId(mDesiredActiveConfig.configId);
Ady Abrahamabc27602020-04-08 17:20:29 -07001057 mScheduler->resyncToHardwareVsync(true, refreshRate.getVsyncPeriod());
1058 mPhaseConfiguration->setRefreshRateFps(refreshRate.getFps());
Ady Abraham9e16a482019-12-03 17:19:41 -08001059 mVSyncModulator->setPhaseOffsets(mPhaseConfiguration->getCurrentOffsets());
Ady Abraham53852a52019-05-28 18:07:44 -07001060}
1061
Ady Abraham27cbed72020-04-10 12:56:59 -07001062void SurfaceFlinger::performSetActiveConfig() {
Alec Mourife3dc942019-02-12 14:19:18 -08001063 ATRACE_CALL();
Ady Abraham2139f732019-11-13 18:56:40 -08001064 ALOGV("performSetActiveConfig");
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001065 // Store the local variable to release the lock.
Ady Abraham27cbed72020-04-10 12:56:59 -07001066 const auto desiredActiveConfig = [&]() -> std::optional<ActiveConfigInfo> {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001067 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Ady Abraham27cbed72020-04-10 12:56:59 -07001068 if (mDesiredActiveConfigChanged) {
1069 return mDesiredActiveConfig;
Ady Abrahamb838aed2019-02-12 15:30:16 -08001070 }
Ady Abraham27cbed72020-04-10 12:56:59 -07001071 return std::nullopt;
1072 }();
1073
1074 if (!desiredActiveConfig) {
1075 // No desired active config pending to be applied
1076 return;
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001077 }
1078
Ady Abraham2e1dd892020-03-05 13:48:36 -08001079 auto& refreshRate =
Ady Abraham27cbed72020-04-10 12:56:59 -07001080 mRefreshRateConfigs->getRefreshRateFromConfigId(desiredActiveConfig->configId);
Ady Abrahamabc27602020-04-08 17:20:29 -07001081 ALOGV("performSetActiveConfig changing active config to %d(%s)",
1082 refreshRate.getConfigId().value(), refreshRate.getName().c_str());
Dominik Laskowski22488f62019-03-28 09:53:04 -07001083 const auto display = getDefaultDisplayDeviceLocked();
Ady Abraham27cbed72020-04-10 12:56:59 -07001084 if (!display || display->getActiveConfig() == desiredActiveConfig->configId) {
Ady Abrahamb838aed2019-02-12 15:30:16 -08001085 // display is not valid or we are already in the requested mode
1086 // on both cases there is nothing left to do
Ady Abraham53852a52019-05-28 18:07:44 -07001087 desiredActiveConfigChangeDone();
Ady Abraham27cbed72020-04-10 12:56:59 -07001088 return;
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001089 }
Ady Abrahamb838aed2019-02-12 15:30:16 -08001090
Ady Abraham838de062019-02-04 10:24:03 -08001091 // Desired active config was set, it is different than the config currently in use, however
1092 // allowed configs might have change by the time we process the refresh.
1093 // Make sure the desired config is still allowed
Ady Abraham27cbed72020-04-10 12:56:59 -07001094 if (!isDisplayConfigAllowed(desiredActiveConfig->configId)) {
Ady Abraham53852a52019-05-28 18:07:44 -07001095 desiredActiveConfigChangeDone();
Ady Abraham27cbed72020-04-10 12:56:59 -07001096 return;
Ady Abraham838de062019-02-04 10:24:03 -08001097 }
Alec Mouri7f015182019-07-11 13:56:22 -07001098
Ady Abraham27cbed72020-04-10 12:56:59 -07001099 mUpcomingActiveConfig = *desiredActiveConfig;
Ady Abrahamb838aed2019-02-12 15:30:16 -08001100 const auto displayId = display->getId();
1101 LOG_ALWAYS_FATAL_IF(!displayId);
1102
Ady Abrahamabc27602020-04-08 17:20:29 -07001103 ATRACE_INT("ActiveConfigFPS_HWC", refreshRate.getFps());
Ady Abrahamb838aed2019-02-12 15:30:16 -08001104
Ady Abraham3a77a7b2019-12-02 18:46:59 -08001105 // TODO(b/142753666) use constrains
Peiyong Line9d809e2020-04-14 13:10:48 -07001106 hal::VsyncPeriodChangeConstraints constraints;
Ady Abraham3a77a7b2019-12-02 18:46:59 -08001107 constraints.desiredTimeNanos = systemTime();
1108 constraints.seamlessRequired = false;
1109
Peiyong Line9d809e2020-04-14 13:10:48 -07001110 hal::VsyncPeriodChangeTimeline outTimeline;
Ady Abraham3a77a7b2019-12-02 18:46:59 -08001111 auto status =
1112 getHwComposer().setActiveConfigWithConstraints(*displayId,
1113 mUpcomingActiveConfig.configId.value(),
1114 constraints, &outTimeline);
1115 if (status != NO_ERROR) {
Ady Abraham5e95aa22020-03-04 10:26:05 -08001116 // setActiveConfigWithConstraints may fail if a hotplug event is just about
1117 // to be sent. We just log the error in this case.
1118 ALOGW("setActiveConfigWithConstraints failed: %d", status);
Ady Abraham27cbed72020-04-10 12:56:59 -07001119 return;
Ady Abraham3a77a7b2019-12-02 18:46:59 -08001120 }
1121
1122 mScheduler->onNewVsyncPeriodChangeTimeline(outTimeline);
1123 // Scheduler will submit an empty frame to HWC if needed.
Ady Abraham27cbed72020-04-10 12:56:59 -07001124 mSetActiveConfigPending = true;
Mathias Agopianc666cae2012-07-25 18:56:13 -07001125}
Dominik Laskowski075d3172018-05-24 15:50:06 -07001126
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001127status_t SurfaceFlinger::getDisplayColorModes(const sp<IBinder>& displayToken,
1128 Vector<ColorMode>* outColorModes) {
1129 if (!displayToken || !outColorModes) {
Michael Wright28f24d02016-07-12 13:30:53 -07001130 return BAD_VALUE;
1131 }
1132
Peiyong Lina52f0292018-03-14 17:26:31 -07001133 std::vector<ColorMode> modes;
Peiyong Linff84a152019-05-17 18:36:19 -07001134 bool isInternalDisplay = false;
Steven Thomas6d8110b2017-08-31 18:24:21 -07001135 {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001136 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
1137
1138 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1139 if (!displayId) {
1140 return NAME_NOT_FOUND;
1141 }
1142
Dominik Laskowski075d3172018-05-24 15:50:06 -07001143 modes = getHwComposer().getColorModes(*displayId);
Peiyong Linff84a152019-05-17 18:36:19 -07001144 isInternalDisplay = displayId == getInternalDisplayIdLocked();
Steven Thomas6d8110b2017-08-31 18:24:21 -07001145 }
Michael Wright28f24d02016-07-12 13:30:53 -07001146 outColorModes->clear();
Peiyong Linff84a152019-05-17 18:36:19 -07001147
1148 // If it's built-in display and the configuration claims it's not wide color capable,
1149 // filter out all wide color modes. The typical reason why this happens is that the
1150 // hardware is not good enough to support GPU composition of wide color, and thus the
1151 // OEMs choose to disable this capability.
1152 if (isInternalDisplay && !hasWideColorDisplay) {
1153 std::remove_copy_if(modes.cbegin(), modes.cend(), std::back_inserter(*outColorModes),
1154 isWideColorMode);
1155 } else {
1156 std::copy(modes.cbegin(), modes.cend(), std::back_inserter(*outColorModes));
1157 }
Michael Wright28f24d02016-07-12 13:30:53 -07001158
1159 return NO_ERROR;
1160}
1161
Daniel Solomon42d04562019-01-20 21:03:19 -08001162status_t SurfaceFlinger::getDisplayNativePrimaries(const sp<IBinder>& displayToken,
1163 ui::DisplayPrimaries &primaries) {
1164 if (!displayToken) {
1165 return BAD_VALUE;
1166 }
1167
1168 // Currently we only support this API for a single internal display.
1169 if (getInternalDisplayToken() != displayToken) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001170 return NAME_NOT_FOUND;
Daniel Solomon42d04562019-01-20 21:03:19 -08001171 }
1172
1173 memcpy(&primaries, &mInternalDisplayPrimaries, sizeof(ui::DisplayPrimaries));
1174 return NO_ERROR;
1175}
1176
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001177ColorMode SurfaceFlinger::getActiveColorMode(const sp<IBinder>& displayToken) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001178 Mutex::Autolock lock(mStateLock);
1179
1180 if (const auto display = getDisplayDeviceLocked(displayToken)) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07001181 return display->getCompositionDisplay()->getState().colorMode;
Michael Wright28f24d02016-07-12 13:30:53 -07001182 }
Peiyong Lina52f0292018-03-14 17:26:31 -07001183 return static_cast<ColorMode>(BAD_VALUE);
Michael Wright28f24d02016-07-12 13:30:53 -07001184}
1185
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001186status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& displayToken, ColorMode mode) {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001187 schedule([=] {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001188 Vector<ColorMode> modes;
1189 getDisplayColorModes(displayToken, &modes);
1190 bool exists = std::find(std::begin(modes), std::end(modes), mode) != std::end(modes);
1191 if (mode < ColorMode::NATIVE || !exists) {
1192 ALOGE("Attempt to set invalid active color mode %s (%d) for display token %p",
1193 decodeColorMode(mode).c_str(), mode, displayToken.get());
1194 return;
Michael Wright28f24d02016-07-12 13:30:53 -07001195 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001196 const auto display = getDisplayDeviceLocked(displayToken);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001197 if (!display) {
1198 ALOGE("Attempt to set active color mode %s (%d) for invalid display token %p",
1199 decodeColorMode(mode).c_str(), mode, displayToken.get());
1200 } else if (display->isVirtual()) {
1201 ALOGW("Attempt to set active color mode %s (%d) for virtual display",
1202 decodeColorMode(mode).c_str(), mode);
1203 } else {
Lloyd Pique6a3b4462019-03-07 20:58:12 -08001204 display->getCompositionDisplay()->setColorProfile(
1205 compositionengine::Output::ColorProfile{mode, Dataspace::UNKNOWN,
1206 RenderIntent::COLORIMETRIC,
1207 Dataspace::UNKNOWN});
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001208 }
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001209 }).wait();
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001210
Michael Wright28f24d02016-07-12 13:30:53 -07001211 return NO_ERROR;
1212}
Mathias Agopianc666cae2012-07-25 18:56:13 -07001213
Galia Peycheva5492cb52019-10-30 14:13:16 +01001214status_t SurfaceFlinger::getAutoLowLatencyModeSupport(const sp<IBinder>& displayToken,
1215 bool* outSupport) const {
Galia Peycheva5492cb52019-10-30 14:13:16 +01001216 if (!displayToken) {
Galia Peycheva5492cb52019-10-30 14:13:16 +01001217 return BAD_VALUE;
1218 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001219
1220 Mutex::Autolock lock(mStateLock);
1221
Galia Peycheva5492cb52019-10-30 14:13:16 +01001222 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1223 if (!displayId) {
Galia Peycheva5492cb52019-10-30 14:13:16 +01001224 return NAME_NOT_FOUND;
1225 }
Peiyong Line9d809e2020-04-14 13:10:48 -07001226 *outSupport =
1227 getHwComposer().hasDisplayCapability(*displayId,
1228 hal::DisplayCapability::AUTO_LOW_LATENCY_MODE);
Galia Peycheva5492cb52019-10-30 14:13:16 +01001229 return NO_ERROR;
1230}
1231
1232void SurfaceFlinger::setAutoLowLatencyMode(const sp<IBinder>& displayToken, bool on) {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001233 static_cast<void>(schedule([=] {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001234 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
1235 getHwComposer().setAutoLowLatencyMode(*displayId, on);
1236 } else {
1237 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
1238 }
1239 }));
Galia Peycheva5492cb52019-10-30 14:13:16 +01001240}
1241
1242status_t SurfaceFlinger::getGameContentTypeSupport(const sp<IBinder>& displayToken,
1243 bool* outSupport) const {
Galia Peycheva5492cb52019-10-30 14:13:16 +01001244 if (!displayToken) {
Galia Peycheva5492cb52019-10-30 14:13:16 +01001245 return BAD_VALUE;
1246 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001247
1248 Mutex::Autolock lock(mStateLock);
1249
Galia Peycheva5492cb52019-10-30 14:13:16 +01001250 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1251 if (!displayId) {
Galia Peycheva5492cb52019-10-30 14:13:16 +01001252 return NAME_NOT_FOUND;
1253 }
1254
Peiyong Line9d809e2020-04-14 13:10:48 -07001255 std::vector<hal::ContentType> types;
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001256 getHwComposer().getSupportedContentTypes(*displayId, &types);
1257
1258 *outSupport = std::any_of(types.begin(), types.end(),
Peiyong Line9d809e2020-04-14 13:10:48 -07001259 [](auto type) { return type == hal::ContentType::GAME; });
Galia Peycheva5492cb52019-10-30 14:13:16 +01001260 return NO_ERROR;
1261}
1262
1263void SurfaceFlinger::setGameContentType(const sp<IBinder>& displayToken, bool on) {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001264 static_cast<void>(schedule([=] {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001265 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
Peiyong Line9d809e2020-04-14 13:10:48 -07001266 const auto type = on ? hal::ContentType::GAME : hal::ContentType::NONE;
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001267 getHwComposer().setContentType(*displayId, type);
1268 } else {
1269 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
1270 }
1271 }));
Galia Peycheva5492cb52019-10-30 14:13:16 +01001272}
1273
Svetoslavd85084b2014-03-20 10:28:31 -07001274status_t SurfaceFlinger::clearAnimationFrameStats() {
1275 Mutex::Autolock _l(mStateLock);
1276 mAnimFrameTracker.clearStats();
1277 return NO_ERROR;
1278}
1279
1280status_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const {
1281 Mutex::Autolock _l(mStateLock);
1282 mAnimFrameTracker.getStats(outStats);
1283 return NO_ERROR;
1284}
1285
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001286status_t SurfaceFlinger::getHdrCapabilities(const sp<IBinder>& displayToken,
1287 HdrCapabilities* outCapabilities) const {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001288 Mutex::Autolock lock(mStateLock);
Dan Stozac4f471e2016-03-24 09:31:08 -07001289
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001290 const auto display = getDisplayDeviceLocked(displayToken);
1291 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001292 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
1293 return NAME_NOT_FOUND;
Dan Stozac4f471e2016-03-24 09:31:08 -07001294 }
1295
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001296 // At this point the DisplayDevice should already be set up,
Peiyong Linfb069302018-04-25 14:34:31 -07001297 // meaning the luminance information is already queried from
1298 // hardware composer and stored properly.
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001299 const HdrCapabilities& capabilities = display->getHdrCapabilities();
Peiyong Linfb069302018-04-25 14:34:31 -07001300 *outCapabilities = HdrCapabilities(capabilities.getSupportedHdrTypes(),
1301 capabilities.getDesiredMaxLuminance(),
1302 capabilities.getDesiredMaxAverageLuminance(),
1303 capabilities.getDesiredMinLuminance());
Dan Stozac4f471e2016-03-24 09:31:08 -07001304
1305 return NO_ERROR;
1306}
1307
Marin Shalamanovf5de90d2019-10-08 10:57:25 +02001308std::optional<DeviceProductInfo> SurfaceFlinger::getDeviceProductInfoLocked(
1309 const DisplayDevice& display) const {
1310 // TODO(b/149075047): Populate DeviceProductInfo on hotplug and store it in DisplayDevice to
1311 // avoid repetitive HAL IPC and EDID parsing.
1312 const auto displayId = display.getId();
1313 LOG_FATAL_IF(!displayId);
1314
1315 const auto hwcDisplayId = getHwComposer().fromPhysicalDisplayId(*displayId);
1316 LOG_FATAL_IF(!hwcDisplayId);
1317
1318 uint8_t port;
1319 DisplayIdentificationData data;
1320 if (!getHwComposer().getDisplayIdentificationData(*hwcDisplayId, &port, &data)) {
1321 ALOGV("%s: No identification data.", __FUNCTION__);
1322 return {};
1323 }
1324
1325 const auto info = parseDisplayIdentificationData(port, data);
1326 if (!info) {
1327 return {};
1328 }
1329 return info->deviceProductInfo;
1330}
1331
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001332status_t SurfaceFlinger::getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
1333 ui::PixelFormat* outFormat,
1334 ui::Dataspace* outDataspace,
1335 uint8_t* outComponentMask) const {
1336 if (!outFormat || !outDataspace || !outComponentMask) {
1337 return BAD_VALUE;
1338 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001339
1340 Mutex::Autolock lock(mStateLock);
1341
1342 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1343 if (!displayId) {
1344 return NAME_NOT_FOUND;
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001345 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001346
1347 return getHwComposer().getDisplayedContentSamplingAttributes(*displayId, outFormat,
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001348 outDataspace, outComponentMask);
1349}
1350
Kevin DuBois74e53772018-11-19 10:52:38 -08001351status_t SurfaceFlinger::setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken,
1352 bool enable, uint8_t componentMask,
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001353 uint64_t maxFrames) {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001354 return schedule([=]() -> status_t {
1355 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
1356 return getHwComposer().setDisplayContentSamplingEnabled(*displayId, enable,
1357 componentMask,
1358 maxFrames);
1359 } else {
1360 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
1361 return NAME_NOT_FOUND;
1362 }
1363 })
1364 .get();
Kevin DuBois74e53772018-11-19 10:52:38 -08001365}
1366
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001367status_t SurfaceFlinger::getDisplayedContentSample(const sp<IBinder>& displayToken,
1368 uint64_t maxFrames, uint64_t timestamp,
1369 DisplayedFrameStats* outStats) const {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001370 Mutex::Autolock lock(mStateLock);
1371
1372 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1373 if (!displayId) {
1374 return NAME_NOT_FOUND;
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001375 }
1376
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001377 return getHwComposer().getDisplayedContentSample(*displayId, maxFrames, timestamp, outStats);
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001378}
1379
Peiyong Lin3c2791e2019-01-14 17:05:18 -08001380status_t SurfaceFlinger::getProtectedContentSupport(bool* outSupported) const {
1381 if (!outSupported) {
1382 return BAD_VALUE;
1383 }
1384 *outSupported = getRenderEngine().supportsProtectedContent();
1385 return NO_ERROR;
1386}
1387
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001388status_t SurfaceFlinger::isWideColorDisplay(const sp<IBinder>& displayToken,
1389 bool* outIsWideColorDisplay) const {
1390 if (!displayToken || !outIsWideColorDisplay) {
1391 return BAD_VALUE;
1392 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001393
1394 Mutex::Autolock lock(mStateLock);
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001395 const auto display = getDisplayDeviceLocked(displayToken);
1396 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001397 return NAME_NOT_FOUND;
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001398 }
Peiyong Linff84a152019-05-17 18:36:19 -07001399
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001400 *outIsWideColorDisplay =
1401 display->isPrimary() ? hasWideColorDisplay : display->hasWideColorGamut();
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001402 return NO_ERROR;
1403}
1404
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001405status_t SurfaceFlinger::enableVSyncInjections(bool enable) {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001406 schedule([=] {
Dominik Laskowski6505f792019-09-18 11:10:05 -07001407 Mutex::Autolock lock(mStateLock);
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001408
Dominik Laskowski6505f792019-09-18 11:10:05 -07001409 if (const auto handle = mScheduler->enableVSyncInjection(enable)) {
1410 mEventQueue->setEventConnection(
1411 mScheduler->getEventConnection(enable ? handle : mSfConnectionHandle));
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001412 }
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001413 }).wait();
Dominik Laskowski8c001672018-05-30 16:52:06 -07001414
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001415 return NO_ERROR;
1416}
1417
1418status_t SurfaceFlinger::injectVSync(nsecs_t when) {
Dominik Laskowski6505f792019-09-18 11:10:05 -07001419 Mutex::Autolock lock(mStateLock);
Ady Abraham5facfb12020-04-22 15:18:31 -07001420 return mScheduler->injectVSync(when, calculateExpectedPresentTime(when)) ? NO_ERROR : BAD_VALUE;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001421}
1422
Lloyd Pique755e3192018-01-31 16:46:15 -08001423status_t SurfaceFlinger::getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const
1424 NO_THREAD_SAFETY_ANALYSIS {
Kalle Raitaa099a242017-01-11 11:17:29 -08001425 // Try to acquire a lock for 1s, fail gracefully
1426 const status_t err = mStateLock.timedLock(s2ns(1));
1427 const bool locked = (err == NO_ERROR);
1428 if (!locked) {
1429 ALOGE("LayerDebugInfo: SurfaceFlinger unresponsive (%s [%d]) - exit", strerror(-err), err);
1430 return TIMED_OUT;
1431 }
1432
1433 outLayers->clear();
1434 mCurrentState.traverseInZOrder([&](Layer* layer) {
1435 outLayers->push_back(layer->getLayerDebugInfo());
1436 });
1437
1438 mStateLock.unlock();
1439 return NO_ERROR;
1440}
1441
Peiyong Linc6780972018-10-28 15:24:08 -07001442status_t SurfaceFlinger::getCompositionPreference(
1443 Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
1444 Dataspace* outWideColorGamutDataspace,
1445 ui::PixelFormat* outWideColorGamutPixelFormat) const {
Peiyong Lin9d846a52018-11-05 13:18:20 -08001446 *outDataspace = mDefaultCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001447 *outPixelFormat = defaultCompositionPixelFormat;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001448 *outWideColorGamutDataspace = mWideColorGamutCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001449 *outWideColorGamutPixelFormat = wideColorGamutCompositionPixelFormat;
Peiyong Lin0256f722018-08-31 15:45:10 -07001450 return NO_ERROR;
1451}
1452
Dan Stozaec460082018-12-17 15:35:09 -08001453status_t SurfaceFlinger::addRegionSamplingListener(const Rect& samplingArea,
1454 const sp<IBinder>& stopLayerHandle,
1455 const sp<IRegionSamplingListener>& listener) {
tangrobinaf45f012019-02-26 18:10:10 +08001456 if (!listener || samplingArea == Rect::INVALID_RECT) {
Dan Stozaec460082018-12-17 15:35:09 -08001457 return BAD_VALUE;
1458 }
Alec Mouri9a02eda2020-04-21 17:39:34 -07001459
1460 const wp<Layer> stopLayer = fromHandle(stopLayerHandle);
1461 mRegionSamplingThread->addListener(samplingArea, stopLayer, listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001462 return NO_ERROR;
1463}
1464
Dan Stozaec460082018-12-17 15:35:09 -08001465status_t SurfaceFlinger::removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) {
tangrobinaf45f012019-02-26 18:10:10 +08001466 if (!listener) {
1467 return BAD_VALUE;
1468 }
Dan Stozaec460082018-12-17 15:35:09 -08001469 mRegionSamplingThread->removeListener(listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001470 return NO_ERROR;
1471}
Dan Gittik57e63c52019-01-18 16:37:54 +00001472
1473status_t SurfaceFlinger::getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
1474 bool* outSupport) const {
1475 if (!displayToken || !outSupport) {
1476 return BAD_VALUE;
1477 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001478
1479 Mutex::Autolock lock(mStateLock);
1480
Dan Gittik57e63c52019-01-18 16:37:54 +00001481 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1482 if (!displayId) {
1483 return NAME_NOT_FOUND;
1484 }
1485 *outSupport =
Peiyong Line9d809e2020-04-14 13:10:48 -07001486 getHwComposer().hasDisplayCapability(*displayId, hal::DisplayCapability::BRIGHTNESS);
Dan Gittik57e63c52019-01-18 16:37:54 +00001487 return NO_ERROR;
1488}
1489
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001490status_t SurfaceFlinger::setDisplayBrightness(const sp<IBinder>& displayToken, float brightness) {
Dan Gittik57e63c52019-01-18 16:37:54 +00001491 if (!displayToken) {
1492 return BAD_VALUE;
1493 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001494
Dominik Laskowski5690bde2020-04-23 19:04:22 -07001495 return promise::chain(schedule([=] {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001496 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
1497 return getHwComposer().setDisplayBrightness(*displayId, brightness);
1498 } else {
1499 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
Dominik Laskowski5690bde2020-04-23 19:04:22 -07001500 return promise::yield<status_t>(NAME_NOT_FOUND);
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001501 }
Dominik Laskowski5690bde2020-04-23 19:04:22 -07001502 }))
1503 .then([](std::future<status_t> task) { return task; })
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001504 .get();
Dan Gittik57e63c52019-01-18 16:37:54 +00001505}
1506
Ady Abraham8532d012019-05-08 14:50:56 -07001507status_t SurfaceFlinger::notifyPowerHint(int32_t hintId) {
1508 PowerHint powerHint = static_cast<PowerHint>(hintId);
1509
1510 if (powerHint == PowerHint::INTERACTION) {
1511 mScheduler->notifyTouchEvent();
1512 }
1513
1514 return NO_ERROR;
1515}
1516
Mathias Agopiand0566bc2011-11-17 17:49:17 -08001517// ----------------------------------------------------------------------------
1518
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -07001519sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection(
Ady Abraham0f4a1b12019-06-04 16:04:04 -07001520 ISurfaceComposer::VsyncSource vsyncSource, ISurfaceComposer::ConfigChanged configChanged) {
Ana Krulecc2870422019-01-29 19:00:58 -08001521 const auto& handle =
1522 vsyncSource == eVsyncSourceSurfaceFlinger ? mSfConnectionHandle : mAppConnectionHandle;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001523
Steven Thomas2bbaabe2019-08-28 16:08:35 -07001524 return mScheduler->createDisplayEventConnection(handle, configChanged);
Mathias Agopianbb641242010-05-18 17:06:55 -07001525}
1526
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001527void SurfaceFlinger::signalTransaction() {
Ady Abraham8532d012019-05-08 14:50:56 -07001528 mScheduler->resetIdleTimer();
Dan Stoza030fbc12020-02-19 15:32:01 -08001529 mPowerAdvisor.notifyDisplayUpdateImminent();
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001530 mEventQueue->invalidate();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001531}
1532
1533void SurfaceFlinger::signalLayerUpdate() {
Ady Abraham8532d012019-05-08 14:50:56 -07001534 mScheduler->resetIdleTimer();
Dan Stoza030fbc12020-02-19 15:32:01 -08001535 mPowerAdvisor.notifyDisplayUpdateImminent();
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001536 mEventQueue->invalidate();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001537}
1538
1539void SurfaceFlinger::signalRefresh() {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07001540 mRefreshPending = true;
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001541 mEventQueue->refresh();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001542}
1543
Dominik Laskowski83b88212018-12-11 13:34:06 -08001544nsecs_t SurfaceFlinger::getVsyncPeriod() const {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001545 const auto displayId = getInternalDisplayIdLocked();
Dominik Laskowski83b88212018-12-11 13:34:06 -08001546 if (!displayId || !getHwComposer().isConnected(*displayId)) {
1547 return 0;
1548 }
1549
Ady Abraham3a77a7b2019-12-02 18:46:59 -08001550 return getHwComposer().getDisplayVsyncPeriod(*displayId);
Dominik Laskowski83b88212018-12-11 13:34:06 -08001551}
1552
Peiyong Line9d809e2020-04-14 13:10:48 -07001553void SurfaceFlinger::onVsyncReceived(int32_t sequenceId, hal::HWDisplayId hwcDisplayId,
Ady Abraham7159f572019-10-11 11:10:18 -07001554 int64_t timestamp,
Peiyong Line9d809e2020-04-14 13:10:48 -07001555 std::optional<hal::VsyncPeriodNanos> vsyncPeriod) {
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001556 ATRACE_NAME("SF onVsync");
1557
Steven Thomas3cfac282017-02-06 12:29:30 -08001558 Mutex::Autolock lock(mStateLock);
Steven Thomasb02664d2017-07-26 18:48:28 -07001559 // Ignore any vsyncs from a previous hardware composer.
David Sodman105b7dc2017-11-04 20:28:14 -07001560 if (sequenceId != getBE().mComposerSequenceId) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001561 return;
1562 }
1563
Dominik Laskowski075d3172018-05-24 15:50:06 -07001564 if (!getHwComposer().onVsync(hwcDisplayId, timestamp)) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001565 return;
1566 }
1567
Dominik Laskowski075d3172018-05-24 15:50:06 -07001568 if (hwcDisplayId != getHwComposer().getInternalHwcDisplayId()) {
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001569 // For now, we don't do anything with external display vsyncs.
1570 return;
1571 }
1572
Alec Mourif8e689c2019-05-20 18:32:22 -07001573 bool periodFlushed = false;
Ady Abraham5dee2f12020-02-05 17:49:47 -08001574 mScheduler->addResyncSample(timestamp, vsyncPeriod, &periodFlushed);
Alec Mourif8e689c2019-05-20 18:32:22 -07001575 if (periodFlushed) {
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001576 mVSyncModulator->onRefreshRateChangeCompleted();
Alec Mouri754c98a2019-03-18 18:53:42 -07001577 }
Mathias Agopian148994e2012-09-19 17:31:36 -07001578}
1579
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001580void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
David Sodman99974d22017-11-28 12:04:33 -08001581 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
1582 *compositorTiming = getBE().mCompositorTiming;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001583}
1584
Ady Abraham2139f732019-11-13 18:56:40 -08001585bool SurfaceFlinger::isDisplayConfigAllowed(HwcConfigIndexType configId) const {
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001586 return mRefreshRateConfigs->isConfigAllowed(configId);
Ady Abraham838de062019-02-04 10:24:03 -08001587}
1588
Ady Abraham2139f732019-11-13 18:56:40 -08001589void SurfaceFlinger::changeRefreshRateLocked(const RefreshRate& refreshRate,
1590 Scheduler::ConfigEvent event) {
Dominik Laskowski22488f62019-03-28 09:53:04 -07001591 const auto display = getDefaultDisplayDeviceLocked();
1592 if (!display || mBootStage != BootStage::FINISHED) {
Ana Krulec7d1d6832018-12-27 11:10:09 -08001593 return;
1594 }
Alec Mouri1c9e82b2019-03-07 12:24:05 -08001595 ATRACE_CALL();
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001596
Ana Krulec7d1d6832018-12-27 11:10:09 -08001597 // Don't do any updating if the current fps is the same as the new one.
Ady Abrahamabc27602020-04-08 17:20:29 -07001598 if (!isDisplayConfigAllowed(refreshRate.getConfigId())) {
Ady Abraham2139f732019-11-13 18:56:40 -08001599 ALOGV("Skipping config %d as it is not part of allowed configs",
Ady Abrahamabc27602020-04-08 17:20:29 -07001600 refreshRate.getConfigId().value());
Ady Abraham1902d072019-03-01 17:18:59 -08001601 return;
1602 }
1603
Ady Abrahamabc27602020-04-08 17:20:29 -07001604 setDesiredActiveConfig({refreshRate.getConfigId(), event});
Ana Krulec7d1d6832018-12-27 11:10:09 -08001605}
1606
Peiyong Line9d809e2020-04-14 13:10:48 -07001607void SurfaceFlinger::onHotplugReceived(int32_t sequenceId, hal::HWDisplayId hwcDisplayId,
1608 hal::Connection connection) {
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001609 ALOGV("%s(%d, %" PRIu64 ", %s)", __FUNCTION__, sequenceId, hwcDisplayId,
Peiyong Line9d809e2020-04-14 13:10:48 -07001610 connection == hal::Connection::CONNECTED ? "connected" : "disconnected");
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001611
Lloyd Piqueba04e622017-12-14 17:11:26 -08001612 // Ignore events that do not have the right sequenceId.
1613 if (sequenceId != getBE().mComposerSequenceId) {
1614 return;
1615 }
1616
Steven Thomasb02664d2017-07-26 18:48:28 -07001617 // Only lock if we're not on the main thread. This function is normally
1618 // called on a hwbinder thread, but for the primary display it's called on
1619 // the main thread with the state lock already held, so don't attempt to
1620 // acquire it here.
Lloyd Piqueba04e622017-12-14 17:11:26 -08001621 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
Steven Thomasb02664d2017-07-26 18:48:28 -07001622
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001623 mPendingHotplugEvents.emplace_back(HotplugEvent{hwcDisplayId, connection});
Mathias Agopian9e2463e2012-09-21 18:26:16 -07001624
Jiwen 'Steve' Caiccfd6822018-02-21 16:15:58 -08001625 if (std::this_thread::get_id() == mMainThreadId) {
1626 // Process all pending hot plug events immediately if we are on the main thread.
1627 processDisplayHotplugEventsLocked();
1628 }
1629
Lloyd Piqueba04e622017-12-14 17:11:26 -08001630 setTransactionFlags(eDisplayTransactionNeeded);
Mathias Agopian86303202012-07-24 22:46:10 -07001631}
1632
Ady Abraham7159f572019-10-11 11:10:18 -07001633void SurfaceFlinger::onVsyncPeriodTimingChangedReceived(
Peiyong Line9d809e2020-04-14 13:10:48 -07001634 int32_t sequenceId, hal::HWDisplayId /*display*/,
1635 const hal::VsyncPeriodChangeTimeline& updatedTimeline) {
Ady Abraham3a77a7b2019-12-02 18:46:59 -08001636 Mutex::Autolock lock(mStateLock);
1637 if (sequenceId != getBE().mComposerSequenceId) {
1638 return;
1639 }
1640 mScheduler->onNewVsyncPeriodChangeTimeline(updatedTimeline);
Ady Abraham7159f572019-10-11 11:10:18 -07001641}
1642
Peiyong Line9d809e2020-04-14 13:10:48 -07001643void SurfaceFlinger::onSeamlessPossible(int32_t /*sequenceId*/, hal::HWDisplayId /*display*/) {
Ady Abrahamb0433bc2020-01-08 17:31:06 -08001644 // TODO(b/142753666): use constraints when calling to setActiveConfigWithConstrains and
1645 // use this callback to know when to retry in case of SEAMLESS_NOT_POSSIBLE.
1646}
1647
Peiyong Line9d809e2020-04-14 13:10:48 -07001648void SurfaceFlinger::onRefreshReceived(int sequenceId, hal::HWDisplayId /*hwcDisplayId*/) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001649 Mutex::Autolock lock(mStateLock);
David Sodman105b7dc2017-11-04 20:28:14 -07001650 if (sequenceId != getBE().mComposerSequenceId) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001651 return;
Steven Thomas3cfac282017-02-06 12:29:30 -08001652 }
Ana Krulec7d1d6832018-12-27 11:10:09 -08001653 repaintEverythingForHWC();
Steven Thomas3cfac282017-02-06 12:29:30 -08001654}
1655
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001656void SurfaceFlinger::setPrimaryVsyncEnabled(bool enabled) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001657 ATRACE_CALL();
Ady Abraham9ba25122019-06-03 17:10:55 -07001658
1659 // Enable / Disable HWVsync from the main thread to avoid race conditions with
1660 // display power state.
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001661 static_cast<void>(
1662 schedule([=]() NO_THREAD_SAFETY_ANALYSIS { setPrimaryVsyncEnabledInternal(enabled); }));
Ady Abraham9ba25122019-06-03 17:10:55 -07001663}
1664
1665void SurfaceFlinger::setPrimaryVsyncEnabledInternal(bool enabled) {
1666 ATRACE_CALL();
1667
Peiyong Line9d809e2020-04-14 13:10:48 -07001668 mHWCVsyncPendingState = enabled ? hal::Vsync::ENABLE : hal::Vsync::DISABLE;
Ady Abraham27c70212019-06-11 10:52:26 -07001669
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001670 if (const auto displayId = getInternalDisplayIdLocked()) {
Ady Abraham9ba25122019-06-03 17:10:55 -07001671 sp<DisplayDevice> display = getDefaultDisplayDeviceLocked();
1672 if (display && display->isPoweredOn()) {
Ady Abraham27c70212019-06-11 10:52:26 -07001673 setVsyncEnabledInHWC(*displayId, mHWCVsyncPendingState);
Ady Abraham9ba25122019-06-03 17:10:55 -07001674 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07001675 }
Mathias Agopian86303202012-07-24 22:46:10 -07001676}
1677
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001678// Note: it is assumed the caller holds |mStateLock| when this is called
Steven Thomasb02664d2017-07-26 18:48:28 -07001679void SurfaceFlinger::resetDisplayState() {
Ana Krulecc2870422019-01-29 19:00:58 -08001680 mScheduler->disableHardwareVsync(true);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001681 // Clear the drawing state so that the logic inside of
1682 // handleTransactionLocked will fire. It will determine the delta between
1683 // mCurrentState and mDrawingState and re-apply all changes when we make the
1684 // transition.
1685 mDrawingState.displays.clear();
1686 mDisplays.clear();
1687}
1688
Steven Thomas050b2c82017-03-06 11:45:16 -08001689void SurfaceFlinger::updateVrFlinger() {
Alec Mourife3dc942019-02-12 14:19:18 -08001690 ATRACE_CALL();
Steven Thomas050b2c82017-03-06 11:45:16 -08001691 if (!mVrFlinger)
1692 return;
1693 bool vrFlingerRequestsDisplay = mVrFlingerRequestsDisplay;
Lloyd Pique441d5042018-10-18 16:49:51 -07001694 if (vrFlingerRequestsDisplay == getHwComposer().isUsingVrComposer()) {
Mark Urbanus209beca2017-02-23 11:16:04 -08001695 return;
1696 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001697
Lloyd Pique441d5042018-10-18 16:49:51 -07001698 if (vrFlingerRequestsDisplay && !getHwComposer().getComposer()->isRemote()) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001699 ALOGE("Vr flinger is only supported for remote hardware composer"
1700 " service connections. Ignoring request to transition to vr"
1701 " flinger.");
1702 mVrFlingerRequestsDisplay = false;
1703 return;
Mark Urbanus209beca2017-02-23 11:16:04 -08001704 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001705
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001706 Mutex::Autolock _l(mStateLock);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001707
Steven Thomas0123ac62018-07-12 11:32:34 -07001708 sp<DisplayDevice> display = getDefaultDisplayDeviceLocked();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07001709 LOG_ALWAYS_FATAL_IF(!display);
Lloyd Pique07e33212018-12-18 16:33:37 -08001710
Peiyong Lin65248e02020-04-18 21:15:07 -07001711 const hal::PowerMode currentDisplayPowerMode = display->getPowerMode();
Lloyd Pique07e33212018-12-18 16:33:37 -08001712
1713 // Clear out all the output layers from the composition engine for all
1714 // displays before destroying the hardware composer interface. This ensures
1715 // any HWC layers are destroyed through that interface before it becomes
1716 // invalid.
1717 for (const auto& [token, displayDevice] : mDisplays) {
Lloyd Pique01c77c12019-04-17 12:48:32 -07001718 displayDevice->getCompositionDisplay()->clearOutputLayers();
Lloyd Pique07e33212018-12-18 16:33:37 -08001719 }
1720
Steven Thomas0123ac62018-07-12 11:32:34 -07001721 // This DisplayDevice will no longer be relevant once resetDisplayState() is
1722 // called below. Clear the reference now so we don't accidentally use it
1723 // later.
1724 display.clear();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001725
Steven Thomasb02664d2017-07-26 18:48:28 -07001726 if (!vrFlingerRequestsDisplay) {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001727 mVrFlinger->SeizeDisplayOwnership();
Steven Thomasb02664d2017-07-26 18:48:28 -07001728 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001729
Steven Thomasb02664d2017-07-26 18:48:28 -07001730 resetDisplayState();
Lloyd Pique441d5042018-10-18 16:49:51 -07001731 // Delete the current instance before creating the new one
1732 mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
1733 mCompositionEngine->setHwComposer(getFactory().createHWComposer(
1734 vrFlingerRequestsDisplay ? "vr" : getBE().mHwcServiceName));
Lloyd Pique4603f3c2020-02-11 12:06:56 -08001735 mCompositionEngine->getHwComposer().setConfiguration(this, ++getBE().mComposerSequenceId);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001736
Lloyd Pique441d5042018-10-18 16:49:51 -07001737 LOG_ALWAYS_FATAL_IF(!getHwComposer().getComposer()->isRemote(),
David Sodman105b7dc2017-11-04 20:28:14 -07001738 "Switched to non-remote hardware composer");
Steven Thomasb02664d2017-07-26 18:48:28 -07001739
1740 if (vrFlingerRequestsDisplay) {
1741 mVrFlinger->GrantDisplayOwnership();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001742 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001743
1744 mVisibleRegionsDirty = true;
1745 invalidateHwcGeometry();
1746
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001747 // Re-enable default display.
Steven Thomas0123ac62018-07-12 11:32:34 -07001748 display = getDefaultDisplayDeviceLocked();
1749 LOG_ALWAYS_FATAL_IF(!display);
Dominik Laskowskie9774092018-12-11 10:04:24 -08001750 setPowerModeInternal(display, currentDisplayPowerMode);
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001751
Steven Thomasb02664d2017-07-26 18:48:28 -07001752 // Reset the timing values to account for the period of the swapped in HWC
Dominik Laskowski83b88212018-12-11 13:34:06 -08001753 const nsecs_t vsyncPeriod = getVsyncPeriod();
1754 mAnimFrameTracker.setDisplayRefreshPeriod(vsyncPeriod);
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001755
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001756 // The present fences returned from vr_hwc are not an accurate
1757 // representation of vsync times.
Ana Krulecc2870422019-01-29 19:00:58 -08001758 mScheduler->setIgnorePresentFences(getHwComposer().isUsingVrComposer() || !hasSyncFramework);
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001759
Steven Thomasb02664d2017-07-26 18:48:28 -07001760 // Use phase of 0 since phase is not known.
1761 // Use latency of 0, which will snap to the ideal latency.
Dominik Laskowski83b88212018-12-11 13:34:06 -08001762 DisplayStatInfo stats{0 /* vsyncTime */, vsyncPeriod};
Ana Krulece588e312018-09-18 12:32:24 -07001763 setCompositorTimingSnapped(stats, 0);
Stephen Kiazyk82386cd2017-04-14 13:43:29 -07001764
Ana Krulecc2870422019-01-29 19:00:58 -08001765 mScheduler->resyncToHardwareVsync(false, vsyncPeriod);
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001766
Lloyd Piquef1c675b2018-09-12 20:45:39 -07001767 mRepaintEverything = true;
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001768 setTransactionFlags(eDisplayTransactionNeeded);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001769}
1770
Alec Mouri6d414b52020-03-17 11:18:05 -07001771sp<Fence> SurfaceFlinger::previousFrameFence() NO_THREAD_SAFETY_ANALYSIS {
Ady Abrahambe0f9482019-04-24 15:41:53 -07001772 // We are storing the last 2 present fences. If sf's phase offset is to be
1773 // woken up before the actual vsync but targeting the next vsync, we need to check
1774 // fence N-2
Alec Mouri6d414b52020-03-17 11:18:05 -07001775 return mVSyncModulator->getOffsets().sf > 0 ? mPreviousPresentFences[0]
1776 : mPreviousPresentFences[1];
1777}
1778
1779bool SurfaceFlinger::previousFramePending(int graceTimeMs) NO_THREAD_SAFETY_ANALYSIS {
1780 ATRACE_CALL();
1781 const sp<Fence>& fence = previousFrameFence();
Ady Abrahambe0f9482019-04-24 15:41:53 -07001782
Ady Abraham11579302019-09-19 12:35:58 -07001783 if (fence == Fence::NO_FENCE) {
1784 return false;
1785 }
1786
Dan Stoza59083052020-04-28 10:13:20 -07001787 const status_t status = fence->wait(graceTimeMs);
1788 // This is the same as Fence::Status::Unsignaled, but it saves a getStatus() call,
1789 // which calls wait(0) again internally
1790 return status == -ETIME;
Ady Abrahambe0f9482019-04-24 15:41:53 -07001791}
1792
Alec Mouri6d414b52020-03-17 11:18:05 -07001793nsecs_t SurfaceFlinger::previousFramePresentTime() NO_THREAD_SAFETY_ANALYSIS {
1794 const sp<Fence>& fence = previousFrameFence();
1795
1796 if (fence == Fence::NO_FENCE) {
1797 return Fence::SIGNAL_TIME_INVALID;
1798 }
1799
1800 return fence->getSignalTime();
1801}
1802
Ady Abraham5facfb12020-04-22 15:18:31 -07001803nsecs_t SurfaceFlinger::calculateExpectedPresentTime(nsecs_t now) const {
Alec Mouriaa614192019-06-06 13:28:34 -07001804 DisplayStatInfo stats;
1805 mScheduler->getDisplayStatInfo(&stats);
Ady Abraham5facfb12020-04-22 15:18:31 -07001806 const nsecs_t presentTime = mScheduler->getDispSyncExpectedPresentTime(now);
Alec Mouriaa614192019-06-06 13:28:34 -07001807 // Inflate the expected present time if we're targetting the next vsync.
Ady Abraham5facfb12020-04-22 15:18:31 -07001808 return mVSyncModulator->getOffsets().sf > 0 ? presentTime : presentTime + stats.vsyncPeriod;
Alec Mouriaa614192019-06-06 13:28:34 -07001809}
1810
Ady Abraham5facfb12020-04-22 15:18:31 -07001811void SurfaceFlinger::onMessageReceived(int32_t what,
1812 nsecs_t expectedVSyncTime) NO_THREAD_SAFETY_ANALYSIS {
Jamie Gennis1c8e95c2012-02-23 19:27:23 -08001813 ATRACE_CALL();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001814 switch (what) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08001815 case MessageQueue::INVALIDATE: {
Dan Stoza28d46a52020-04-28 09:54:54 -07001816 onMessageInvalidate(expectedVSyncTime);
Dan Stoza6b9454d2014-11-07 16:00:59 -08001817 break;
1818 }
1819 case MessageQueue::REFRESH: {
Dan Stoza28d46a52020-04-28 09:54:54 -07001820 onMessageRefresh();
Dan Stoza6b9454d2014-11-07 16:00:59 -08001821 break;
1822 }
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001823 }
1824}
1825
Dan Stoza28d46a52020-04-28 09:54:54 -07001826void SurfaceFlinger::onMessageInvalidate(nsecs_t expectedVSyncTime) NO_THREAD_SAFETY_ANALYSIS {
1827 ATRACE_CALL();
1828
1829 const nsecs_t frameStart = systemTime();
1830 // calculate the expected present time once and use the cached
1831 // value throughout this frame to make sure all layers are
1832 // seeing this same value.
1833 const nsecs_t lastExpectedPresentTime = mExpectedPresentTime.load();
1834 mExpectedPresentTime = expectedVSyncTime;
1835
1836 // When Backpressure propagation is enabled we want to give a small grace period
1837 // for the present fence to fire instead of just giving up on this frame to handle cases
1838 // where present fence is just about to get signaled.
1839 const int graceTimeForPresentFenceMs =
1840 (mPropagateBackpressure &&
1841 (mPropagateBackpressureClientComposition || !mHadClientComposition))
1842 ? 1
1843 : 0;
1844
1845 // Pending frames may trigger backpressure propagation.
1846 const TracedOrdinal<bool> framePending = {"PrevFramePending",
1847 previousFramePending(graceTimeForPresentFenceMs)};
1848
1849 // Frame missed counts for metrics tracking.
1850 // A frame is missed if the prior frame is still pending. If no longer pending,
1851 // then we still count the frame as missed if the predicted present time
1852 // was further in the past than when the fence actually fired.
1853
1854 // Add some slop to correct for drift. This should generally be
1855 // smaller than a typical frame duration, but should not be so small
1856 // that it reports reasonable drift as a missed frame.
1857 DisplayStatInfo stats;
1858 mScheduler->getDisplayStatInfo(&stats);
1859 const nsecs_t frameMissedSlop = stats.vsyncPeriod / 2;
1860 const nsecs_t previousPresentTime = previousFramePresentTime();
1861 const TracedOrdinal<bool> frameMissed = {"PrevFrameMissed",
1862 framePending ||
1863 (previousPresentTime >= 0 &&
1864 (lastExpectedPresentTime <
1865 previousPresentTime - frameMissedSlop))};
1866 const TracedOrdinal<bool> hwcFrameMissed = {"PrevHwcFrameMissed",
1867 mHadDeviceComposition && frameMissed};
1868 const TracedOrdinal<bool> gpuFrameMissed = {"PrevGpuFrameMissed",
1869 mHadClientComposition && frameMissed};
1870
1871 if (frameMissed) {
1872 mFrameMissedCount++;
1873 mTimeStats->incrementMissedFrames();
1874 if (mMissedFrameJankCount == 0) {
1875 mMissedFrameJankStart = systemTime();
1876 }
1877 mMissedFrameJankCount++;
1878 }
1879
1880 if (hwcFrameMissed) {
1881 mHwcFrameMissedCount++;
1882 }
1883
1884 if (gpuFrameMissed) {
1885 mGpuFrameMissedCount++;
1886 }
1887
1888 // If we are in the middle of a config change and the fence hasn't
1889 // fired yet just wait for the next invalidate
1890 if (mSetActiveConfigPending) {
1891 if (framePending) {
1892 mEventQueue->invalidate();
1893 return;
1894 }
1895
1896 // We received the present fence from the HWC, so we assume it successfully updated
1897 // the config, hence we update SF.
1898 mSetActiveConfigPending = false;
1899 setActiveConfigInternal();
1900 }
1901
1902 if (framePending && mPropagateBackpressure) {
1903 if ((hwcFrameMissed && !gpuFrameMissed) || mPropagateBackpressureClientComposition) {
1904 signalLayerUpdate();
1905 return;
1906 }
1907 }
1908
1909 // Our jank window is always at least 100ms since we missed a
1910 // frame...
1911 static constexpr nsecs_t kMinJankyDuration =
1912 std::chrono::duration_cast<std::chrono::nanoseconds>(100ms).count();
1913 // ...but if it's larger than 1s then we missed the trace cutoff.
1914 static constexpr nsecs_t kMaxJankyDuration =
1915 std::chrono::duration_cast<std::chrono::nanoseconds>(1s).count();
1916 // If we're in a user build then don't push any atoms
1917 if (!mIsUserBuild && mMissedFrameJankCount > 0) {
1918 const auto displayDevice = getDefaultDisplayDeviceLocked();
1919 // Only report jank when the display is on, as displays in DOZE
1920 // power mode may operate at a different frame rate than is
1921 // reported in their config, which causes noticeable (but less
1922 // severe) jank.
1923 if (displayDevice && displayDevice->getPowerMode() == hal::PowerMode::ON) {
1924 const nsecs_t currentTime = systemTime();
1925 const nsecs_t jankDuration = currentTime - mMissedFrameJankStart;
1926 if (jankDuration > kMinJankyDuration && jankDuration < kMaxJankyDuration) {
1927 ATRACE_NAME("Jank detected");
1928 ALOGD("Detected janky event. Missed frames: %d", mMissedFrameJankCount);
1929 const int32_t jankyDurationMillis = jankDuration / (1000 * 1000);
1930 android::util::stats_write(android::util::DISPLAY_JANK_REPORTED,
1931 jankyDurationMillis, mMissedFrameJankCount);
1932 }
1933
1934 // We either reported a jank event or we missed the trace
1935 // window, so clear counters here.
1936 if (jankDuration > kMinJankyDuration) {
1937 mMissedFrameJankCount = 0;
1938 mMissedFrameJankStart = 0;
1939 }
1940 }
1941 }
1942
1943 // Now that we're going to make it to the handleMessageTransaction()
1944 // call below it's safe to call updateVrFlinger(), which will
1945 // potentially trigger a display handoff.
1946 updateVrFlinger();
1947
1948 if (mTracingEnabledChanged) {
1949 mTracingEnabled = mTracing.isEnabled();
1950 mTracingEnabledChanged = false;
1951 }
1952
1953 bool refreshNeeded;
1954 {
1955 ConditionalLockGuard<std::mutex> lock(mTracingLock, mTracingEnabled);
1956
1957 refreshNeeded = handleMessageTransaction();
1958 refreshNeeded |= handleMessageInvalidate();
1959 if (mTracingEnabled) {
1960 mAddCompositionStateToTrace =
1961 mTracing.flagIsSetLocked(SurfaceTracing::TRACE_COMPOSITION);
1962 if (mVisibleRegionsDirty && !mAddCompositionStateToTrace) {
1963 mTracing.notifyLocked("visibleRegionsDirty");
1964 }
1965 }
1966 }
1967
1968 // Layers need to get updated (in the previous line) before we can use them for
1969 // choosing the refresh rate.
1970 // Hold mStateLock as chooseRefreshRateForContent promotes wp<Layer> to sp<Layer>
1971 // and may eventually call to ~Layer() if it holds the last reference
1972 {
1973 Mutex::Autolock _l(mStateLock);
1974 mScheduler->chooseRefreshRateForContent();
1975 }
1976
1977 performSetActiveConfig();
1978
1979 updateCursorAsync();
1980 updateInputFlinger();
1981
1982 refreshNeeded |= mRepaintEverything;
1983 if (refreshNeeded && CC_LIKELY(mBootStage != BootStage::BOOTLOADER)) {
1984 // Signal a refresh if a transaction modified the window state,
1985 // a new buffer was latched, or if HWC has requested a full
1986 // repaint
1987 if (mFrameStartTime <= 0) {
1988 // We should only use the time of the first invalidate
1989 // message that signals a refresh as the beginning of the
1990 // frame. Otherwise the real frame time will be
1991 // underestimated.
1992 mFrameStartTime = frameStart;
1993 }
1994 signalRefresh();
1995 }
1996}
1997
Dan Stoza6b9454d2014-11-07 16:00:59 -08001998bool SurfaceFlinger::handleMessageTransaction() {
Alec Mourife3dc942019-02-12 14:19:18 -08001999 ATRACE_CALL();
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08002000 uint32_t transactionFlags = peekTransactionFlags();
Marissa Wall713b63f2018-10-17 15:42:43 -07002001
Marissa Walle6e3c0d2019-03-29 10:28:30 -07002002 bool flushedATransaction = flushTransactionQueues();
2003
2004 bool runHandleTransaction = transactionFlags &&
2005 ((transactionFlags != eTransactionFlushNeeded) || flushedATransaction);
2006
2007 if (runHandleTransaction) {
2008 handleTransaction(eTransactionMask);
2009 } else {
2010 getTransactionFlags(eTransactionFlushNeeded);
Marissa Wall713b63f2018-10-17 15:42:43 -07002011 }
2012
Marissa Walle6e3c0d2019-03-29 10:28:30 -07002013 if (transactionFlushNeeded()) {
2014 setTransactionFlags(eTransactionFlushNeeded);
Mathias Agopian4fec8732012-06-29 14:12:52 -07002015 }
Marissa Wall713b63f2018-10-17 15:42:43 -07002016
Marissa Walle6e3c0d2019-03-29 10:28:30 -07002017 return runHandleTransaction;
Mathias Agopian4fec8732012-06-29 14:12:52 -07002018}
2019
Dan Stoza28d46a52020-04-28 09:54:54 -07002020void SurfaceFlinger::onMessageRefresh() {
Mathias Agopiancd60f992012-08-16 16:28:27 -07002021 ATRACE_CALL();
Dan Stoza14cd37c2015-07-09 12:43:33 -07002022
Dan Stoza2b6d38e2017-06-01 16:40:30 -07002023 mRefreshPending = false;
2024
Lloyd Piqueab039b52019-02-13 14:22:42 -08002025 compositionengine::CompositionRefreshArgs refreshArgs;
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002026 refreshArgs.outputs.reserve(mDisplays.size());
Lloyd Piqueab039b52019-02-13 14:22:42 -08002027 for (const auto& [_, display] : mDisplays) {
2028 refreshArgs.outputs.push_back(display->getCompositionDisplay());
2029 }
2030 mDrawingState.traverseInZOrder([&refreshArgs](Layer* layer) {
Lloyd Piquede196652020-01-22 17:29:58 -08002031 if (auto layerFE = layer->getCompositionEngineLayerFE())
2032 refreshArgs.layers.push_back(layerFE);
Lloyd Piqueab039b52019-02-13 14:22:42 -08002033 });
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002034 refreshArgs.layersWithQueuedFrames.reserve(mLayersWithQueuedFrames.size());
2035 for (sp<Layer> layer : mLayersWithQueuedFrames) {
Lloyd Piquede196652020-01-22 17:29:58 -08002036 if (auto layerFE = layer->getCompositionEngineLayerFE())
2037 refreshArgs.layersWithQueuedFrames.push_back(layerFE);
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002038 }
2039
Lloyd Piquef8cf14d2019-02-28 16:03:12 -08002040 refreshArgs.repaintEverything = mRepaintEverything.exchange(false);
Lloyd Pique6a3b4462019-03-07 20:58:12 -08002041 refreshArgs.outputColorSetting = useColorManagement
2042 ? mDisplayColorSetting
2043 : compositionengine::OutputColorSetting::kUnmanaged;
2044 refreshArgs.colorSpaceAgnosticDataspace = mColorSpaceAgnosticDataspace;
2045 refreshArgs.forceOutputColorMode = mForceColorMode;
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002046
2047 refreshArgs.updatingOutputGeometryThisFrame = mVisibleRegionsDirty;
2048 refreshArgs.updatingGeometryThisFrame = mGeometryInvalid || mVisibleRegionsDirty;
Lucas Dupin2dd6f392020-02-18 17:43:36 -08002049 refreshArgs.blursAreExpensive = mBlursAreExpensive;
Lloyd Pique3eb1b212019-03-07 21:15:40 -08002050
2051 if (CC_UNLIKELY(mDrawingState.colorMatrixChanged)) {
2052 refreshArgs.colorTransformMatrix = mDrawingState.colorMatrix;
2053 mDrawingState.colorMatrixChanged = false;
2054 }
2055
2056 refreshArgs.devOptForceClientComposition = mDebugDisableHWC || mDebugRegion;
2057
Lloyd Piquef8cf14d2019-02-28 16:03:12 -08002058 if (mDebugRegion != 0) {
2059 refreshArgs.devOptFlashDirtyRegionsDelay =
2060 std::chrono::milliseconds(mDebugRegion > 1 ? mDebugRegion : 0);
2061 }
Lloyd Piqueab039b52019-02-13 14:22:42 -08002062
Lloyd Pique3eb1b212019-03-07 21:15:40 -08002063 mGeometryInvalid = false;
2064
Ady Abraham3a77a7b2019-12-02 18:46:59 -08002065 // Store the present time just before calling to the composition engine so we could notify
2066 // the scheduler.
2067 const auto presentTime = systemTime();
2068
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002069 mCompositionEngine->present(refreshArgs);
Alec Mouri9519bf12019-11-15 16:54:44 -08002070 mTimeStats->recordFrameDuration(mFrameStartTime, systemTime());
2071 // Reset the frame start time now that we've recorded this frame.
2072 mFrameStartTime = 0;
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002073
Ady Abraham3a77a7b2019-12-02 18:46:59 -08002074 mScheduler->onDisplayRefreshed(presentTime);
2075
David Sodmanfa9b2af2017-12-24 13:28:59 -08002076 postFrame();
David Sodman2b406362017-12-15 13:33:47 -08002077 postComposition();
Dan Stoza05dacfb2016-07-01 13:33:38 -07002078
Alec Mouri8f7a0102020-04-15 12:11:10 -07002079 const bool prevFrameHadDeviceComposition = mHadDeviceComposition;
2080
Lloyd Pique66d68602019-02-13 14:23:31 -08002081 mHadClientComposition =
2082 std::any_of(mDisplays.cbegin(), mDisplays.cend(), [](const auto& tokenDisplayPair) {
2083 auto& displayDevice = tokenDisplayPair.second;
Vishnu Nair9b079a22020-01-21 14:36:08 -08002084 return displayDevice->getCompositionDisplay()->getState().usesClientComposition &&
2085 !displayDevice->getCompositionDisplay()->getState().reusedClientComposition;
Lloyd Pique66d68602019-02-13 14:23:31 -08002086 });
2087 mHadDeviceComposition =
2088 std::any_of(mDisplays.cbegin(), mDisplays.cend(), [](const auto& tokenDisplayPair) {
2089 auto& displayDevice = tokenDisplayPair.second;
2090 return displayDevice->getCompositionDisplay()->getState().usesDeviceComposition;
2091 });
Vishnu Nair9b079a22020-01-21 14:36:08 -08002092 mReusedClientComposition =
2093 std::any_of(mDisplays.cbegin(), mDisplays.cend(), [](const auto& tokenDisplayPair) {
2094 auto& displayDevice = tokenDisplayPair.second;
2095 return displayDevice->getCompositionDisplay()->getState().reusedClientComposition;
2096 });
David Sodmanfa9b2af2017-12-24 13:28:59 -08002097
Alec Mouri8f7a0102020-04-15 12:11:10 -07002098 // Only report a strategy change if we move in and out of composition with hw overlays
2099 if (prevFrameHadDeviceComposition != mHadDeviceComposition) {
2100 mTimeStats->incrementCompositionStrategyChanges();
2101 }
2102
Dominik Laskowskieddeda12019-07-19 11:54:13 -07002103 mVSyncModulator->onRefreshed(mHadClientComposition);
Dan Stoza14cd37c2015-07-09 12:43:33 -07002104
David Sodman7e4ae112018-02-09 15:02:28 -08002105 mLayersWithQueuedFrames.clear();
Vishnu Nairdf529052019-06-07 14:53:14 -07002106 if (mVisibleRegionsDirty) {
2107 mVisibleRegionsDirty = false;
Vishnu Nair60db8c02020-04-02 11:55:16 -07002108 if (mTracingEnabled && mAddCompositionStateToTrace) {
Vishnu Nairdf529052019-06-07 14:53:14 -07002109 mTracing.notify("visibleRegionsDirty");
2110 }
2111 }
Lloyd Piqueab039b52019-02-13 14:22:42 -08002112
2113 if (mCompositionEngine->needsAnotherUpdate()) {
2114 signalLayerUpdate();
2115 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07002116}
Mathias Agopian4fec8732012-06-29 14:12:52 -07002117
David Sodmanfa9b2af2017-12-24 13:28:59 -08002118bool SurfaceFlinger::handleMessageInvalidate() {
2119 ATRACE_CALL();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002120 bool refreshNeeded = handlePageFlip();
2121
Vishnu Nair4351ad52019-02-11 14:13:02 -08002122 if (mVisibleRegionsDirty) {
2123 computeLayerBounds();
2124 }
2125
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002126 for (auto& layer : mLayersPendingRefresh) {
2127 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002128 visibleReg.set(layer->getScreenBounds());
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002129 invalidateLayerStack(layer, visibleReg);
2130 }
2131 mLayersPendingRefresh.clear();
2132 return refreshNeeded;
Mathias Agopian4fec8732012-06-29 14:12:52 -07002133}
2134
Ana Krulece588e312018-09-18 12:32:24 -07002135void SurfaceFlinger::updateCompositorTiming(const DisplayStatInfo& stats, nsecs_t compositeTime,
2136 std::shared_ptr<FenceTime>& presentFenceTime) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002137 // Update queue of past composite+present times and determine the
2138 // most recently known composite to present latency.
David Sodman99974d22017-11-28 12:04:33 -08002139 getBE().mCompositePresentTimes.push({compositeTime, presentFenceTime});
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002140 nsecs_t compositeToPresentLatency = -1;
David Sodman99974d22017-11-28 12:04:33 -08002141 while (!getBE().mCompositePresentTimes.empty()) {
2142 SurfaceFlingerBE::CompositePresentTime& cpt = getBE().mCompositePresentTimes.front();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002143 // Cached values should have been updated before calling this method,
2144 // which helps avoid duplicate syscalls.
2145 nsecs_t displayTime = cpt.display->getCachedSignalTime();
2146 if (displayTime == Fence::SIGNAL_TIME_PENDING) {
2147 break;
2148 }
2149 compositeToPresentLatency = displayTime - cpt.composite;
David Sodman99974d22017-11-28 12:04:33 -08002150 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002151 }
2152
2153 // Don't let mCompositePresentTimes grow unbounded, just in case.
David Sodman99974d22017-11-28 12:04:33 -08002154 while (getBE().mCompositePresentTimes.size() > 16) {
2155 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002156 }
2157
Ana Krulece588e312018-09-18 12:32:24 -07002158 setCompositorTimingSnapped(stats, compositeToPresentLatency);
Brian Andersond0010582017-03-07 13:20:31 -08002159}
2160
Ana Krulece588e312018-09-18 12:32:24 -07002161void SurfaceFlinger::setCompositorTimingSnapped(const DisplayStatInfo& stats,
2162 nsecs_t compositeToPresentLatency) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002163 // Integer division and modulo round toward 0 not -inf, so we need to
2164 // treat negative and positive offsets differently.
Ady Abraham9e16a482019-12-03 17:19:41 -08002165 nsecs_t idealLatency = (mPhaseConfiguration->getCurrentOffsets().late.sf > 0)
2166 ? (stats.vsyncPeriod -
2167 (mPhaseConfiguration->getCurrentOffsets().late.sf % stats.vsyncPeriod))
2168 : ((-mPhaseConfiguration->getCurrentOffsets().late.sf) % stats.vsyncPeriod);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002169
Ady Abraham9e16a482019-12-03 17:19:41 -08002170 // Just in case mPhaseConfiguration->getCurrentOffsets().late.sf == -vsyncInterval.
Brian Andersond0010582017-03-07 13:20:31 -08002171 if (idealLatency <= 0) {
Ana Krulece588e312018-09-18 12:32:24 -07002172 idealLatency = stats.vsyncPeriod;
Brian Andersond0010582017-03-07 13:20:31 -08002173 }
2174
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002175 // Snap the latency to a value that removes scheduling jitter from the
2176 // composition and present times, which often have >1ms of jitter.
2177 // Reducing jitter is important if an app attempts to extrapolate
2178 // something (such as user input) to an accurate diasplay time.
Ady Abraham9e16a482019-12-03 17:19:41 -08002179 // Snapping also allows an app to precisely calculate
2180 // mPhaseConfiguration->getCurrentOffsets().late.sf with (presentLatency % interval).
Ana Krulece588e312018-09-18 12:32:24 -07002181 nsecs_t bias = stats.vsyncPeriod / 2;
2182 int64_t extraVsyncs = (compositeToPresentLatency - idealLatency + bias) / stats.vsyncPeriod;
2183 nsecs_t snappedCompositeToPresentLatency =
2184 (extraVsyncs > 0) ? idealLatency + (extraVsyncs * stats.vsyncPeriod) : idealLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002185
David Sodman99974d22017-11-28 12:04:33 -08002186 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
Ana Krulece588e312018-09-18 12:32:24 -07002187 getBE().mCompositorTiming.deadline = stats.vsyncTime - idealLatency;
2188 getBE().mCompositorTiming.interval = stats.vsyncPeriod;
David Sodman99974d22017-11-28 12:04:33 -08002189 getBE().mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002190}
2191
David Sodman2b406362017-12-15 13:33:47 -08002192void SurfaceFlinger::postComposition()
Mathias Agopiancd60f992012-08-16 16:28:27 -07002193{
Dan Stoza9e56aa02015-11-02 13:00:03 -08002194 ATRACE_CALL();
2195 ALOGV("postComposition");
2196
Brian Andersonf6386862016-10-31 16:34:13 -07002197 nsecs_t dequeueReadyTime = systemTime();
Brian Anderson3546a3f2016-07-14 11:51:14 -07002198 for (auto& layer : mLayersWithQueuedFrames) {
Brian Andersonf6386862016-10-31 16:34:13 -07002199 layer->releasePendingBuffer(dequeueReadyTime);
Brian Anderson3546a3f2016-07-14 11:51:14 -07002200 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07002201 // |mStateLock| not needed as we are on the main thread
Lloyd Pique32cbe282018-10-19 13:09:22 -07002202 const auto displayDevice = getDefaultDisplayDeviceLocked();
Brian Anderson3d4039d2016-09-23 16:31:30 -07002203
David Sodman73beded2017-11-15 11:56:06 -08002204 getBE().mGlCompositionDoneTimeline.updateSignalTimes();
Brian Anderson3d4039d2016-09-23 16:31:30 -07002205 std::shared_ptr<FenceTime> glCompositionDoneFenceTime;
Lloyd Pique66d68602019-02-13 14:23:31 -08002206 if (displayDevice && displayDevice->getCompositionDisplay()->getState().usesClientComposition) {
Brian Anderson3d4039d2016-09-23 16:31:30 -07002207 glCompositionDoneFenceTime =
Lloyd Pique31cb2942018-10-19 17:23:03 -07002208 std::make_shared<FenceTime>(displayDevice->getCompositionDisplay()
2209 ->getRenderSurface()
2210 ->getClientTargetAcquireFence());
David Sodman73beded2017-11-15 11:56:06 -08002211 getBE().mGlCompositionDoneTimeline.push(glCompositionDoneFenceTime);
Brian Anderson3d4039d2016-09-23 16:31:30 -07002212 } else {
2213 glCompositionDoneFenceTime = FenceTime::NO_FENCE;
2214 }
Brian Anderson3d4039d2016-09-23 16:31:30 -07002215
David Sodman73beded2017-11-15 11:56:06 -08002216 getBE().mDisplayTimeline.updateSignalTimes();
Ady Abrahambe0f9482019-04-24 15:41:53 -07002217 mPreviousPresentFences[1] = mPreviousPresentFences[0];
2218 mPreviousPresentFences[0] = displayDevice
2219 ? getHwComposer().getPresentFence(*displayDevice->getId())
2220 : Fence::NO_FENCE;
2221 auto presentFenceTime = std::make_shared<FenceTime>(mPreviousPresentFences[0]);
David Sodman73beded2017-11-15 11:56:06 -08002222 getBE().mDisplayTimeline.push(presentFenceTime);
Brian Anderson3d4039d2016-09-23 16:31:30 -07002223
Ana Krulece588e312018-09-18 12:32:24 -07002224 DisplayStatInfo stats;
Ana Krulecc2870422019-01-29 19:00:58 -08002225 mScheduler->getDisplayStatInfo(&stats);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002226
Lloyd Piqueab039b52019-02-13 14:22:42 -08002227 // We use the CompositionEngine::getLastFrameRefreshTimestamp() which might
2228 // be sampled a little later than when we started doing work for this frame,
2229 // but that should be okay since updateCompositorTiming has snapping logic.
2230 updateCompositorTiming(stats, mCompositionEngine->getLastFrameRefreshTimestamp(),
2231 presentFenceTime);
Brian Andersond0010582017-03-07 13:20:31 -08002232 CompositorTiming compositorTiming;
2233 {
David Sodman99974d22017-11-28 12:04:33 -08002234 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
2235 compositorTiming = getBE().mCompositorTiming;
Brian Andersond0010582017-03-07 13:20:31 -08002236 }
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002237
Edgar Arriaga844fa672020-01-16 14:21:42 -08002238 mDrawingState.traverse([&](Layer* layer) {
Adithya Srinivasanb69e0762019-11-11 18:39:53 -08002239 bool frameLatched = layer->onPostComposition(displayDevice, glCompositionDoneFenceTime,
2240 presentFenceTime, compositorTiming);
Dan Stozae77c7662016-05-13 11:37:28 -07002241 if (frameLatched) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07002242 recordBufferingStats(layer->getName(), layer->getOccupancyHistory(false));
Dan Stozae77c7662016-05-13 11:37:28 -07002243 }
Robert Carr2047fae2016-11-28 14:09:09 -08002244 });
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002245
Valerie Hau4b678442020-04-14 10:50:42 -07002246 mTransactionCompletedThread.addPresentFence(mPreviousPresentFences[0]);
2247 mTransactionCompletedThread.sendCallbacks();
2248
Ady Abraham92fa2f42020-02-11 15:33:56 -08002249 if (displayDevice && displayDevice->isPrimary() &&
Peiyong Lin65248e02020-04-18 21:15:07 -07002250 displayDevice->getPowerMode() == hal::PowerMode::ON && presentFenceTime->isValid()) {
Ana Krulecc2870422019-01-29 19:00:58 -08002251 mScheduler->addPresentFence(presentFenceTime);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07002252 }
2253
Fabien Sanglardcbf153b2017-03-10 17:57:12 -08002254 if (!hasSyncFramework) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07002255 if (displayDevice && getHwComposer().isConnected(*displayDevice->getId()) &&
2256 displayDevice->isPoweredOn()) {
Ana Krulecc2870422019-01-29 19:00:58 -08002257 mScheduler->enableHardwareVsync();
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07002258 }
2259 }
2260
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002261 if (mAnimCompositionPending) {
2262 mAnimCompositionPending = false;
2263
Brian Anderson4e606e32017-03-16 15:34:57 -07002264 if (presentFenceTime->isValid()) {
Brian Anderson3d4039d2016-09-23 16:31:30 -07002265 mAnimFrameTracker.setActualPresentFence(
Brian Anderson4e606e32017-03-16 15:34:57 -07002266 std::move(presentFenceTime));
Lloyd Pique32cbe282018-10-19 13:09:22 -07002267 } else if (displayDevice && getHwComposer().isConnected(*displayDevice->getId())) {
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002268 // The HWC doesn't support present fences, so use the refresh
2269 // timestamp instead.
Lloyd Pique32cbe282018-10-19 13:09:22 -07002270 const nsecs_t presentTime =
2271 getHwComposer().getRefreshTimestamp(*displayDevice->getId());
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002272 mAnimFrameTracker.setActualPresentTime(presentTime);
2273 }
2274 mAnimFrameTracker.advanceFrame();
2275 }
Dan Stozab90cf072015-03-05 11:05:59 -08002276
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002277 mTimeStats->incrementTotalFrames();
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07002278 if (mHadClientComposition) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002279 mTimeStats->incrementClientCompositionFrames();
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07002280 }
2281
Vishnu Nair9b079a22020-01-21 14:36:08 -08002282 if (mReusedClientComposition) {
2283 mTimeStats->incrementClientCompositionReusedFrames();
2284 }
2285
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002286 mTimeStats->setPresentFenceGlobal(presentFenceTime);
Yiwei Zhangce6ebc02018-10-20 12:42:38 -07002287
Alec Mouri717bcb62020-02-10 17:07:19 -08002288 const size_t sfConnections = mScheduler->getEventThreadConnectionCount(mSfConnectionHandle);
2289 const size_t appConnections = mScheduler->getEventThreadConnectionCount(mAppConnectionHandle);
2290 mTimeStats->recordDisplayEventConnectionCount(sfConnections + appConnections);
2291
Lloyd Pique32cbe282018-10-19 13:09:22 -07002292 if (displayDevice && getHwComposer().isConnected(*displayDevice->getId()) &&
2293 !displayDevice->isPoweredOn()) {
Dan Stozab90cf072015-03-05 11:05:59 -08002294 return;
2295 }
2296
2297 nsecs_t currentTime = systemTime();
2298 if (mHasPoweredOff) {
2299 mHasPoweredOff = false;
2300 } else {
David Sodman4a36e932017-11-07 14:29:47 -08002301 nsecs_t elapsedTime = currentTime - getBE().mLastSwapTime;
Ana Krulece588e312018-09-18 12:32:24 -07002302 size_t numPeriods = static_cast<size_t>(elapsedTime / stats.vsyncPeriod);
David Sodman4a36e932017-11-07 14:29:47 -08002303 if (numPeriods < SurfaceFlingerBE::NUM_BUCKETS - 1) {
2304 getBE().mFrameBuckets[numPeriods] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002305 } else {
David Sodman4a36e932017-11-07 14:29:47 -08002306 getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002307 }
David Sodman4a36e932017-11-07 14:29:47 -08002308 getBE().mTotalTime += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002309 }
David Sodman4a36e932017-11-07 14:29:47 -08002310 getBE().mLastSwapTime = currentTime;
Dan Stoza436ccf32018-06-21 12:10:12 -07002311
Alec Mouri4dde1782019-09-30 17:27:13 -07002312 // Cleanup any outstanding resources due to rendering a prior frame.
2313 getRenderEngine().cleanupPostRender();
2314
Dan Stoza436ccf32018-06-21 12:10:12 -07002315 {
2316 std::lock_guard lock(mTexturePoolMutex);
Dan Stoza67765d82019-05-07 14:58:27 -07002317 if (mTexturePool.size() < mTexturePoolSize) {
2318 const size_t refillCount = mTexturePoolSize - mTexturePool.size();
Dan Stoza436ccf32018-06-21 12:10:12 -07002319 const size_t offset = mTexturePool.size();
2320 mTexturePool.resize(mTexturePoolSize);
2321 getRenderEngine().genTextures(refillCount, mTexturePool.data() + offset);
2322 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Dan Stoza67765d82019-05-07 14:58:27 -07002323 } else if (mTexturePool.size() > mTexturePoolSize) {
2324 const size_t deleteCount = mTexturePool.size() - mTexturePoolSize;
2325 const size_t offset = mTexturePoolSize;
2326 getRenderEngine().deleteTextures(deleteCount, mTexturePool.data() + offset);
2327 mTexturePool.resize(mTexturePoolSize);
2328 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Dan Stoza436ccf32018-06-21 12:10:12 -07002329 }
2330 }
Marissa Walle2ffb422018-10-12 11:33:52 -07002331
Kevin DuBois413287f2019-02-25 08:46:47 -08002332 if (mLumaSampling && mRegionSamplingThread) {
2333 mRegionSamplingThread->notifyNewContent();
Dan Stozaec460082018-12-17 15:35:09 -08002334 }
Dan Stoza45de5ba2019-04-25 14:12:09 -07002335
2336 // Even though ATRACE_INT64 already checks if tracing is enabled, it doesn't prevent the
2337 // side-effect of getTotalSize(), so we check that again here
2338 if (ATRACE_ENABLED()) {
Marissa Wall22b2de12019-12-02 18:11:43 -08002339 // getTotalSize returns the total number of buffers that were allocated by SurfaceFlinger
Dan Stoza45de5ba2019-04-25 14:12:09 -07002340 ATRACE_INT64("Total Buffer Size", GraphicBufferAllocator::get().getTotalSize());
2341 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07002342}
2343
Lloyd Pique7eebe692020-04-22 22:40:06 -07002344FloatRect SurfaceFlinger::getLayerClipBoundsForDisplay(const DisplayDevice& displayDevice) const {
2345 return displayDevice.getViewport().toFloatRect();
2346}
2347
Vishnu Nair4351ad52019-02-11 14:13:02 -08002348void SurfaceFlinger::computeLayerBounds() {
2349 for (const auto& pair : mDisplays) {
2350 const auto& displayDevice = pair.second;
2351 const auto display = displayDevice->getCompositionDisplay();
2352 for (const auto& layer : mDrawingState.layersSortedByZ) {
2353 // only consider the layers on the given layer stack
2354 if (!display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
Vishnu Nair01ace762019-02-12 14:25:24 -08002355 continue;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002356 }
2357
Lloyd Pique7eebe692020-04-22 22:40:06 -07002358 layer->computeBounds(getLayerClipBoundsForDisplay(*displayDevice), ui::Transform(),
Vishnu Nairc97b8db2019-10-29 18:19:35 -07002359 0.f /* shadowRadius */);
Vishnu Nair4351ad52019-02-11 14:13:02 -08002360 }
2361 }
2362}
2363
David Sodmanfa9b2af2017-12-24 13:28:59 -08002364void SurfaceFlinger::postFrame()
2365{
2366 // |mStateLock| not needed as we are on the main thread
Dominik Laskowski075d3172018-05-24 15:50:06 -07002367 const auto display = getDefaultDisplayDeviceLocked();
2368 if (display && getHwComposer().isConnected(*display->getId())) {
2369 uint32_t flipCount = display->getPageFlipCount();
David Sodmanfa9b2af2017-12-24 13:28:59 -08002370 if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
2371 logFrameStats();
2372 }
2373 }
2374}
2375
Mathias Agopian87baae12012-07-31 12:38:26 -07002376void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002377{
Mathias Agopian841cde52012-03-01 15:44:37 -08002378 ATRACE_CALL();
2379
Mathias Agopian7cc6df52013-06-05 14:30:54 -07002380 // here we keep a copy of the drawing state (that is the state that's
2381 // going to be overwritten by handleTransactionLocked()) outside of
2382 // mStateLock so that the side-effects of the State assignment
2383 // don't happen with mStateLock held (which can cause deadlocks).
2384 State drawingState(mDrawingState);
2385
Mathias Agopianca4d3602011-05-19 15:38:14 -07002386 Mutex::Autolock _l(mStateLock);
Dominik Laskowski9dab3432019-03-27 13:21:10 -07002387 mDebugInTransaction = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002388
Mathias Agopianca4d3602011-05-19 15:38:14 -07002389 // Here we're guaranteed that some transaction flags are set
2390 // so we can call handleTransactionLocked() unconditionally.
2391 // We call getTransactionFlags(), which will also clear the flags,
2392 // with mStateLock held to guarantee that mCurrentState won't change
2393 // until the transaction is committed.
Mathias Agopian4da75192010-08-10 17:19:56 -07002394
Dominik Laskowskieddeda12019-07-19 11:54:13 -07002395 mVSyncModulator->onTransactionHandled();
Mathias Agopiane57f2922012-08-09 16:29:12 -07002396 transactionFlags = getTransactionFlags(eTransactionMask);
Mathias Agopian87baae12012-07-31 12:38:26 -07002397 handleTransactionLocked(transactionFlags);
Mathias Agopiandea20b12011-05-03 17:04:02 -07002398
Mathias Agopianca4d3602011-05-19 15:38:14 -07002399 mDebugInTransaction = 0;
2400 invalidateHwcGeometry();
2401 // here the transaction has been committed
Mathias Agopian3d579642009-06-04 18:46:21 -07002402}
2403
Lloyd Piqueba04e622017-12-14 17:11:26 -08002404void SurfaceFlinger::processDisplayHotplugEventsLocked() {
2405 for (const auto& event : mPendingHotplugEvents) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002406 const std::optional<DisplayIdentificationInfo> info =
2407 getHwComposer().onHotplug(event.hwcDisplayId, event.connection);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002408
Dominik Laskowski075d3172018-05-24 15:50:06 -07002409 if (!info) {
Lloyd Piqueba04e622017-12-14 17:11:26 -08002410 continue;
2411 }
2412
Dominik Laskowski55c85402020-01-21 16:25:47 -08002413 const DisplayId displayId = info->id;
2414 const auto it = mPhysicalDisplayTokens.find(displayId);
2415
Peiyong Line9d809e2020-04-14 13:10:48 -07002416 if (event.connection == hal::Connection::CONNECTED) {
Dominik Laskowski55c85402020-01-21 16:25:47 -08002417 if (it == mPhysicalDisplayTokens.end()) {
2418 ALOGV("Creating display %s", to_string(displayId).c_str());
2419
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002420 if (event.hwcDisplayId == getHwComposer().getInternalHwcDisplayId()) {
Dominik Laskowski55c85402020-01-21 16:25:47 -08002421 initScheduler(displayId);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002422 }
Dominik Laskowski55c85402020-01-21 16:25:47 -08002423
Dominik Laskowski075d3172018-05-24 15:50:06 -07002424 DisplayDeviceState state;
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002425 state.physical = {displayId, getHwComposer().getDisplayConnectionType(displayId),
2426 event.hwcDisplayId};
Dominik Laskowski075d3172018-05-24 15:50:06 -07002427 state.isSecure = true; // All physical displays are currently considered secure.
2428 state.displayName = info->name;
Dominik Laskowski55c85402020-01-21 16:25:47 -08002429
2430 sp<IBinder> token = new BBinder();
2431 mCurrentState.displays.add(token, state);
2432 mPhysicalDisplayTokens.emplace(displayId, std::move(token));
2433
Dominik Laskowski075d3172018-05-24 15:50:06 -07002434 mInterceptor->saveDisplayCreation(state);
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002435 } else {
2436 ALOGV("Recreating display %s", to_string(displayId).c_str());
2437
2438 const auto token = it->second;
2439 auto& state = mCurrentState.displays.editValueFor(token);
2440 state.sequenceId = DisplayDeviceState{}.sequenceId;
Steven Thomaseb6d2052018-03-20 15:40:48 -07002441 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08002442 } else {
Dominik Laskowski55c85402020-01-21 16:25:47 -08002443 ALOGV("Removing display %s", to_string(displayId).c_str());
Lloyd Piqueba04e622017-12-14 17:11:26 -08002444
Dominik Laskowski55c85402020-01-21 16:25:47 -08002445 const ssize_t index = mCurrentState.displays.indexOfKey(it->second);
Dominik Laskowski075d3172018-05-24 15:50:06 -07002446 if (index >= 0) {
2447 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
2448 mInterceptor->saveDisplayDeletion(state.sequenceId);
2449 mCurrentState.displays.removeItemsAt(index);
Lloyd Piquefcd86612017-12-14 17:15:36 -08002450 }
Dominik Laskowski55c85402020-01-21 16:25:47 -08002451 mPhysicalDisplayTokens.erase(it);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002452 }
2453
2454 processDisplayChangesLocked();
2455 }
2456
2457 mPendingHotplugEvents.clear();
2458}
2459
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002460void SurfaceFlinger::dispatchDisplayHotplugEvent(PhysicalDisplayId displayId, bool connected) {
Dominik Laskowski98041832019-08-01 18:35:59 -07002461 mScheduler->onHotplugReceived(mAppConnectionHandle, displayId, connected);
2462 mScheduler->onHotplugReceived(mSfConnectionHandle, displayId, connected);
Dominik Laskowski1eba0202019-01-24 09:14:40 -08002463}
2464
Lloyd Pique99d3da52018-01-22 17:48:03 -08002465sp<DisplayDevice> SurfaceFlinger::setupNewDisplayDeviceInternal(
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -07002466 const wp<IBinder>& displayToken,
2467 std::shared_ptr<compositionengine::Display> compositionDisplay,
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002468 const DisplayDeviceState& state,
2469 const sp<compositionengine::DisplaySurface>& displaySurface,
Dominik Laskowski075d3172018-05-24 15:50:06 -07002470 const sp<IGraphicBufferProducer>& producer) {
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -07002471 auto displayId = compositionDisplay->getDisplayId();
2472 DisplayDeviceCreationArgs creationArgs(this, displayToken, compositionDisplay);
Dominik Laskowskie9774092018-12-11 10:04:24 -08002473 creationArgs.sequenceId = state.sequenceId;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002474 creationArgs.isSecure = state.isSecure;
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002475 creationArgs.displaySurface = displaySurface;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002476 creationArgs.hasWideColorGamut = false;
2477 creationArgs.supportedPerFrameMetadata = 0;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002478
Dominik Laskowski55c85402020-01-21 16:25:47 -08002479 if (const auto& physical = state.physical) {
2480 creationArgs.connectionType = physical->type;
2481 }
2482
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002483 const bool isInternalDisplay = displayId && displayId == getInternalDisplayIdLocked();
Dominik Laskowski075d3172018-05-24 15:50:06 -07002484 creationArgs.isPrimary = isInternalDisplay;
2485
2486 if (useColorManagement && displayId) {
2487 std::vector<ColorMode> modes = getHwComposer().getColorModes(*displayId);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002488 for (ColorMode colorMode : modes) {
Peiyong Linfca547f2018-07-09 13:03:33 -07002489 if (isWideColorMode(colorMode)) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002490 creationArgs.hasWideColorGamut = true;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002491 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002492
Dominik Laskowski7e045462018-05-30 13:02:02 -07002493 std::vector<RenderIntent> renderIntents =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002494 getHwComposer().getRenderIntents(*displayId, colorMode);
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002495 creationArgs.hwcColorModes.emplace(colorMode, renderIntents);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002496 }
tangrobin6753a022018-08-10 10:58:54 +08002497 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002498
Dominik Laskowski075d3172018-05-24 15:50:06 -07002499 if (displayId) {
2500 getHwComposer().getHdrCapabilities(*displayId, &creationArgs.hdrCapabilities);
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002501 creationArgs.supportedPerFrameMetadata =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002502 getHwComposer().getSupportedPerFrameMetadata(*displayId);
Chia-I Wu0f509fb2018-06-21 15:52:50 +08002503 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002504
Lloyd Pique90c115d2018-09-18 21:39:42 -07002505 auto nativeWindowSurface = getFactory().createNativeWindowSurface(producer);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002506 auto nativeWindow = nativeWindowSurface->getNativeWindow();
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002507 creationArgs.nativeWindow = nativeWindow;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002508
Lloyd Pique99d3da52018-01-22 17:48:03 -08002509 // Make sure that composition can never be stalled by a virtual display
2510 // consumer that isn't processing buffers fast enough. We have to do this
Alec Mouri0a9c7b82018-11-16 13:05:25 -08002511 // here, in case the display is composed entirely by HWC.
Dominik Laskowski281644e2018-04-19 15:47:35 -07002512 if (state.isVirtual()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002513 nativeWindow->setSwapInterval(nativeWindow.get(), 0);
2514 }
2515
Dominik Laskowski718f9602019-11-09 20:01:35 -08002516 creationArgs.physicalOrientation =
2517 isInternalDisplay ? internalDisplayOrientation : ui::ROTATION_0;
Chia-I Wua02871c2018-08-27 14:38:23 -07002518
Lloyd Pique99d3da52018-01-22 17:48:03 -08002519 // virtual displays are always considered enabled
Peiyong Lin65248e02020-04-18 21:15:07 -07002520 creationArgs.initialPowerMode = state.isVirtual() ? hal::PowerMode::ON : hal::PowerMode::OFF;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002521
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -07002522 sp<DisplayDevice> display = getFactory().createDisplayDevice(creationArgs);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002523
2524 if (maxFrameBufferAcquiredBuffers >= 3) {
2525 nativeWindowSurface->preallocateBuffers();
2526 }
2527
2528 ColorMode defaultColorMode = ColorMode::NATIVE;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002529 Dataspace defaultDataSpace = Dataspace::UNKNOWN;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002530 if (display->hasWideColorGamut()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002531 defaultColorMode = ColorMode::SRGB;
Peiyong Lin14724e62018-12-05 07:27:30 -08002532 defaultDataSpace = Dataspace::V0_SRGB;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002533 }
Lloyd Pique6a3b4462019-03-07 20:58:12 -08002534 display->getCompositionDisplay()->setColorProfile(
2535 compositionengine::Output::ColorProfile{defaultColorMode, defaultDataSpace,
2536 RenderIntent::COLORIMETRIC,
2537 Dataspace::UNKNOWN});
Dominik Laskowski075d3172018-05-24 15:50:06 -07002538 if (!state.isVirtual()) {
2539 LOG_ALWAYS_FATAL_IF(!displayId);
Ady Abraham2139f732019-11-13 18:56:40 -08002540 auto activeConfigId = HwcConfigIndexType(getHwComposer().getActiveConfigIndex(*displayId));
2541 display->setActiveConfig(activeConfigId);
Lloyd Pique3c085a02018-05-09 19:38:32 -07002542 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07002543
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002544 display->setLayerStack(state.layerStack);
2545 display->setProjection(state.orientation, state.viewport, state.frame);
2546 display->setDisplayName(state.displayName);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002547
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002548 return display;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002549}
2550
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002551void SurfaceFlinger::processDisplayAdded(const wp<IBinder>& displayToken,
2552 const DisplayDeviceState& state) {
2553 int width = 0;
2554 int height = 0;
2555 ui::PixelFormat pixelFormat = static_cast<ui::PixelFormat>(PIXEL_FORMAT_UNKNOWN);
2556 if (state.physical) {
2557 const auto& activeConfig =
2558 getCompositionEngine().getHwComposer().getActiveConfig(state.physical->id);
2559 width = activeConfig->getWidth();
2560 height = activeConfig->getHeight();
2561 pixelFormat = static_cast<ui::PixelFormat>(PIXEL_FORMAT_RGBA_8888);
2562 } else if (state.surface != nullptr) {
2563 int status = state.surface->query(NATIVE_WINDOW_WIDTH, &width);
2564 ALOGE_IF(status != NO_ERROR, "Unable to query width (%d)", status);
2565 status = state.surface->query(NATIVE_WINDOW_HEIGHT, &height);
2566 ALOGE_IF(status != NO_ERROR, "Unable to query height (%d)", status);
2567 int intPixelFormat;
2568 status = state.surface->query(NATIVE_WINDOW_FORMAT, &intPixelFormat);
2569 ALOGE_IF(status != NO_ERROR, "Unable to query format (%d)", status);
2570 pixelFormat = static_cast<ui::PixelFormat>(intPixelFormat);
2571 } else {
2572 // Virtual displays without a surface are dormant:
2573 // they have external state (layer stack, projection,
2574 // etc.) but no internal state (i.e. a DisplayDevice).
2575 return;
2576 }
2577
2578 compositionengine::DisplayCreationArgsBuilder builder;
2579 if (const auto& physical = state.physical) {
2580 builder.setPhysical({physical->id, physical->type});
2581 }
2582 builder.setPixels(ui::Size(width, height));
2583 builder.setPixelFormat(pixelFormat);
2584 builder.setIsSecure(state.isSecure);
2585 builder.setLayerStackId(state.layerStack);
2586 builder.setPowerAdvisor(&mPowerAdvisor);
2587 builder.setUseHwcVirtualDisplays(mUseHwcVirtualDisplays || getHwComposer().isUsingVrComposer());
2588 builder.setName(state.displayName);
2589 const auto compositionDisplay = getCompositionEngine().createDisplay(builder.build());
2590
2591 sp<compositionengine::DisplaySurface> displaySurface;
2592 sp<IGraphicBufferProducer> producer;
2593 sp<IGraphicBufferProducer> bqProducer;
2594 sp<IGraphicBufferConsumer> bqConsumer;
2595 getFactory().createBufferQueue(&bqProducer, &bqConsumer, /*consumerIsSurfaceFlinger =*/false);
2596
2597 std::optional<DisplayId> displayId = compositionDisplay->getId();
2598
2599 if (state.isVirtual()) {
2600 sp<VirtualDisplaySurface> vds =
2601 new VirtualDisplaySurface(getHwComposer(), displayId, state.surface, bqProducer,
2602 bqConsumer, state.displayName);
2603
2604 displaySurface = vds;
2605 producer = vds;
2606 } else {
2607 ALOGE_IF(state.surface != nullptr,
2608 "adding a supported display, but rendering "
2609 "surface is provided (%p), ignoring it",
2610 state.surface.get());
2611
2612 LOG_ALWAYS_FATAL_IF(!displayId);
2613 displaySurface = new FramebufferSurface(getHwComposer(), *displayId, bqConsumer,
2614 maxGraphicsWidth, maxGraphicsHeight);
2615 producer = bqProducer;
2616 }
2617
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002618 LOG_FATAL_IF(!displaySurface);
2619 const auto display = setupNewDisplayDeviceInternal(displayToken, compositionDisplay, state,
2620 displaySurface, producer);
2621 mDisplays.emplace(displayToken, display);
2622 if (!state.isVirtual()) {
2623 LOG_FATAL_IF(!displayId);
2624 dispatchDisplayHotplugEvent(displayId->value, true);
2625 }
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002626
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002627 if (display->isPrimary()) {
2628 mScheduler->onPrimaryDisplayAreaChanged(display->getWidth() * display->getHeight());
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002629 }
2630}
2631
2632void SurfaceFlinger::processDisplayRemoved(const wp<IBinder>& displayToken) {
2633 if (const auto display = getDisplayDeviceLocked(displayToken)) {
2634 // Save display ID before disconnecting.
2635 const auto displayId = display->getId();
2636 display->disconnect();
2637
2638 if (!display->isVirtual()) {
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002639 LOG_FATAL_IF(!displayId);
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002640 dispatchDisplayHotplugEvent(displayId->value, false);
2641 }
2642 }
2643
2644 mDisplays.erase(displayToken);
2645}
2646
2647void SurfaceFlinger::processDisplayChanged(const wp<IBinder>& displayToken,
2648 const DisplayDeviceState& currentState,
2649 const DisplayDeviceState& drawingState) {
2650 const sp<IBinder> currentBinder = IInterface::asBinder(currentState.surface);
2651 const sp<IBinder> drawingBinder = IInterface::asBinder(drawingState.surface);
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002652 if (currentBinder != drawingBinder || currentState.sequenceId != drawingState.sequenceId) {
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002653 // changing the surface is like destroying and recreating the DisplayDevice
2654 if (const auto display = getDisplayDeviceLocked(displayToken)) {
2655 display->disconnect();
2656 }
2657 mDisplays.erase(displayToken);
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002658 if (const auto& physical = currentState.physical) {
2659 getHwComposer().allocatePhysicalDisplay(physical->hwcDisplayId, physical->id);
2660 }
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002661 processDisplayAdded(displayToken, currentState);
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002662 if (currentState.physical) {
2663 initializeDisplays();
2664 }
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002665 return;
2666 }
2667
2668 if (const auto display = getDisplayDeviceLocked(displayToken)) {
2669 if (currentState.layerStack != drawingState.layerStack) {
2670 display->setLayerStack(currentState.layerStack);
2671 }
2672 if ((currentState.orientation != drawingState.orientation) ||
2673 (currentState.viewport != drawingState.viewport) ||
2674 (currentState.frame != drawingState.frame)) {
2675 display->setProjection(currentState.orientation, currentState.viewport,
2676 currentState.frame);
2677 }
2678 if (currentState.width != drawingState.width ||
2679 currentState.height != drawingState.height) {
2680 display->setDisplaySize(currentState.width, currentState.height);
2681 if (display->isPrimary()) {
2682 mScheduler->onPrimaryDisplayAreaChanged(currentState.width * currentState.height);
2683 }
2684 }
2685 }
2686}
2687
Lloyd Pique347200f2017-12-14 17:00:15 -08002688void SurfaceFlinger::processDisplayChangesLocked() {
2689 // here we take advantage of Vector's copy-on-write semantics to
2690 // improve performance by skipping the transaction entirely when
2691 // know that the lists are identical
2692 const KeyedVector<wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
2693 const KeyedVector<wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
2694 if (!curr.isIdenticalTo(draw)) {
2695 mVisibleRegionsDirty = true;
Lloyd Pique347200f2017-12-14 17:00:15 -08002696
2697 // find the displays that were removed
2698 // (ie: in drawing state but not in current state)
2699 // also handle displays that changed
2700 // (ie: displays that are in both lists)
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002701 for (size_t i = 0; i < draw.size(); i++) {
2702 const wp<IBinder>& displayToken = draw.keyAt(i);
2703 const ssize_t j = curr.indexOfKey(displayToken);
Lloyd Pique347200f2017-12-14 17:00:15 -08002704 if (j < 0) {
2705 // in drawing state but not in current state
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002706 processDisplayRemoved(displayToken);
Lloyd Pique347200f2017-12-14 17:00:15 -08002707 } else {
2708 // this display is in both lists. see if something changed.
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002709 const DisplayDeviceState& currentState = curr[j];
2710 const DisplayDeviceState& drawingState = draw[i];
2711 processDisplayChanged(displayToken, currentState, drawingState);
Lloyd Pique347200f2017-12-14 17:00:15 -08002712 }
Lloyd Pique347200f2017-12-14 17:00:15 -08002713 }
2714
2715 // find displays that were added
2716 // (ie: in current state but not in drawing state)
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002717 for (size_t i = 0; i < curr.size(); i++) {
2718 const wp<IBinder>& displayToken = curr.keyAt(i);
2719 if (draw.indexOfKey(displayToken) < 0) {
2720 processDisplayAdded(displayToken, curr[i]);
Lloyd Pique347200f2017-12-14 17:00:15 -08002721 }
2722 }
2723 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08002724
2725 mDrawingState.displays = mCurrentState.displays;
Lloyd Pique347200f2017-12-14 17:00:15 -08002726}
2727
Mathias Agopian87baae12012-07-31 12:38:26 -07002728void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
Mathias Agopian3d579642009-06-04 18:46:21 -07002729{
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07002730 const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
2731
Dan Stoza7dde5992015-05-22 09:51:44 -07002732 // Notify all layers of available frames
Edgar Arriaga844fa672020-01-16 14:21:42 -08002733 mCurrentState.traverse([expectedPresentTime](Layer* layer) {
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07002734 layer->notifyAvailableFrames(expectedPresentTime);
Robert Carr2047fae2016-11-28 14:09:09 -08002735 });
Dan Stoza7dde5992015-05-22 09:51:44 -07002736
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002737 /*
2738 * Traversal of the children
2739 * (perform the transaction for each of them if needed)
2740 */
2741
Marissa Wall06255332019-03-27 13:48:27 -07002742 if ((transactionFlags & eTraversalNeeded) || mTraversalNeededMainThread) {
Edgar Arriaga844fa672020-01-16 14:21:42 -08002743 mCurrentState.traverse([&](Layer* layer) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002744 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
Robert Carr2047fae2016-11-28 14:09:09 -08002745 if (!trFlags) return;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002746
2747 const uint32_t flags = layer->doTransaction(0);
2748 if (flags & Layer::eVisibleRegion)
2749 mVisibleRegionsDirty = true;
Robert Carr720e5062018-07-30 17:45:14 -07002750
2751 if (flags & Layer::eInputInfoChanged) {
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002752 mInputInfoChanged = true;
Robert Carr720e5062018-07-30 17:45:14 -07002753 }
Robert Carr2047fae2016-11-28 14:09:09 -08002754 });
Marissa Wall06255332019-03-27 13:48:27 -07002755 mTraversalNeededMainThread = false;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002756 }
2757
2758 /*
Mathias Agopian3559b072012-08-15 13:46:03 -07002759 * Perform display own transactions if needed
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002760 */
2761
Mathias Agopiane57f2922012-08-09 16:29:12 -07002762 if (transactionFlags & eDisplayTransactionNeeded) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002763 processDisplayChangesLocked();
Lloyd Piqueba04e622017-12-14 17:11:26 -08002764 processDisplayHotplugEventsLocked();
Mathias Agopian3559b072012-08-15 13:46:03 -07002765 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002766
Vishnu Nair6213bd92020-05-08 17:42:25 -07002767 if (transactionFlags & (eTransformHintUpdateNeeded | eDisplayTransactionNeeded)) {
Mathias Agopian84300952012-11-21 16:02:13 -08002768 // The transform hint might have changed for some layers
2769 // (either because a display has changed, or because a layer
2770 // as changed).
2771 //
2772 // Walk through all the layers in currentLayers,
2773 // and update their transform hint.
2774 //
2775 // If a layer is visible only on a single display, then that
2776 // display is used to calculate the hint, otherwise we use the
2777 // default display.
2778 //
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002779 // NOTE: we do this here, rather than when presenting the display so that
Mathias Agopian84300952012-11-21 16:02:13 -08002780 // the hint is set before we acquire a buffer from the surface texture.
2781 //
2782 // NOTE: layer transactions have taken place already, so we use their
2783 // drawing state. However, SurfaceFlinger's own transaction has not
2784 // happened yet, so we must use the current state layer list
2785 // (soon to become the drawing state list).
2786 //
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002787 sp<const DisplayDevice> hintDisplay;
Mathias Agopian84300952012-11-21 16:02:13 -08002788 uint32_t currentlayerStack = 0;
Robert Carr2047fae2016-11-28 14:09:09 -08002789 bool first = true;
Edgar Arriaga844fa672020-01-16 14:21:42 -08002790 mCurrentState.traverse([&](Layer* layer) {
Mathias Agopian84300952012-11-21 16:02:13 -08002791 // NOTE: we rely on the fact that layers are sorted by
2792 // layerStack first (so we don't have to traverse the list
2793 // of displays for every layer).
Robert Carr1f0a16a2016-10-24 16:27:39 -07002794 uint32_t layerStack = layer->getLayerStack();
Robert Carr2047fae2016-11-28 14:09:09 -08002795 if (first || currentlayerStack != layerStack) {
Mathias Agopian84300952012-11-21 16:02:13 -08002796 currentlayerStack = layerStack;
2797 // figure out if this layerstack is mirrored
2798 // (more than one display) if so, pick the default display,
2799 // if not, pick the only display it's on.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002800 hintDisplay = nullptr;
2801 for (const auto& [token, display] : mDisplays) {
Lloyd Piqueef36b002019-01-23 17:52:04 -08002802 if (display->getCompositionDisplay()
2803 ->belongsInOutput(layer->getLayerStack(),
2804 layer->getPrimaryDisplayOnly())) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002805 if (hintDisplay) {
2806 hintDisplay = nullptr;
Mathias Agopian84300952012-11-21 16:02:13 -08002807 break;
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002808 } else {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002809 hintDisplay = display;
Mathias Agopian84300952012-11-21 16:02:13 -08002810 }
2811 }
2812 }
2813 }
Chet Haase91d25932013-04-11 15:24:55 -07002814
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002815 if (!hintDisplay) {
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002816 // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
2817 // redraw after transform hint changes. See bug 8508397.
Robert Carr56a0b9a2017-12-04 16:06:13 -08002818
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002819 // could be null when this layer is using a layerStack
2820 // that is not visible on any display. Also can occur at
2821 // screen off/on times.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002822 hintDisplay = getDefaultDisplayDeviceLocked();
Mathias Agopian84300952012-11-21 16:02:13 -08002823 }
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002824
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002825 // could be null if there is no display available at all to get
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002826 // the transform hint from.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002827 if (hintDisplay) {
2828 layer->updateTransformHint(hintDisplay);
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08002829 }
Robert Carr2047fae2016-11-28 14:09:09 -08002830
2831 first = false;
2832 });
Mathias Agopian84300952012-11-21 16:02:13 -08002833 }
2834
Mathias Agopian3559b072012-08-15 13:46:03 -07002835 /*
2836 * Perform our own transaction if needed
2837 */
Robert Carr1f0a16a2016-10-24 16:27:39 -07002838
2839 if (mLayersAdded) {
2840 mLayersAdded = false;
2841 // Layers have been added.
Mathias Agopian3559b072012-08-15 13:46:03 -07002842 mVisibleRegionsDirty = true;
2843 }
2844
2845 // some layers might have been removed, so
2846 // we need to update the regions they're exposing.
2847 if (mLayersRemoved) {
2848 mLayersRemoved = false;
2849 mVisibleRegionsDirty = true;
Robert Carr2047fae2016-11-28 14:09:09 -08002850 mDrawingState.traverseInZOrder([&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07002851 if (mLayersPendingRemoval.indexOf(layer) >= 0) {
Mathias Agopian3559b072012-08-15 13:46:03 -07002852 // this layer is not visible anymore
Robert Carr1f0a16a2016-10-24 16:27:39 -07002853 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002854 visibleReg.set(layer->getScreenBounds());
Chia-I Wuab0c3192017-08-01 11:29:00 -07002855 invalidateLayerStack(layer, visibleReg);
Mathias Agopian0aa758d2009-04-22 15:23:34 -07002856 }
Robert Carr2047fae2016-11-28 14:09:09 -08002857 });
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002858 }
2859
Vishnu Nairec0ab382019-02-13 15:32:56 -08002860 commitInputWindowCommands();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002861 commitTransaction();
Riley Andrews03414a12014-07-01 14:22:59 -07002862}
2863
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002864void SurfaceFlinger::updateInputFlinger() {
Robert Carr720e5062018-07-30 17:45:14 -07002865 ATRACE_CALL();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002866 if (!mInputFlinger) {
Vishnu Nairde19f852018-12-18 16:11:53 -08002867 return;
2868 }
2869
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002870 if (mVisibleRegionsDirty || mInputInfoChanged) {
2871 mInputInfoChanged = false;
2872 updateInputWindowInfo();
chaviw95ef3c42019-02-14 10:55:09 -08002873 } else if (mInputWindowCommands.syncInputWindows) {
2874 // If the caller requested to sync input windows, but there are no
2875 // changes to input windows, notify immediately.
2876 setInputWindowsFinished();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002877 }
2878
Arthur Hung6cbb9752019-09-05 16:38:18 +08002879 mInputWindowCommands.clear();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002880}
2881
2882void SurfaceFlinger::updateInputWindowInfo() {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002883 std::vector<InputWindowInfo> inputHandles;
Robert Carr720e5062018-07-30 17:45:14 -07002884
2885 mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
2886 if (layer->hasInput()) {
Vishnu Nair51625fa2018-12-06 13:54:33 -08002887 // When calculating the screen bounds we ignore the transparent region since it may
2888 // result in an unwanted offset.
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002889 inputHandles.push_back(layer->fillInputInfo());
Robert Carr720e5062018-07-30 17:45:14 -07002890 }
2891 });
chaviw291d88a2019-02-14 10:33:58 -08002892
2893 mInputFlinger->setInputWindows(inputHandles,
2894 mInputWindowCommands.syncInputWindows ? mSetInputWindowsListener
2895 : nullptr);
Robert Carr720e5062018-07-30 17:45:14 -07002896}
2897
Vishnu Nairec0ab382019-02-13 15:32:56 -08002898void SurfaceFlinger::commitInputWindowCommands() {
Rob Carr9a2cc992020-03-06 12:44:45 -08002899 mInputWindowCommands.merge(mPendingInputWindowCommands);
Vishnu Nairec0ab382019-02-13 15:32:56 -08002900 mPendingInputWindowCommands.clear();
2901}
2902
Riley Andrews03414a12014-07-01 14:22:59 -07002903void SurfaceFlinger::updateCursorAsync()
2904{
Lloyd Piquec7b0c752019-03-07 20:59:59 -08002905 compositionengine::CompositionRefreshArgs refreshArgs;
2906 for (const auto& [_, display] : mDisplays) {
2907 if (display->getId()) {
2908 refreshArgs.outputs.push_back(display->getCompositionDisplay());
Riley Andrews03414a12014-07-01 14:22:59 -07002909 }
2910 }
Lloyd Piquec7b0c752019-03-07 20:59:59 -08002911
2912 mCompositionEngine->updateCursorAsync(refreshArgs);
Mathias Agopian4fec8732012-06-29 14:12:52 -07002913}
2914
Ady Abraham2139f732019-11-13 18:56:40 -08002915void SurfaceFlinger::changeRefreshRate(const RefreshRate& refreshRate,
Ady Abraham8a82ba62020-01-17 12:43:17 -08002916 Scheduler::ConfigEvent event) NO_THREAD_SAFETY_ANALYSIS {
2917 // If this is called from the main thread mStateLock must be locked before
2918 // Currently the only way to call this function from the main thread is from
2919 // Sheduler::chooseRefreshRateForContent
2920
2921 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
Ady Abraham2139f732019-11-13 18:56:40 -08002922 changeRefreshRateLocked(refreshRate, event);
2923}
2924
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002925void SurfaceFlinger::initScheduler(DisplayId primaryDisplayId) {
2926 if (mScheduler) {
2927 // In practice it's not allowed to hotplug in/out the primary display once it's been
2928 // connected during startup, but some tests do it, so just warn and return.
2929 ALOGW("Can't re-init scheduler");
2930 return;
2931 }
2932
Ady Abraham2139f732019-11-13 18:56:40 -08002933 auto currentConfig = HwcConfigIndexType(getHwComposer().getActiveConfigIndex(primaryDisplayId));
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002934 mRefreshRateConfigs =
Ana Krulec3f6a2062020-01-23 15:48:01 -08002935 std::make_unique<scheduler::RefreshRateConfigs>(getHwComposer().getConfigs(
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002936 primaryDisplayId),
2937 currentConfig);
2938 mRefreshRateStats =
2939 std::make_unique<scheduler::RefreshRateStats>(*mRefreshRateConfigs, *mTimeStats,
Peiyong Lin65248e02020-04-18 21:15:07 -07002940 currentConfig, hal::PowerMode::OFF);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002941 mRefreshRateStats->setConfigMode(currentConfig);
2942
Ady Abraham9e16a482019-12-03 17:19:41 -08002943 mPhaseConfiguration = getFactory().createPhaseConfiguration(*mRefreshRateConfigs);
2944
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002945 // start the EventThread
2946 mScheduler =
2947 getFactory().createScheduler([this](bool enabled) { setPrimaryVsyncEnabled(enabled); },
Ady Abraham3a77a7b2019-12-02 18:46:59 -08002948 *mRefreshRateConfigs, *this);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002949 mAppConnectionHandle =
Ady Abraham9e16a482019-12-03 17:19:41 -08002950 mScheduler->createConnection("app", mPhaseConfiguration->getCurrentOffsets().late.app,
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002951 impl::EventThread::InterceptVSyncsCallback());
2952 mSfConnectionHandle =
Ady Abraham9e16a482019-12-03 17:19:41 -08002953 mScheduler->createConnection("sf", mPhaseConfiguration->getCurrentOffsets().late.sf,
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002954 [this](nsecs_t timestamp) {
2955 mInterceptor->saveVSyncEvent(timestamp);
2956 });
2957
2958 mEventQueue->setEventConnection(mScheduler->getEventConnection(mSfConnectionHandle));
2959 mVSyncModulator.emplace(*mScheduler, mAppConnectionHandle, mSfConnectionHandle,
Ady Abraham9e16a482019-12-03 17:19:41 -08002960 mPhaseConfiguration->getCurrentOffsets());
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002961
2962 mRegionSamplingThread =
2963 new RegionSamplingThread(*this, *mScheduler,
2964 RegionSamplingThread::EnvironmentTimingTunables());
Alec Mouri60aee1c2019-10-28 16:18:59 -07002965 // Dispatch a config change request for the primary display on scheduler
2966 // initialization, so that the EventThreads always contain a reference to a
2967 // prior configuration.
2968 //
2969 // This is a bit hacky, but this avoids a back-pointer into the main SF
2970 // classes from EventThread, and there should be no run-time binder cost
2971 // anyway since there are no connected apps at this point.
2972 const nsecs_t vsyncPeriod =
Ady Abrahamabc27602020-04-08 17:20:29 -07002973 mRefreshRateConfigs->getRefreshRateFromConfigId(currentConfig).getVsyncPeriod();
Alec Mouri60aee1c2019-10-28 16:18:59 -07002974 mScheduler->onConfigChanged(mAppConnectionHandle, primaryDisplayId.value, currentConfig,
2975 vsyncPeriod);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002976}
2977
Mathias Agopian4fec8732012-06-29 14:12:52 -07002978void SurfaceFlinger::commitTransaction()
2979{
Vishnu Nair60db8c02020-04-02 11:55:16 -07002980 commitTransactionLocked();
Jamie Gennis2d5e2302012-10-15 18:24:43 -07002981 mTransactionPending = false;
2982 mAnimTransactionPending = false;
Mathias Agopian4fec8732012-06-29 14:12:52 -07002983 mTransactionCV.broadcast();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002984}
2985
Lloyd Pique58e24a32019-08-01 15:50:14 -07002986void SurfaceFlinger::commitTransactionLocked() {
2987 if (!mLayersPendingRemoval.isEmpty()) {
2988 // Notify removed layers now that they can't be drawn from
2989 for (const auto& l : mLayersPendingRemoval) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07002990 recordBufferingStats(l->getName(), l->getOccupancyHistory(true));
Lloyd Pique58e24a32019-08-01 15:50:14 -07002991
2992 // Ensure any buffers set to display on any children are released.
2993 if (l->isRemovedFromCurrentState()) {
2994 l->latchAndReleaseBuffer();
2995 }
2996
2997 // If the layer has been removed and has no parent, then it will not be reachable
2998 // when traversing layers on screen. Add the layer to the offscreenLayers set to
2999 // ensure we can copy its current to drawing state.
3000 if (!l->getParent()) {
3001 mOffscreenLayers.emplace(l.get());
3002 }
3003 }
3004 mLayersPendingRemoval.clear();
3005 }
3006
3007 // If this transaction is part of a window animation then the next frame
3008 // we composite should be considered an animation as well.
3009 mAnimCompositionPending = mAnimTransactionPending;
3010
3011 mDrawingState = mCurrentState;
3012 // clear the "changed" flags in current state
3013 mCurrentState.colorMatrixChanged = false;
3014
Edgar Arriaga844fa672020-01-16 14:21:42 -08003015 mDrawingState.traverse([&](Layer* layer) {
Lloyd Pique58e24a32019-08-01 15:50:14 -07003016 layer->commitChildList();
3017
3018 // If the layer can be reached when traversing mDrawingState, then the layer is no
3019 // longer offscreen. Remove the layer from the offscreenLayer set.
3020 if (mOffscreenLayers.count(layer)) {
3021 mOffscreenLayers.erase(layer);
3022 }
3023 });
3024
3025 commitOffscreenLayers();
Edgar Arriaga844fa672020-01-16 14:21:42 -08003026 mDrawingState.traverse([&](Layer* layer) { layer->updateMirrorInfo(); });
Lloyd Pique58e24a32019-08-01 15:50:14 -07003027}
3028
chaviw74d90ad2019-04-26 14:45:26 -07003029void SurfaceFlinger::commitOffscreenLayers() {
3030 for (Layer* offscreenLayer : mOffscreenLayers) {
Edgar Arriaga844fa672020-01-16 14:21:42 -08003031 offscreenLayer->traverse(LayerVector::StateSet::Drawing, [](Layer* layer) {
chaviw74d90ad2019-04-26 14:45:26 -07003032 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
3033 if (!trFlags) return;
3034
3035 layer->doTransaction(0);
3036 layer->commitChildList();
3037 });
3038 }
3039}
3040
Chia-I Wuab0c3192017-08-01 11:29:00 -07003041void SurfaceFlinger::invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003042 for (const auto& [token, displayDevice] : mDisplays) {
3043 auto display = displayDevice->getCompositionDisplay();
Lloyd Piqueef36b002019-01-23 17:52:04 -08003044 if (display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003045 display->editState().dirtyRegion.orSelf(dirty);
Mathias Agopian92a979a2012-08-02 18:32:23 -07003046 }
3047 }
Mathias Agopian87baae12012-07-31 12:38:26 -07003048}
3049
Dan Stoza6b9454d2014-11-07 16:00:59 -08003050bool SurfaceFlinger::handlePageFlip()
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003051{
Ady Abraham09bd3922019-04-08 10:44:56 -07003052 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08003053 ALOGV("handlePageFlip");
3054
Brian Andersond6927fb2016-07-23 23:37:30 -07003055 nsecs_t latchTime = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003056
Mathias Agopian4fec8732012-06-29 14:12:52 -07003057 bool visibleRegions = false;
Dan Stoza6b9454d2014-11-07 16:00:59 -08003058 bool frameQueued = false;
Mike Stroyan0cd76192017-04-20 12:10:48 -06003059 bool newDataLatched = false;
Eric Penner51c59cd2014-07-28 19:51:58 -07003060
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003061 const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
3062
Eric Penner51c59cd2014-07-28 19:51:58 -07003063 // Store the set of layers that need updates. This set must not change as
3064 // buffers are being latched, as this could result in a deadlock.
3065 // Example: Two producers share the same command stream and:
3066 // 1.) Layer 0 is latched
3067 // 2.) Layer 0 gets a new frame
3068 // 2.) Layer 1 gets a new frame
3069 // 3.) Layer 1 is latched.
3070 // Display is now waiting on Layer 1's frame, which is behind layer 0's
3071 // second frame. But layer 0's second frame could be waiting on display.
Edgar Arriaga844fa672020-01-16 14:21:42 -08003072 mDrawingState.traverse([&](Layer* layer) {
Marissa Wallfd668622018-05-10 10:21:13 -07003073 if (layer->hasReadyFrame()) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08003074 frameQueued = true;
Ana Krulec010d2192018-10-08 06:29:54 -07003075 if (layer->shouldPresentNow(expectedPresentTime)) {
Robert Carr2047fae2016-11-28 14:09:09 -08003076 mLayersWithQueuedFrames.push_back(layer);
Dan Stozaee44edd2015-03-23 15:50:23 -07003077 } else {
Ady Abraham09bd3922019-04-08 10:44:56 -07003078 ATRACE_NAME("!layer->shouldPresentNow()");
Dan Stozaee44edd2015-03-23 15:50:23 -07003079 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08003080 }
Dan Stozaee44edd2015-03-23 15:50:23 -07003081 } else {
3082 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08003083 }
Robert Carr2047fae2016-11-28 14:09:09 -08003084 });
3085
chaviw49a108c2019-08-12 11:23:06 -07003086 // The client can continue submitting buffers for offscreen layers, but they will not
3087 // be shown on screen. Therefore, we need to latch and release buffers of offscreen
3088 // layers to ensure dequeueBuffer doesn't block indefinitely.
3089 for (Layer* offscreenLayer : mOffscreenLayers) {
Edgar Arriaga844fa672020-01-16 14:21:42 -08003090 offscreenLayer->traverse(LayerVector::StateSet::Drawing,
chaviw49a108c2019-08-12 11:23:06 -07003091 [&](Layer* l) { l->latchAndReleaseBuffer(); });
3092 }
3093
Lloyd Piquef2c79392018-12-20 16:23:33 -08003094 if (!mLayersWithQueuedFrames.empty()) {
3095 // mStateLock is needed for latchBuffer as LayerRejecter::reject()
3096 // writes to Layer current state. See also b/119481871
3097 Mutex::Autolock lock(mStateLock);
3098
3099 for (auto& layer : mLayersWithQueuedFrames) {
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003100 if (layer->latchBuffer(visibleRegions, latchTime, expectedPresentTime)) {
Vishnu Nair6194e2e2019-02-06 12:58:39 -08003101 mLayersPendingRefresh.push_back(layer);
3102 }
Lloyd Piquef2c79392018-12-20 16:23:33 -08003103 layer->useSurfaceDamage();
Lloyd Piquef2c79392018-12-20 16:23:33 -08003104 if (layer->isBufferLatched()) {
3105 newDataLatched = true;
3106 }
Mike Stroyan0cd76192017-04-20 12:10:48 -06003107 }
Mathias Agopian4fec8732012-06-29 14:12:52 -07003108 }
Mathias Agopian4da75192010-08-10 17:19:56 -07003109
Mathias Agopian3b1d2b62012-07-11 13:48:17 -07003110 mVisibleRegionsDirty |= visibleRegions;
Dan Stoza6b9454d2014-11-07 16:00:59 -08003111
3112 // If we will need to wake up at some time in the future to deal with a
3113 // queued frame that shouldn't be displayed during this vsync period, wake
3114 // up during the next vsync period to check again.
Chia-I Wua36bf922017-06-30 12:51:05 -07003115 if (frameQueued && (mLayersWithQueuedFrames.empty() || !newDataLatched)) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08003116 signalLayerUpdate();
3117 }
3118
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08003119 // enter boot animation on first buffer latch
3120 if (CC_UNLIKELY(mBootStage == BootStage::BOOTLOADER && newDataLatched)) {
3121 ALOGI("Enter boot animation");
3122 mBootStage = BootStage::BOOTANIMATION;
3123 }
3124
Edgar Arriaga844fa672020-01-16 14:21:42 -08003125 mDrawingState.traverse([&](Layer* layer) { layer->updateCloneBufferInfo(); });
chaviw74b03172019-08-19 11:09:03 -07003126
Dan Stoza6b9454d2014-11-07 16:00:59 -08003127 // Only continue with the refresh if there is actually new work to do
Mike Stroyan0cd76192017-04-20 12:10:48 -06003128 return !mLayersWithQueuedFrames.empty() && newDataLatched;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003129}
3130
Mathias Agopianad456f92011-01-13 17:53:01 -08003131void SurfaceFlinger::invalidateHwcGeometry()
3132{
Dan Stoza9e56aa02015-11-02 13:00:03 -08003133 mGeometryInvalid = true;
Mathias Agopianad456f92011-01-13 17:53:01 -08003134}
3135
Robert Carrc0df3122019-04-11 13:18:21 -07003136status_t SurfaceFlinger::addClientLayer(const sp<Client>& client, const sp<IBinder>& handle,
3137 const sp<IGraphicBufferProducer>& gbc, const sp<Layer>& lbc,
3138 const sp<IBinder>& parentHandle,
Vishnu Nair6213bd92020-05-08 17:42:25 -07003139 const sp<Layer>& parentLayer, bool addToCurrentState,
3140 uint32_t* outTransformHint) {
Dan Stoza7d89d062015-04-30 13:29:25 -07003141 // add this layer to the current state list
3142 {
3143 Mutex::Autolock _l(mStateLock);
Robert Carrc0df3122019-04-11 13:18:21 -07003144 sp<Layer> parent;
3145 if (parentHandle != nullptr) {
Alec Mouri9a02eda2020-04-21 17:39:34 -07003146 parent = fromHandleLocked(parentHandle).promote();
Robert Carrc0df3122019-04-11 13:18:21 -07003147 if (parent == nullptr) {
3148 return NAME_NOT_FOUND;
3149 }
3150 } else {
3151 parent = parentLayer;
3152 }
3153
Ady Abraham0a525092020-03-03 12:51:24 -08003154 if (mNumLayers >= ISurfaceComposer::MAX_LAYERS) {
chaviweadf0d42019-08-12 13:28:29 -07003155 ALOGE("AddClientLayer failed, mNumLayers (%zu) >= MAX_LAYERS (%zu)", mNumLayers.load(),
Ady Abraham0a525092020-03-03 12:51:24 -08003156 ISurfaceComposer::MAX_LAYERS);
Dan Stoza7d89d062015-04-30 13:29:25 -07003157 return NO_MEMORY;
3158 }
Robert Carrc0df3122019-04-11 13:18:21 -07003159
3160 mLayersByLocalBinderToken.emplace(handle->localBinder(), lbc);
3161
Robert Carrb89ea9d2018-12-10 13:01:14 -08003162 if (parent == nullptr && addToCurrentState) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003163 mCurrentState.layersSortedByZ.add(lbc);
chaviwac841852019-01-16 16:04:43 -08003164 } else if (parent == nullptr) {
3165 lbc->onRemovedFromCurrentState();
3166 } else if (parent->isRemovedFromCurrentState()) {
3167 parent->addChild(lbc);
3168 lbc->onRemovedFromCurrentState();
Robert Carrb89ea9d2018-12-10 13:01:14 -08003169 } else {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003170 parent->addChild(lbc);
3171 }
Chia-I Wu98f1c102017-05-30 14:54:08 -07003172
Yiwei Zhang243b3782018-05-15 17:40:04 -07003173 if (gbc != nullptr) {
3174 mGraphicBufferProducerList.insert(IInterface::asBinder(gbc).get());
3175 LOG_ALWAYS_FATAL_IF(mGraphicBufferProducerList.size() >
3176 mMaxGraphicBufferProducerListSize,
3177 "Suspected IGBP leak: %zu IGBPs (%zu max), %zu Layers",
3178 mGraphicBufferProducerList.size(),
chaviweadf0d42019-08-12 13:28:29 -07003179 mMaxGraphicBufferProducerListSize, mNumLayers.load());
Yiwei Zhang243b3782018-05-15 17:40:04 -07003180 }
Vishnu Nair6213bd92020-05-08 17:42:25 -07003181
3182 if (const auto display = getDefaultDisplayDeviceLocked()) {
3183 lbc->updateTransformHint(display);
3184 }
3185 if (outTransformHint) {
3186 *outTransformHint = lbc->getTransformHint();
3187 }
3188
Robert Carr1f0a16a2016-10-24 16:27:39 -07003189 mLayersAdded = true;
Dan Stoza7d89d062015-04-30 13:29:25 -07003190 }
3191
Mathias Agopian96f08192010-06-02 23:28:45 -07003192 // attach this layer to the client
Mathias Agopianac9fa422013-02-11 16:40:36 -08003193 client->attachLayer(handle, lbc);
Mathias Agopian4f113742011-05-03 16:21:41 -07003194
Dan Stoza7d89d062015-04-30 13:29:25 -07003195 return NO_ERROR;
Mathias Agopian96f08192010-06-02 23:28:45 -07003196}
3197
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07003198void SurfaceFlinger::removeGraphicBufferProducerAsync(const wp<IBinder>& binder) {
3199 static_cast<void>(schedule([=] {
3200 Mutex::Autolock lock(mStateLock);
3201 mGraphicBufferProducerList.erase(binder);
3202 }));
3203}
3204
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08003205uint32_t SurfaceFlinger::peekTransactionFlags() {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003206 return mTransactionFlags;
Mathias Agopiandea20b12011-05-03 17:04:02 -07003207}
3208
Mathias Agopian3f844832013-08-07 21:24:32 -07003209uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003210 return mTransactionFlags.fetch_and(~flags) & flags;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003211}
3212
Mathias Agopian3f844832013-08-07 21:24:32 -07003213uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) {
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003214 return setTransactionFlags(flags, Scheduler::TransactionStart::NORMAL);
Dan Stoza84d619e2018-03-28 17:07:36 -07003215}
3216
3217uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags,
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003218 Scheduler::TransactionStart transactionStart) {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003219 uint32_t old = mTransactionFlags.fetch_or(flags);
Dominik Laskowskieddeda12019-07-19 11:54:13 -07003220 mVSyncModulator->setTransactionStart(transactionStart);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003221 if ((old & flags)==0) { // wake the server up
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08003222 signalTransaction();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003223 }
3224 return old;
3225}
3226
Marissa Wall713b63f2018-10-17 15:42:43 -07003227bool SurfaceFlinger::flushTransactionQueues() {
Valerie Haufce31b82019-04-30 16:41:14 -07003228 // to prevent onHandleDestroyed from being called while the lock is held,
3229 // we must keep a copy of the transactions (specifically the composer
3230 // states) around outside the scope of the lock
3231 std::vector<const TransactionState> transactions;
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003232 bool flushedATransaction = false;
Valerie Haufce31b82019-04-30 16:41:14 -07003233 {
3234 Mutex::Autolock _l(mStateLock);
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003235
Valerie Haufce31b82019-04-30 16:41:14 -07003236 auto it = mTransactionQueues.begin();
3237 while (it != mTransactionQueues.end()) {
3238 auto& [applyToken, transactionQueue] = *it;
Marissa Wall713b63f2018-10-17 15:42:43 -07003239
Valerie Haufce31b82019-04-30 16:41:14 -07003240 while (!transactionQueue.empty()) {
3241 const auto& transaction = transactionQueue.front();
3242 if (!transactionIsReadyToBeApplied(transaction.desiredPresentTime,
3243 transaction.states)) {
3244 setTransactionFlags(eTransactionFlushNeeded);
3245 break;
3246 }
3247 transactions.push_back(transaction);
3248 applyTransactionState(transaction.states, transaction.displays, transaction.flags,
3249 mPendingInputWindowCommands, transaction.desiredPresentTime,
Valerie Hau9dab9732019-08-20 09:29:25 -07003250 transaction.buffer, transaction.postTime,
3251 transaction.privileged, transaction.hasListenerCallbacks,
3252 transaction.listenerCallbacks, /*isMainThread*/ true);
Valerie Haufce31b82019-04-30 16:41:14 -07003253 transactionQueue.pop();
3254 flushedATransaction = true;
Marissa Wall713b63f2018-10-17 15:42:43 -07003255 }
Marissa Wall713b63f2018-10-17 15:42:43 -07003256
Valerie Haufce31b82019-04-30 16:41:14 -07003257 if (transactionQueue.empty()) {
3258 it = mTransactionQueues.erase(it);
3259 mTransactionCV.broadcast();
3260 } else {
Valerie Haue5562ec2019-05-14 12:39:16 -07003261 it = std::next(it, 1);
Valerie Haufce31b82019-04-30 16:41:14 -07003262 }
Valerie Hauf6016b62019-03-28 10:49:59 -07003263 }
Marissa Wall713b63f2018-10-17 15:42:43 -07003264 }
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003265 return flushedATransaction;
3266}
3267
3268bool SurfaceFlinger::transactionFlushNeeded() {
3269 return !mTransactionQueues.empty();
Marissa Wall713b63f2018-10-17 15:42:43 -07003270}
3271
chaviwca27f252018-02-06 16:46:39 -08003272
Marissa Wall17b4e452018-12-26 16:32:34 -08003273bool SurfaceFlinger::transactionIsReadyToBeApplied(int64_t desiredPresentTime,
3274 const Vector<ComposerState>& states) {
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003275
3276 const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
Marissa Wall17b4e452018-12-26 16:32:34 -08003277 // Do not present if the desiredPresentTime has not passed unless it is more than one second
3278 // in the future. We ignore timestamps more than 1 second in the future for stability reasons.
3279 if (desiredPresentTime >= 0 && desiredPresentTime >= expectedPresentTime &&
3280 desiredPresentTime < expectedPresentTime + s2ns(1)) {
3281 return false;
3282 }
3283
Marissa Wall713b63f2018-10-17 15:42:43 -07003284 for (const ComposerState& state : states) {
3285 const layer_state_t& s = state.state;
3286 if (!(s.what & layer_state_t::eAcquireFenceChanged)) {
3287 continue;
3288 }
3289 if (s.acquireFence && s.acquireFence->getStatus() == Fence::Status::Unsignaled) {
Marissa Wall17b4e452018-12-26 16:32:34 -08003290 return false;
Marissa Wall713b63f2018-10-17 15:42:43 -07003291 }
3292 }
Marissa Wall17b4e452018-12-26 16:32:34 -08003293 return true;
Marissa Wall713b63f2018-10-17 15:42:43 -07003294}
3295
Valerie Hau9dab9732019-08-20 09:29:25 -07003296void SurfaceFlinger::setTransactionState(
3297 const Vector<ComposerState>& states, const Vector<DisplayState>& displays, uint32_t flags,
3298 const sp<IBinder>& applyToken, const InputWindowCommands& inputWindowCommands,
3299 int64_t desiredPresentTime, const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
3300 const std::vector<ListenerCallbacks>& listenerCallbacks) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003301 ATRACE_CALL();
Robert Carr14167e02019-02-13 13:50:55 -08003302
Valerie Haubc6ddb12019-03-08 11:10:15 -08003303 const int64_t postTime = systemTime();
3304
Robert Carr14167e02019-02-13 13:50:55 -08003305 bool privileged = callingThreadHasUnscopedSurfaceFlingerAccess();
3306
Mathias Agopian698c0872011-06-28 19:09:31 -07003307 Mutex::Autolock _l(mStateLock);
Mathias Agopiane57f2922012-08-09 16:29:12 -07003308
Marissa Wall713b63f2018-10-17 15:42:43 -07003309 // If its TransactionQueue already has a pending TransactionState or if it is pending
Valerie Hauf6016b62019-03-28 10:49:59 -07003310 auto itr = mTransactionQueues.find(applyToken);
3311 // if this is an animation frame, wait until prior animation frame has
3312 // been applied by SF
3313 if (flags & eAnimation) {
3314 while (itr != mTransactionQueues.end()) {
3315 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
3316 if (CC_UNLIKELY(err != NO_ERROR)) {
3317 ALOGW_IF(err == TIMED_OUT,
3318 "setTransactionState timed out "
3319 "waiting for animation frame to apply");
3320 break;
3321 }
3322 itr = mTransactionQueues.find(applyToken);
3323 }
3324 }
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003325
Ady Abraham5facfb12020-04-22 15:18:31 -07003326 const bool pendingTransactions = itr != mTransactionQueues.end();
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003327 // Expected present time is computed and cached on invalidate, so it may be stale.
Ady Abraham5facfb12020-04-22 15:18:31 -07003328 if (!pendingTransactions) {
3329 mExpectedPresentTime = calculateExpectedPresentTime(systemTime());
3330 }
3331
3332 if (pendingTransactions || !transactionIsReadyToBeApplied(desiredPresentTime, states)) {
Robert Carr14167e02019-02-13 13:50:55 -08003333 mTransactionQueues[applyToken].emplace(states, displays, flags, desiredPresentTime,
Valerie Hau9dab9732019-08-20 09:29:25 -07003334 uncacheBuffer, postTime, privileged,
3335 hasListenerCallbacks, listenerCallbacks);
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003336 setTransactionFlags(eTransactionFlushNeeded);
Marissa Wall713b63f2018-10-17 15:42:43 -07003337 return;
3338 }
3339
Valerie Haubc6ddb12019-03-08 11:10:15 -08003340 applyTransactionState(states, displays, flags, inputWindowCommands, desiredPresentTime,
Valerie Hau9dab9732019-08-20 09:29:25 -07003341 uncacheBuffer, postTime, privileged, hasListenerCallbacks,
3342 listenerCallbacks);
Marissa Wall713b63f2018-10-17 15:42:43 -07003343}
3344
Valerie Hau9dab9732019-08-20 09:29:25 -07003345void SurfaceFlinger::applyTransactionState(
3346 const Vector<ComposerState>& states, const Vector<DisplayState>& displays, uint32_t flags,
3347 const InputWindowCommands& inputWindowCommands, const int64_t desiredPresentTime,
3348 const client_cache_t& uncacheBuffer, const int64_t postTime, bool privileged,
3349 bool hasListenerCallbacks, const std::vector<ListenerCallbacks>& listenerCallbacks,
3350 bool isMainThread) {
Marissa Wall713b63f2018-10-17 15:42:43 -07003351 uint32_t transactionFlags = 0;
3352
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003353 if (flags & eAnimation) {
3354 // For window updates that are part of an animation we must wait for
3355 // previous animation "frames" to be handled.
Valerie Hau38448362019-04-11 14:49:33 -07003356 while (!isMainThread && mAnimTransactionPending) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003357 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003358 if (CC_UNLIKELY(err != NO_ERROR)) {
3359 // just in case something goes wrong in SF, return to the
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003360 // caller after a few seconds.
3361 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out "
3362 "waiting for previous animation frame");
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003363 mAnimTransactionPending = false;
3364 break;
3365 }
3366 }
3367 }
3368
chaviwca27f252018-02-06 16:46:39 -08003369 for (const DisplayState& display : displays) {
3370 transactionFlags |= setDisplayStateLocked(display);
Jamie Gennisb8d69a52011-10-10 15:48:06 -07003371 }
3372
Valerie Hau9dab9732019-08-20 09:29:25 -07003373 // start and end registration for listeners w/ no surface so they can get their callback. Note
3374 // that listeners with SurfaceControls will start registration during setClientStateLocked
3375 // below.
3376 for (const auto& listener : listenerCallbacks) {
3377 mTransactionCompletedThread.startRegistration(listener);
3378 mTransactionCompletedThread.endRegistration(listener);
Marissa Walld600d572019-03-26 15:38:50 -07003379 }
3380
Valerie Hau9dab9732019-08-20 09:29:25 -07003381 std::unordered_set<ListenerCallbacks, ListenerCallbacksHash> listenerCallbacksWithSurfaces;
Marissa Walle2ffb422018-10-12 11:33:52 -07003382 uint32_t clientStateFlags = 0;
chaviwca27f252018-02-06 16:46:39 -08003383 for (const ComposerState& state : states) {
Valerie Hau9dab9732019-08-20 09:29:25 -07003384 clientStateFlags |= setClientStateLocked(state, desiredPresentTime, postTime, privileged,
3385 listenerCallbacksWithSurfaces);
Marissa Wall3dad52d2019-03-22 14:03:19 -07003386 }
3387
Valerie Hau9dab9732019-08-20 09:29:25 -07003388 for (const auto& listenerCallback : listenerCallbacksWithSurfaces) {
Marissa Wallefb71af2019-06-27 14:45:53 -07003389 mTransactionCompletedThread.endRegistration(listenerCallback);
3390 }
3391
Marissa Walle2ffb422018-10-12 11:33:52 -07003392 // If the state doesn't require a traversal and there are callbacks, send them now
Valerie Hau9dab9732019-08-20 09:29:25 -07003393 if (!(clientStateFlags & eTraversalNeeded) && hasListenerCallbacks) {
Marissa Walle2ffb422018-10-12 11:33:52 -07003394 mTransactionCompletedThread.sendCallbacks();
3395 }
3396 transactionFlags |= clientStateFlags;
chaviwca27f252018-02-06 16:46:39 -08003397
chaviw273171b2018-12-26 11:46:30 -08003398 transactionFlags |= addInputWindowCommands(inputWindowCommands);
3399
Marissa Wall947d34e2019-03-29 14:03:53 -07003400 if (uncacheBuffer.isValid()) {
3401 ClientCache::getInstance().erase(uncacheBuffer);
Alec Mouri4545a8a2019-08-08 20:05:32 -07003402 getRenderEngine().unbindExternalTextureBuffer(uncacheBuffer.id);
Marissa Wall78b72202019-03-15 14:58:34 -07003403 }
3404
Jorim Jaggibdcf09c2017-08-08 15:22:08 +02003405 // If a synchronous transaction is explicitly requested without any changes, force a transaction
3406 // anyway. This can be used as a flush mechanism for previous async transactions.
3407 // Empty animation transaction can be used to simulate back-pressure, so also force a
3408 // transaction for empty animation transactions.
3409 if (transactionFlags == 0 &&
3410 ((flags & eSynchronous) || (flags & eAnimation))) {
Robert Carr2a7dbb42016-05-24 11:41:28 -07003411 transactionFlags = eTransactionNeeded;
3412 }
3413
Marissa Wall06255332019-03-27 13:48:27 -07003414 // If we are on the main thread, we are about to preform a traversal. Clear the traversal bit
3415 // so we don't have to wake up again next frame to preform an uneeded traversal.
3416 if (isMainThread && (transactionFlags & eTraversalNeeded)) {
3417 transactionFlags = transactionFlags & (~eTraversalNeeded);
3418 mTraversalNeededMainThread = true;
3419 }
3420
Mathias Agopian386aa982011-11-07 21:58:03 -08003421 if (transactionFlags) {
Lloyd Pique4dccc412018-01-22 17:21:36 -08003422 if (mInterceptor->isEnabled()) {
3423 mInterceptor->saveTransaction(states, mCurrentState.displays, displays, flags);
Irvelffc9efc2016-07-27 15:16:37 -07003424 }
Irvel468051e2016-06-13 16:44:44 -07003425
Mathias Agopian386aa982011-11-07 21:58:03 -08003426 // this triggers the transaction
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003427 const auto start = (flags & eEarlyWakeup) ? Scheduler::TransactionStart::EARLY
3428 : Scheduler::TransactionStart::NORMAL;
Dan Stoza84d619e2018-03-28 17:07:36 -07003429 setTransactionFlags(transactionFlags, start);
Mathias Agopian386aa982011-11-07 21:58:03 -08003430
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003431 if (flags & eAnimation) {
3432 mAnimTransactionPending = true;
3433 }
Robert Carr238f4a22020-04-29 13:04:02 -07003434
3435 // if this is a synchronous transaction, wait for it to take effect
3436 // before returning.
3437 const bool synchronous = flags & eSynchronous;
3438 const bool syncInput = inputWindowCommands.syncInputWindows;
3439 if (!synchronous && !syncInput) {
3440 return;
3441 }
3442
3443 if (synchronous) {
3444 mTransactionPending = true;
3445 }
3446 if (syncInput) {
chaviw4fe36852019-04-15 16:25:49 -07003447 mPendingSyncInputWindows = true;
3448 }
Valerie Hau0779ded2019-03-19 12:43:04 -07003449
Robert Carr238f4a22020-04-29 13:04:02 -07003450
Valerie Hau0779ded2019-03-19 12:43:04 -07003451 // applyTransactionState can be called by either the main SF thread or by
3452 // another process through setTransactionState. While a given process may wish
3453 // to wait on synchronous transactions, the main SF thread should never
3454 // be blocked. Therefore, we only wait if isMainThread is false.
3455 while (!isMainThread && (mTransactionPending || mPendingSyncInputWindows)) {
Mathias Agopian386aa982011-11-07 21:58:03 -08003456 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
3457 if (CC_UNLIKELY(err != NO_ERROR)) {
3458 // just in case something goes wrong in SF, return to the
3459 // called after a few seconds.
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003460 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");
3461 mTransactionPending = false;
chaviw95ef3c42019-02-14 10:55:09 -08003462 mPendingSyncInputWindows = false;
Mathias Agopian386aa982011-11-07 21:58:03 -08003463 break;
3464 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -07003465 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003466 }
3467}
3468
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003469uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s) {
3470 const ssize_t index = mCurrentState.displays.indexOfKey(s.token);
3471 if (index < 0) return 0;
Jesse Hall9a143922012-10-04 16:29:19 -07003472
Mathias Agopiane57f2922012-08-09 16:29:12 -07003473 uint32_t flags = 0;
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003474 DisplayDeviceState& state = mCurrentState.displays.editValueAt(index);
3475
3476 const uint32_t what = s.what;
3477 if (what & DisplayState::eSurfaceChanged) {
3478 if (IInterface::asBinder(state.surface) != IInterface::asBinder(s.surface)) {
3479 state.surface = s.surface;
3480 flags |= eDisplayTransactionNeeded;
Michael Lentine47e45402014-07-18 15:34:25 -07003481 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07003482 }
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003483 if (what & DisplayState::eLayerStackChanged) {
3484 if (state.layerStack != s.layerStack) {
3485 state.layerStack = s.layerStack;
3486 flags |= eDisplayTransactionNeeded;
3487 }
3488 }
3489 if (what & DisplayState::eDisplayProjectionChanged) {
3490 if (state.orientation != s.orientation) {
3491 state.orientation = s.orientation;
3492 flags |= eDisplayTransactionNeeded;
3493 }
3494 if (state.frame != s.frame) {
3495 state.frame = s.frame;
3496 flags |= eDisplayTransactionNeeded;
3497 }
3498 if (state.viewport != s.viewport) {
3499 state.viewport = s.viewport;
3500 flags |= eDisplayTransactionNeeded;
3501 }
3502 }
3503 if (what & DisplayState::eDisplaySizeChanged) {
3504 if (state.width != s.width) {
3505 state.width = s.width;
3506 flags |= eDisplayTransactionNeeded;
3507 }
3508 if (state.height != s.height) {
3509 state.height = s.height;
3510 flags |= eDisplayTransactionNeeded;
3511 }
3512 }
3513
Mathias Agopiane57f2922012-08-09 16:29:12 -07003514 return flags;
3515}
3516
Steven Thomasd4071902020-03-24 16:02:53 -07003517bool SurfaceFlinger::callingThreadHasUnscopedSurfaceFlingerAccess(bool usePermissionCache) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003518 IPCThreadState* ipc = IPCThreadState::self();
3519 const int pid = ipc->getCallingPid();
3520 const int uid = ipc->getCallingUid();
Robert Carrd4ae7f32018-06-07 16:10:57 -07003521 if ((uid != AID_GRAPHICS && uid != AID_SYSTEM) &&
Steven Thomasd4071902020-03-24 16:02:53 -07003522 (usePermissionCache ? !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)
3523 : !checkPermission(sAccessSurfaceFlinger, pid, uid))) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003524 return false;
3525 }
3526 return true;
3527}
3528
Marissa Wall3dad52d2019-03-22 14:03:19 -07003529uint32_t SurfaceFlinger::setClientStateLocked(
Valerie Hau9dab9732019-08-20 09:29:25 -07003530 const ComposerState& composerState, int64_t desiredPresentTime, int64_t postTime,
3531 bool privileged,
3532 std::unordered_set<ListenerCallbacks, ListenerCallbacksHash>& listenerCallbacks) {
chaviwca27f252018-02-06 16:46:39 -08003533 const layer_state_t& s = composerState.state;
chaviwca27f252018-02-06 16:46:39 -08003534
Valerie Hau9dab9732019-08-20 09:29:25 -07003535 for (auto& listener : s.listeners) {
3536 // note that startRegistration will not re-register if the listener has
3537 // already be registered for a prior surface control
3538 mTransactionCompletedThread.startRegistration(listener);
3539 listenerCallbacks.insert(listener);
3540 }
3541
Vishnu Nairdc6f5b92019-12-03 07:33:37 -08003542 sp<Layer> layer = nullptr;
3543 if (s.surface) {
Alec Mouri9a02eda2020-04-21 17:39:34 -07003544 layer = fromHandleLocked(s.surface).promote();
Vishnu Nairdc6f5b92019-12-03 07:33:37 -08003545 } else {
3546 // The client may provide us a null handle. Treat it as if the layer was removed.
3547 ALOGW("Attempt to set client state with a null layer handle");
3548 }
chaviw8b3871a2017-11-01 17:41:01 -07003549 if (layer == nullptr) {
Valerie Hau9dab9732019-08-20 09:29:25 -07003550 for (auto& [listener, callbackIds] : s.listeners) {
Marissa Wallefb71af2019-06-27 14:45:53 -07003551 mTransactionCompletedThread.registerUnpresentedCallbackHandle(
Valerie Hau9dab9732019-08-20 09:29:25 -07003552 new CallbackHandle(listener, callbackIds, s.surface));
Marissa Wall88e20482019-06-24 10:49:42 -07003553 }
chaviw8b3871a2017-11-01 17:41:01 -07003554 return 0;
3555 }
3556
chaviw8b3871a2017-11-01 17:41:01 -07003557 uint32_t flags = 0;
3558
Garfield Tan8a3083e2018-12-03 13:21:07 -08003559 const uint64_t what = s.what;
Jorim Jaggidba32732018-05-28 17:43:52 +02003560
3561 // If we are deferring transaction, make sure to push the pending state, as otherwise the
3562 // pending state will also be deferred.
Marissa Wallf58c14b2018-07-24 10:50:43 -07003563 if (what & layer_state_t::eDeferTransaction_legacy) {
Jorim Jaggidba32732018-05-28 17:43:52 +02003564 layer->pushPendingState();
3565 }
3566
Valerie Hau871d6352020-01-29 08:44:02 -08003567 // Only set by BLAST adapter layers
3568 if (what & layer_state_t::eProducerDisconnect) {
3569 layer->onDisconnect();
3570 }
3571
chaviw8b3871a2017-11-01 17:41:01 -07003572 if (what & layer_state_t::ePositionChanged) {
chaviw214c89d2019-09-04 16:03:53 -07003573 if (layer->setPosition(s.x, s.y)) {
chaviw8b3871a2017-11-01 17:41:01 -07003574 flags |= eTraversalNeeded;
Mathias Agopiane57f2922012-08-09 16:29:12 -07003575 }
chaviw8b3871a2017-11-01 17:41:01 -07003576 }
3577 if (what & layer_state_t::eLayerChanged) {
3578 // NOTE: index needs to be calculated before we update the state
3579 const auto& p = layer->getParent();
3580 if (p == nullptr) {
chaviw64f7b422017-07-12 10:31:58 -07003581 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
chaviw8b3871a2017-11-01 17:41:01 -07003582 if (layer->setLayer(s.z) && idx >= 0) {
Mathias Agopiane57f2922012-08-09 16:29:12 -07003583 mCurrentState.layersSortedByZ.removeAt(idx);
3584 mCurrentState.layersSortedByZ.add(layer);
3585 // we need traversal (state changed)
3586 // AND transaction (list changed)
3587 flags |= eTransactionNeeded|eTraversalNeeded;
3588 }
chaviw8b3871a2017-11-01 17:41:01 -07003589 } else {
3590 if (p->setChildLayer(layer, s.z)) {
chaviw06178942017-07-27 10:25:59 -07003591 flags |= eTransactionNeeded|eTraversalNeeded;
3592 }
3593 }
chaviw8b3871a2017-11-01 17:41:01 -07003594 }
3595 if (what & layer_state_t::eRelativeLayerChanged) {
Robert Carr503c7042017-09-27 15:06:08 -07003596 // NOTE: index needs to be calculated before we update the state
3597 const auto& p = layer->getParent();
3598 if (p == nullptr) {
3599 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
3600 if (layer->setRelativeLayer(s.relativeLayerHandle, s.z) && idx >= 0) {
3601 mCurrentState.layersSortedByZ.removeAt(idx);
3602 mCurrentState.layersSortedByZ.add(layer);
3603 // we need traversal (state changed)
3604 // AND transaction (list changed)
3605 flags |= eTransactionNeeded|eTraversalNeeded;
3606 }
3607 } else {
3608 if (p->setChildRelativeLayer(layer, s.relativeLayerHandle, s.z)) {
3609 flags |= eTransactionNeeded|eTraversalNeeded;
3610 }
chaviw8b3871a2017-11-01 17:41:01 -07003611 }
3612 }
3613 if (what & layer_state_t::eSizeChanged) {
3614 if (layer->setSize(s.w, s.h)) {
3615 flags |= eTraversalNeeded;
3616 }
3617 }
3618 if (what & layer_state_t::eAlphaChanged) {
3619 if (layer->setAlpha(s.alpha))
3620 flags |= eTraversalNeeded;
3621 }
3622 if (what & layer_state_t::eColorChanged) {
3623 if (layer->setColor(s.color))
3624 flags |= eTraversalNeeded;
3625 }
Peiyong Lind3788632018-09-18 16:01:31 -07003626 if (what & layer_state_t::eColorTransformChanged) {
3627 if (layer->setColorTransform(s.colorTransform)) {
3628 flags |= eTraversalNeeded;
3629 }
3630 }
Valerie Haudd0b7572019-01-29 14:59:27 -08003631 if (what & layer_state_t::eBackgroundColorChanged) {
3632 if (layer->setBackgroundColor(s.color, s.bgColorAlpha, s.bgColorDataspace)) {
3633 flags |= eTraversalNeeded;
3634 }
3635 }
chaviw8b3871a2017-11-01 17:41:01 -07003636 if (what & layer_state_t::eMatrixChanged) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003637 // TODO: b/109894387
3638 //
3639 // SurfaceFlinger's renderer is not prepared to handle cropping in the face of arbitrary
3640 // rotation. To see the problem observe that if we have a square parent, and a child
3641 // of the same size, then we rotate the child 45 degrees around it's center, the child
3642 // must now be cropped to a non rectangular 8 sided region.
3643 //
3644 // Of course we can fix this in the future. For now, we are lucky, SurfaceControl is
3645 // private API, and the WindowManager only uses rotation in one case, which is on a top
3646 // level layer in which cropping is not an issue.
3647 //
3648 // However given that abuse of rotation matrices could lead to surfaces extending outside
3649 // of cropped areas, we need to prevent non-root clients without permission ACCESS_SURFACE_FLINGER
3650 // (a.k.a. everyone except WindowManager and tests) from setting non rectangle preserving
3651 // transformations.
Robert Carr14167e02019-02-13 13:50:55 -08003652 if (layer->setMatrix(s.matrix, privileged))
chaviw8b3871a2017-11-01 17:41:01 -07003653 flags |= eTraversalNeeded;
3654 }
3655 if (what & layer_state_t::eTransparentRegionChanged) {
3656 if (layer->setTransparentRegionHint(s.transparentRegion))
3657 flags |= eTraversalNeeded;
3658 }
3659 if (what & layer_state_t::eFlagsChanged) {
3660 if (layer->setFlags(s.flags, s.mask))
3661 flags |= eTraversalNeeded;
3662 }
Marissa Wallf58c14b2018-07-24 10:50:43 -07003663 if (what & layer_state_t::eCropChanged_legacy) {
chaviw214c89d2019-09-04 16:03:53 -07003664 if (layer->setCrop_legacy(s.crop_legacy)) flags |= eTraversalNeeded;
chaviw8b3871a2017-11-01 17:41:01 -07003665 }
Lucas Dupin1b6531c2018-07-05 17:18:21 -07003666 if (what & layer_state_t::eCornerRadiusChanged) {
3667 if (layer->setCornerRadius(s.cornerRadius))
3668 flags |= eTraversalNeeded;
3669 }
Lucas Dupin00f16422020-03-11 11:33:04 -07003670 if (what & layer_state_t::eBackgroundBlurRadiusChanged && !mDisableBlurs) {
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08003671 if (layer->setBackgroundBlurRadius(s.backgroundBlurRadius)) flags |= eTraversalNeeded;
3672 }
chaviw8b3871a2017-11-01 17:41:01 -07003673 if (what & layer_state_t::eLayerStackChanged) {
3674 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
3675 // We only allow setting layer stacks for top level layers,
3676 // everything else inherits layer stack from its parent.
3677 if (layer->hasParent()) {
3678 ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003679 layer->getDebugName());
chaviw8b3871a2017-11-01 17:41:01 -07003680 } else if (idx < 0) {
3681 ALOGE("Attempt to set layer stack on layer without parent (%s) that "
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003682 "that also does not appear in the top level layer list. Something"
3683 " has gone wrong.",
3684 layer->getDebugName());
chaviw8b3871a2017-11-01 17:41:01 -07003685 } else if (layer->setLayerStack(s.layerStack)) {
3686 mCurrentState.layersSortedByZ.removeAt(idx);
3687 mCurrentState.layersSortedByZ.add(layer);
3688 // we need traversal (state changed)
3689 // AND transaction (list changed)
Vishnu Nair6213bd92020-05-08 17:42:25 -07003690 flags |= eTransactionNeeded | eTraversalNeeded | eTransformHintUpdateNeeded;
chaviw8b3871a2017-11-01 17:41:01 -07003691 }
3692 }
Marissa Wallf58c14b2018-07-24 10:50:43 -07003693 if (what & layer_state_t::eDeferTransaction_legacy) {
3694 if (s.barrierHandle_legacy != nullptr) {
3695 layer->deferTransactionUntil_legacy(s.barrierHandle_legacy, s.frameNumber_legacy);
3696 } else if (s.barrierGbp_legacy != nullptr) {
3697 const sp<IGraphicBufferProducer>& gbp = s.barrierGbp_legacy;
chaviw8b3871a2017-11-01 17:41:01 -07003698 if (authenticateSurfaceTextureLocked(gbp)) {
3699 const auto& otherLayer =
3700 (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
Marissa Wallf58c14b2018-07-24 10:50:43 -07003701 layer->deferTransactionUntil_legacy(otherLayer, s.frameNumber_legacy);
chaviw8b3871a2017-11-01 17:41:01 -07003702 } else {
3703 ALOGE("Attempt to defer transaction to to an"
3704 " unrecognized GraphicBufferProducer");
Robert Carr1db73f62016-12-21 12:58:51 -08003705 }
3706 }
chaviw8b3871a2017-11-01 17:41:01 -07003707 // We don't trigger a traversal here because if no other state is
3708 // changed, we don't want this to cause any more work
3709 }
chaviw8b3871a2017-11-01 17:41:01 -07003710 if (what & layer_state_t::eReparentChildren) {
3711 if (layer->reparentChildren(s.reparentHandle)) {
3712 flags |= eTransactionNeeded|eTraversalNeeded;
Robert Carrc3574f72016-03-24 12:19:32 -07003713 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07003714 }
chaviw8b3871a2017-11-01 17:41:01 -07003715 if (what & layer_state_t::eDetachChildren) {
3716 layer->detachChildren();
3717 }
3718 if (what & layer_state_t::eOverrideScalingModeChanged) {
3719 layer->setOverrideScalingMode(s.overrideScalingMode);
3720 // We don't trigger a traversal here because if no other state is
3721 // changed, we don't want this to cause any more work
3722 }
Marissa Wall61c58622018-07-18 10:12:20 -07003723 if (what & layer_state_t::eTransformChanged) {
3724 if (layer->setTransform(s.transform)) flags |= eTraversalNeeded;
3725 }
3726 if (what & layer_state_t::eTransformToDisplayInverseChanged) {
3727 if (layer->setTransformToDisplayInverse(s.transformToDisplayInverse))
3728 flags |= eTraversalNeeded;
3729 }
3730 if (what & layer_state_t::eCropChanged) {
3731 if (layer->setCrop(s.crop)) flags |= eTraversalNeeded;
3732 }
Marissa Wall861616d2018-10-22 12:52:23 -07003733 if (what & layer_state_t::eFrameChanged) {
3734 if (layer->setFrame(s.frame)) flags |= eTraversalNeeded;
3735 }
Marissa Wall61c58622018-07-18 10:12:20 -07003736 if (what & layer_state_t::eAcquireFenceChanged) {
3737 if (layer->setAcquireFence(s.acquireFence)) flags |= eTraversalNeeded;
3738 }
3739 if (what & layer_state_t::eDataspaceChanged) {
3740 if (layer->setDataspace(s.dataspace)) flags |= eTraversalNeeded;
3741 }
3742 if (what & layer_state_t::eHdrMetadataChanged) {
3743 if (layer->setHdrMetadata(s.hdrMetadata)) flags |= eTraversalNeeded;
3744 }
3745 if (what & layer_state_t::eSurfaceDamageRegionChanged) {
3746 if (layer->setSurfaceDamageRegion(s.surfaceDamageRegion)) flags |= eTraversalNeeded;
3747 }
3748 if (what & layer_state_t::eApiChanged) {
3749 if (layer->setApi(s.api)) flags |= eTraversalNeeded;
3750 }
3751 if (what & layer_state_t::eSidebandStreamChanged) {
3752 if (layer->setSidebandStream(s.sidebandStream)) flags |= eTraversalNeeded;
3753 }
Robert Carr720e5062018-07-30 17:45:14 -07003754 if (what & layer_state_t::eInputInfoChanged) {
Vishnu Nairce5d0cc2019-02-28 14:38:41 -08003755 if (privileged) {
Robert Carr11ac2012019-01-22 09:05:25 -08003756 layer->setInputInfo(s.inputInfo);
3757 flags |= eTraversalNeeded;
3758 } else {
3759 ALOGE("Attempt to update InputWindowInfo without permission ACCESS_SURFACE_FLINGER");
3760 }
Robert Carr720e5062018-07-30 17:45:14 -07003761 }
Evan Rosky1f6d6d52018-12-06 10:47:26 -08003762 if (what & layer_state_t::eMetadataChanged) {
3763 if (layer->setMetadata(s.metadata)) flags |= eTraversalNeeded;
3764 }
Peiyong Linc502cb72019-03-01 15:00:23 -08003765 if (what & layer_state_t::eColorSpaceAgnosticChanged) {
3766 if (layer->setColorSpaceAgnostic(s.colorSpaceAgnostic)) {
3767 flags |= eTraversalNeeded;
3768 }
3769 }
Vishnu Nairc97b8db2019-10-29 18:19:35 -07003770 if (what & layer_state_t::eShadowRadiusChanged) {
3771 if (layer->setShadowRadius(s.shadowRadius)) flags |= eTraversalNeeded;
3772 }
Ana Krulecc84d09b2019-11-02 23:10:29 +01003773 if (what & layer_state_t::eFrameRateSelectionPriority) {
3774 if (privileged && layer->setFrameRateSelectionPriority(s.frameRateSelectionPriority)) {
3775 flags |= eTraversalNeeded;
3776 }
3777 }
Steven Thomas3172e202020-01-06 19:25:30 -08003778 if (what & layer_state_t::eFrameRateChanged) {
Steven Thomas62a4cf82020-01-31 12:04:03 -08003779 if (ValidateFrameRate(s.frameRate, s.frameRateCompatibility,
3780 "SurfaceFlinger::setClientStateLocked") &&
3781 layer->setFrameRate(Layer::FrameRate(s.frameRate,
3782 Layer::FrameRate::convertCompatibility(
3783 s.frameRateCompatibility)))) {
Ady Abraham71c437d2020-01-31 15:56:57 -08003784 flags |= eTraversalNeeded;
Steven Thomas62a4cf82020-01-31 12:04:03 -08003785 }
Steven Thomas3172e202020-01-06 19:25:30 -08003786 }
Vishnu Nair6213bd92020-05-08 17:42:25 -07003787 if (what & layer_state_t::eFixedTransformHintChanged) {
3788 if (layer->setFixedTransformHint(s.fixedTransformHint)) {
3789 flags |= eTraversalNeeded | eTransformHintUpdateNeeded;
3790 }
3791 }
Vishnu Nair14d76922019-08-05 08:41:20 -07003792 // This has to happen after we reparent children because when we reparent to null we remove
3793 // child layers from current state and remove its relative z. If the children are reparented in
3794 // the same transaction, then we have to make sure we reparent the children first so we do not
3795 // lose its relative z order.
3796 if (what & layer_state_t::eReparent) {
3797 bool hadParent = layer->hasParent();
3798 if (layer->reparent(s.parentHandleForChild)) {
3799 if (!hadParent) {
3800 mCurrentState.layersSortedByZ.remove(layer);
3801 }
3802 flags |= eTransactionNeeded | eTraversalNeeded;
3803 }
3804 }
Marissa Walle2ffb422018-10-12 11:33:52 -07003805 std::vector<sp<CallbackHandle>> callbackHandles;
Valerie Hau9dab9732019-08-20 09:29:25 -07003806 if ((what & layer_state_t::eHasListenerCallbacksChanged) && (!s.listeners.empty())) {
3807 for (auto& [listener, callbackIds] : s.listeners) {
Marissa Walle2ffb422018-10-12 11:33:52 -07003808 callbackHandles.emplace_back(new CallbackHandle(listener, callbackIds, s.surface));
3809 }
3810 }
Marissa Wall78b72202019-03-15 14:58:34 -07003811 bool bufferChanged = what & layer_state_t::eBufferChanged;
3812 bool cacheIdChanged = what & layer_state_t::eCachedBufferChanged;
3813 sp<GraphicBuffer> buffer;
Alec Mouri4545a8a2019-08-08 20:05:32 -07003814 if (bufferChanged && cacheIdChanged && s.buffer != nullptr) {
Marissa Wall78b72202019-03-15 14:58:34 -07003815 buffer = s.buffer;
Alec Mouri4545a8a2019-08-08 20:05:32 -07003816 bool success = ClientCache::getInstance().add(s.cachedBuffer, s.buffer);
3817 if (success) {
3818 getRenderEngine().cacheExternalTextureBuffer(s.buffer);
3819 success = ClientCache::getInstance()
3820 .registerErasedRecipient(s.cachedBuffer,
3821 wp<ClientCache::ErasedRecipient>(this));
3822 if (!success) {
3823 getRenderEngine().unbindExternalTextureBuffer(s.buffer->getId());
3824 }
3825 }
Marissa Wall78b72202019-03-15 14:58:34 -07003826 } else if (cacheIdChanged) {
Marissa Wall947d34e2019-03-29 14:03:53 -07003827 buffer = ClientCache::getInstance().get(s.cachedBuffer);
Marissa Wall78b72202019-03-15 14:58:34 -07003828 } else if (bufferChanged) {
3829 buffer = s.buffer;
Marissa Wall73411622019-01-25 10:45:41 -08003830 }
Marissa Wall78b72202019-03-15 14:58:34 -07003831 if (buffer) {
Valerie Haubf784642020-01-29 07:25:23 -08003832 if (layer->setBuffer(buffer, s.acquireFence, postTime, desiredPresentTime,
3833 s.cachedBuffer)) {
Valerie Haubc6ddb12019-03-08 11:10:15 -08003834 flags |= eTraversalNeeded;
Valerie Haubc6ddb12019-03-08 11:10:15 -08003835 }
Marissa Wallebc2c052019-01-16 19:16:55 -08003836 }
Marissa Walle2ffb422018-10-12 11:33:52 -07003837 if (layer->setTransactionCompletedListeners(callbackHandles)) flags |= eTraversalNeeded;
3838 // Do not put anything that updates layer state or modifies flags after
3839 // setTransactionCompletedListener
Mathias Agopiane57f2922012-08-09 16:29:12 -07003840 return flags;
3841}
3842
chaviw273171b2018-12-26 11:46:30 -08003843uint32_t SurfaceFlinger::addInputWindowCommands(const InputWindowCommands& inputWindowCommands) {
3844 uint32_t flags = 0;
chaviwa911b102019-02-14 10:18:33 -08003845 if (inputWindowCommands.syncInputWindows) {
3846 flags |= eTraversalNeeded;
3847 }
3848
Vishnu Nairec0ab382019-02-13 15:32:56 -08003849 mPendingInputWindowCommands.merge(inputWindowCommands);
chaviw273171b2018-12-26 11:46:30 -08003850 return flags;
3851}
3852
chaviwfe94a222019-08-21 13:52:59 -07003853status_t SurfaceFlinger::mirrorLayer(const sp<Client>& client, const sp<IBinder>& mirrorFromHandle,
3854 sp<IBinder>* outHandle) {
3855 if (!mirrorFromHandle) {
3856 return NAME_NOT_FOUND;
3857 }
3858
3859 sp<Layer> mirrorLayer;
3860 sp<Layer> mirrorFrom;
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003861 std::string uniqueName = getUniqueLayerName("MirrorRoot");
chaviwfe94a222019-08-21 13:52:59 -07003862
3863 {
3864 Mutex::Autolock _l(mStateLock);
Alec Mouri9a02eda2020-04-21 17:39:34 -07003865 mirrorFrom = fromHandleLocked(mirrorFromHandle).promote();
chaviwfe94a222019-08-21 13:52:59 -07003866 if (!mirrorFrom) {
3867 return NAME_NOT_FOUND;
3868 }
3869
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003870 status_t result = createContainerLayer(client, std::move(uniqueName), -1, -1, 0,
3871 LayerMetadata(), outHandle, &mirrorLayer);
chaviwfe94a222019-08-21 13:52:59 -07003872 if (result != NO_ERROR) {
3873 return result;
3874 }
3875
3876 mirrorLayer->mClonedChild = mirrorFrom->createClone();
3877 }
3878
Vishnu Nair6213bd92020-05-08 17:42:25 -07003879 return addClientLayer(client, *outHandle, nullptr, mirrorLayer, nullptr, nullptr, false,
3880 nullptr /* outTransformHint */);
chaviwfe94a222019-08-21 13:52:59 -07003881}
3882
Marissa Wall2d814fb2019-04-09 18:52:57 +00003883status_t SurfaceFlinger::createLayer(const String8& name, const sp<Client>& client, uint32_t w,
3884 uint32_t h, PixelFormat format, uint32_t flags,
3885 LayerMetadata metadata, sp<IBinder>* handle,
Robert Carrc0df3122019-04-11 13:18:21 -07003886 sp<IGraphicBufferProducer>* gbp,
Valerie Hau1acd6962019-10-28 16:35:48 -07003887 const sp<IBinder>& parentHandle, const sp<Layer>& parentLayer,
3888 uint32_t* outTransformHint) {
Mathias Agopian6e2d6482009-07-09 18:16:43 -07003889 if (int32_t(w|h) < 0) {
Mathias Agopian921e6ac2012-07-23 23:11:29 -07003890 ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
Mathias Agopian6e2d6482009-07-09 18:16:43 -07003891 int(w), int(h));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003892 return BAD_VALUE;
Mathias Agopian6e2d6482009-07-09 18:16:43 -07003893 }
Andreas Huber8b42e8a2010-08-16 08:49:37 -07003894
Robert Carrc0df3122019-04-11 13:18:21 -07003895 ALOG_ASSERT(parentLayer == nullptr || parentHandle == nullptr,
3896 "Expected only one of parentLayer or parentHandle to be non-null. "
3897 "Programmer error?");
3898
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003899 status_t result = NO_ERROR;
3900
3901 sp<Layer> layer;
3902
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003903 std::string uniqueName = getUniqueLayerName(name.string());
Cody Northropbc755282017-03-31 12:00:08 -06003904
Evan Roskya1f1e152019-01-24 16:17:46 -08003905 bool primaryDisplayOnly = false;
3906
3907 // window type is WINDOW_TYPE_DONT_SCREENSHOT from SurfaceControl.java
3908 // TODO b/64227542
3909 if (metadata.has(METADATA_WINDOW_TYPE)) {
3910 int32_t windowType = metadata.getInt32(METADATA_WINDOW_TYPE, 0);
3911 if (windowType == 441731) {
Ady Abraham8f1ee7f2019-04-05 10:32:50 -07003912 metadata.setInt32(METADATA_WINDOW_TYPE, InputWindowInfo::TYPE_NAVIGATION_BAR_PANEL);
Evan Roskya1f1e152019-01-24 16:17:46 -08003913 primaryDisplayOnly = true;
3914 }
3915 }
3916
Mathias Agopian3165cc22012-08-08 19:42:09 -07003917 switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
Marissa Wall61c58622018-07-18 10:12:20 -07003918 case ISurfaceComposerClient::eFXSurfaceBufferQueue:
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003919 result = createBufferQueueLayer(client, std::move(uniqueName), w, h, flags,
3920 std::move(metadata), format, handle, gbp, &layer);
David Sodman0c69cad2017-08-21 12:12:51 -07003921
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003922 break;
Marissa Wall61c58622018-07-18 10:12:20 -07003923 case ISurfaceComposerClient::eFXSurfaceBufferState:
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003924 result = createBufferStateLayer(client, std::move(uniqueName), w, h, flags,
Vishnu Nair6213bd92020-05-08 17:42:25 -07003925 std::move(metadata), handle, &layer);
Marissa Wall61c58622018-07-18 10:12:20 -07003926 break;
Vishnu Nairfa247b12020-02-11 08:58:26 -08003927 case ISurfaceComposerClient::eFXSurfaceEffect:
Vishnu Nair88a11f22018-11-28 18:30:57 -08003928 // check if buffer size is set for color layer.
3929 if (w > 0 || h > 0) {
3930 ALOGE("createLayer() failed, w or h cannot be set for color layer (w=%d, h=%d)",
3931 int(w), int(h));
3932 return BAD_VALUE;
3933 }
3934
Vishnu Nairfa247b12020-02-11 08:58:26 -08003935 result = createEffectLayer(client, std::move(uniqueName), w, h, flags,
3936 std::move(metadata), handle, &layer);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003937 break;
Robert Carr6b3f6c52018-08-13 13:05:17 -07003938 case ISurfaceComposerClient::eFXSurfaceContainer:
Vishnu Nair88a11f22018-11-28 18:30:57 -08003939 // check if buffer size is set for container layer.
3940 if (w > 0 || h > 0) {
3941 ALOGE("createLayer() failed, w or h cannot be set for container layer (w=%d, h=%d)",
3942 int(w), int(h));
3943 return BAD_VALUE;
3944 }
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003945 result = createContainerLayer(client, std::move(uniqueName), w, h, flags,
3946 std::move(metadata), handle, &layer);
Robert Carr6b3f6c52018-08-13 13:05:17 -07003947 break;
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003948 default:
3949 result = BAD_VALUE;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003950 break;
3951 }
3952
Dan Stoza7d89d062015-04-30 13:29:25 -07003953 if (result != NO_ERROR) {
3954 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003955 }
Dan Stoza7d89d062015-04-30 13:29:25 -07003956
Evan Roskya1f1e152019-01-24 16:17:46 -08003957 if (primaryDisplayOnly) {
3958 layer->setPrimaryDisplayOnly();
Chia-I Wuab0c3192017-08-01 11:29:00 -07003959 }
3960
Robert Carrb89ea9d2018-12-10 13:01:14 -08003961 bool addToCurrentState = callingThreadHasUnscopedSurfaceFlingerAccess();
Robert Carrc0df3122019-04-11 13:18:21 -07003962 result = addClientLayer(client, *handle, *gbp, layer, parentHandle, parentLayer,
Vishnu Nair6213bd92020-05-08 17:42:25 -07003963 addToCurrentState, outTransformHint);
Dan Stoza7d89d062015-04-30 13:29:25 -07003964 if (result != NO_ERROR) {
3965 return result;
3966 }
Lloyd Pique4dccc412018-01-22 17:21:36 -08003967 mInterceptor->saveSurfaceCreation(layer);
Dan Stoza7d89d062015-04-30 13:29:25 -07003968
3969 setTransactionFlags(eTransactionNeeded);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003970 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003971}
3972
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003973std::string SurfaceFlinger::getUniqueLayerName(const char* name) {
3974 unsigned dupeCounter = 0;
Cody Northropbc755282017-03-31 12:00:08 -06003975
3976 // Tack on our counter whether there is a hit or not, so everyone gets a tag
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003977 std::string uniqueName = base::StringPrintf("%s#%u", name, dupeCounter);
Cody Northropbc755282017-03-31 12:00:08 -06003978
Dan Stoza436ccf32018-06-21 12:10:12 -07003979 // Grab the state lock since we're accessing mCurrentState
3980 Mutex::Autolock lock(mStateLock);
3981
Cody Northropbc755282017-03-31 12:00:08 -06003982 // Loop over layers until we're sure there is no matching name
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003983 bool matchFound = true;
Cody Northropbc755282017-03-31 12:00:08 -06003984 while (matchFound) {
3985 matchFound = false;
Edgar Arriaga844fa672020-01-16 14:21:42 -08003986 mCurrentState.traverse([&](Layer* layer) {
Cody Northropbc755282017-03-31 12:00:08 -06003987 if (layer->getName() == uniqueName) {
3988 matchFound = true;
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003989 uniqueName = base::StringPrintf("%s#%u", name, ++dupeCounter);
Cody Northropbc755282017-03-31 12:00:08 -06003990 }
3991 });
3992 }
3993
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003994 ALOGV_IF(dupeCounter > 0, "duplicate layer name: changing %s to %s", name, uniqueName.c_str());
Cody Northropbc755282017-03-31 12:00:08 -06003995 return uniqueName;
3996}
3997
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003998status_t SurfaceFlinger::createBufferQueueLayer(const sp<Client>& client, std::string name,
Marissa Wallfd668622018-05-10 10:21:13 -07003999 uint32_t w, uint32_t h, uint32_t flags,
Evan Roskya1f1e152019-01-24 16:17:46 -08004000 LayerMetadata metadata, PixelFormat& format,
4001 sp<IBinder>* handle,
Marissa Wallfd668622018-05-10 10:21:13 -07004002 sp<IGraphicBufferProducer>* gbp,
4003 sp<Layer>* outLayer) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004004 // initialize the surfaces
Mathias Agopian92a979a2012-08-02 18:32:23 -07004005 switch (format) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004006 case PIXEL_FORMAT_TRANSPARENT:
4007 case PIXEL_FORMAT_TRANSLUCENT:
4008 format = PIXEL_FORMAT_RGBA_8888;
4009 break;
4010 case PIXEL_FORMAT_OPAQUE:
Mathias Agopian8f105402010-04-05 18:01:24 -07004011 format = PIXEL_FORMAT_RGBX_8888;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004012 break;
4013 }
4014
chaviwb4c6e582019-08-16 14:35:07 -07004015 sp<BufferQueueLayer> layer;
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004016 LayerCreationArgs args(this, client, std::move(name), w, h, flags, std::move(metadata));
chaviwb4c6e582019-08-16 14:35:07 -07004017 args.textureName = getNewTexture();
4018 {
4019 // Grab the SF state lock during this since it's the only safe way to access
4020 // RenderEngine when creating a BufferLayerConsumer
4021 // TODO: Check if this lock is still needed here
4022 Mutex::Autolock lock(mStateLock);
4023 layer = getFactory().createBufferQueueLayer(args);
4024 }
4025
Marissa Wallfd668622018-05-10 10:21:13 -07004026 status_t err = layer->setDefaultBufferProperties(w, h, format);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004027 if (err == NO_ERROR) {
David Sodman0c69cad2017-08-21 12:12:51 -07004028 *handle = layer->getHandle();
4029 *gbp = layer->getProducer();
4030 *outLayer = layer;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004031 }
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004032
Marissa Wallfd668622018-05-10 10:21:13 -07004033 ALOGE_IF(err, "createBufferQueueLayer() failed (%s)", strerror(-err));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004034 return err;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004035}
4036
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004037status_t SurfaceFlinger::createBufferStateLayer(const sp<Client>& client, std::string name,
Marissa Wall61c58622018-07-18 10:12:20 -07004038 uint32_t w, uint32_t h, uint32_t flags,
Evan Roskya1f1e152019-01-24 16:17:46 -08004039 LayerMetadata metadata, sp<IBinder>* handle,
Vishnu Nair6213bd92020-05-08 17:42:25 -07004040 sp<Layer>* outLayer) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004041 LayerCreationArgs args(this, client, std::move(name), w, h, flags, std::move(metadata));
chaviwb4c6e582019-08-16 14:35:07 -07004042 args.displayDevice = getDefaultDisplayDevice();
4043 args.textureName = getNewTexture();
4044 sp<BufferStateLayer> layer = getFactory().createBufferStateLayer(args);
Marissa Wall61c58622018-07-18 10:12:20 -07004045 *handle = layer->getHandle();
4046 *outLayer = layer;
4047
4048 return NO_ERROR;
4049}
4050
Vishnu Nairfa247b12020-02-11 08:58:26 -08004051status_t SurfaceFlinger::createEffectLayer(const sp<Client>& client, std::string name, uint32_t w,
4052 uint32_t h, uint32_t flags, LayerMetadata metadata,
4053 sp<IBinder>* handle, sp<Layer>* outLayer) {
4054 *outLayer = getFactory().createEffectLayer(
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004055 {this, client, std::move(name), w, h, flags, std::move(metadata)});
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004056 *handle = (*outLayer)->getHandle();
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004057 return NO_ERROR;
Mathias Agopian118d0242011-10-13 16:02:48 -07004058}
4059
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004060status_t SurfaceFlinger::createContainerLayer(const sp<Client>& client, std::string name,
Evan Roskya1f1e152019-01-24 16:17:46 -08004061 uint32_t w, uint32_t h, uint32_t flags,
4062 LayerMetadata metadata, sp<IBinder>* handle,
4063 sp<Layer>* outLayer) {
4064 *outLayer = getFactory().createContainerLayer(
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004065 {this, client, std::move(name), w, h, flags, std::move(metadata)});
Robert Carr6b3f6c52018-08-13 13:05:17 -07004066 *handle = (*outLayer)->getHandle();
4067 return NO_ERROR;
4068}
4069
Robert Carr6fb1a7e2018-12-11 12:07:25 -08004070void SurfaceFlinger::markLayerPendingRemovalLocked(const sp<Layer>& layer) {
Robert Carr2e102c92018-10-23 12:11:15 -07004071 mLayersPendingRemoval.add(layer);
4072 mLayersRemoved = true;
4073 setTransactionFlags(eTransactionNeeded);
4074}
4075
Robert Carr695d5282018-12-18 15:27:58 -08004076void SurfaceFlinger::onHandleDestroyed(sp<Layer>& layer)
Rob Carr4bba3702018-10-08 21:53:30 +00004077{
Robert Carr2e102c92018-10-23 12:11:15 -07004078 Mutex::Autolock lock(mStateLock);
Robert Carr6fb1a7e2018-12-11 12:07:25 -08004079 // If a layer has a parent, we allow it to out-live it's handle
4080 // with the idea that the parent holds a reference and will eventually
4081 // be cleaned up. However no one cleans up the top-level so we do so
4082 // here.
4083 if (layer->getParent() == nullptr) {
4084 mCurrentState.layersSortedByZ.remove(layer);
4085 }
4086 markLayerPendingRemovalLocked(layer);
Robert Carrc0df3122019-04-11 13:18:21 -07004087
4088 auto it = mLayersByLocalBinderToken.begin();
4089 while (it != mLayersByLocalBinderToken.end()) {
4090 if (it->second == layer) {
4091 it = mLayersByLocalBinderToken.erase(it);
4092 } else {
4093 it++;
4094 }
4095 }
4096
Robert Carr695d5282018-12-18 15:27:58 -08004097 layer.clear();
Rob Carr4bba3702018-10-08 21:53:30 +00004098}
4099
Mathias Agopianb60314a2012-04-10 22:09:54 -07004100// ---------------------------------------------------------------------------
4101
Andy McFadden13a082e2012-08-24 10:16:42 -07004102void SurfaceFlinger::onInitializeDisplays() {
Dominik Laskowski83b88212018-12-11 13:34:06 -08004103 const auto display = getDefaultDisplayDeviceLocked();
4104 if (!display) return;
4105
4106 const sp<IBinder> token = display->getDisplayToken().promote();
4107 LOG_ALWAYS_FATAL_IF(token == nullptr);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004108
Jesse Hall01e29052013-02-19 16:13:35 -08004109 // reset screen orientation and use primary layer stack
Andy McFadden13a082e2012-08-24 10:16:42 -07004110 Vector<ComposerState> state;
4111 Vector<DisplayState> displays;
4112 DisplayState d;
Jesse Hall01e29052013-02-19 16:13:35 -08004113 d.what = DisplayState::eDisplayProjectionChanged |
4114 DisplayState::eLayerStackChanged;
Dominik Laskowski83b88212018-12-11 13:34:06 -08004115 d.token = token;
Jesse Hall01e29052013-02-19 16:13:35 -08004116 d.layerStack = 0;
Dominik Laskowski718f9602019-11-09 20:01:35 -08004117 d.orientation = ui::ROTATION_0;
Jeff Brown4c05dd12012-09-09 00:07:17 -07004118 d.frame.makeInvalid();
4119 d.viewport.makeInvalid();
Michael Lentine47e45402014-07-18 15:34:25 -07004120 d.width = 0;
4121 d.height = 0;
Andy McFadden13a082e2012-08-24 10:16:42 -07004122 displays.add(d);
Valerie Hau9dab9732019-08-20 09:29:25 -07004123 setTransactionState(state, displays, 0, nullptr, mPendingInputWindowCommands, -1, {}, false,
4124 {});
Jamie Gennis6547ff42013-07-16 20:12:42 -07004125
Peiyong Lin65248e02020-04-18 21:15:07 -07004126 setPowerModeInternal(display, hal::PowerMode::ON);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004127
Dominik Laskowski83b88212018-12-11 13:34:06 -08004128 const nsecs_t vsyncPeriod = getVsyncPeriod();
4129 mAnimFrameTracker.setDisplayRefreshPeriod(vsyncPeriod);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08004130
Brian Andersond0010582017-03-07 13:20:31 -08004131 // Use phase of 0 since phase is not known.
4132 // Use latency of 0, which will snap to the ideal latency.
Dominik Laskowski83b88212018-12-11 13:34:06 -08004133 DisplayStatInfo stats{0 /* vsyncTime */, vsyncPeriod};
Ana Krulece588e312018-09-18 12:32:24 -07004134 setCompositorTimingSnapped(stats, 0);
Andy McFadden13a082e2012-08-24 10:16:42 -07004135}
4136
4137void SurfaceFlinger::initializeDisplays() {
Dominik Laskowski8c001672018-05-30 16:52:06 -07004138 // Async since we may be called from the main thread.
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07004139 static_cast<void>(schedule([this]() NO_THREAD_SAFETY_ANALYSIS { onInitializeDisplays(); }));
Andy McFadden13a082e2012-08-24 10:16:42 -07004140}
4141
Peiyong Line9d809e2020-04-14 13:10:48 -07004142void SurfaceFlinger::setVsyncEnabledInHWC(DisplayId displayId, hal::Vsync enabled) {
Ady Abraham27c70212019-06-11 10:52:26 -07004143 if (mHWCVsyncState != enabled) {
4144 getHwComposer().setVsyncEnabled(displayId, enabled);
4145 mHWCVsyncState = enabled;
4146 }
4147}
4148
Peiyong Lin65248e02020-04-18 21:15:07 -07004149void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& display, hal::PowerMode mode) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004150 if (display->isVirtual()) {
4151 ALOGE("%s: Invalid operation on virtual display", __FUNCTION__);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004152 return;
4153 }
4154
Dominik Laskowski075d3172018-05-24 15:50:06 -07004155 const auto displayId = display->getId();
4156 LOG_ALWAYS_FATAL_IF(!displayId);
4157
Dominik Laskowski34157762018-10-31 13:07:19 -07004158 ALOGD("Setting power mode %d on display %s", mode, to_string(*displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004159
Peiyong Lin65248e02020-04-18 21:15:07 -07004160 const hal::PowerMode currentMode = display->getPowerMode();
Dominik Laskowski075d3172018-05-24 15:50:06 -07004161 if (mode == currentMode) {
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004162 return;
4163 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004164
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004165 display->setPowerMode(mode);
4166
Lloyd Pique4dccc412018-01-22 17:21:36 -08004167 if (mInterceptor->isEnabled()) {
Peiyong Lin65248e02020-04-18 21:15:07 -07004168 mInterceptor->savePowerModeUpdate(display->getSequenceId(), static_cast<int32_t>(mode));
Irvelffc9efc2016-07-27 15:16:37 -07004169 }
4170
Peiyong Lin65248e02020-04-18 21:15:07 -07004171 if (currentMode == hal::PowerMode::OFF) {
Martin Liu4a322352020-03-24 21:30:38 +08004172 if (SurfaceFlinger::setSchedFifo(true) != NO_ERROR) {
4173 ALOGW("Couldn't set SCHED_FIFO on display on: %s\n", strerror(errno));
4174 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07004175 getHwComposer().setPowerMode(*displayId, mode);
Peiyong Lin65248e02020-04-18 21:15:07 -07004176 if (display->isPrimary() && mode != hal::PowerMode::DOZE_SUSPEND) {
Ady Abraham27c70212019-06-11 10:52:26 -07004177 setVsyncEnabledInHWC(*displayId, mHWCVsyncPendingState);
Ana Krulecc2870422019-01-29 19:00:58 -08004178 mScheduler->onScreenAcquired(mAppConnectionHandle);
4179 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004180 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004181
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004182 mVisibleRegionsDirty = true;
Dan Stozab90cf072015-03-05 11:05:59 -08004183 mHasPoweredOff = true;
Dan Stozac7a25ad2018-04-12 11:45:09 -07004184 repaintEverything();
Peiyong Lin65248e02020-04-18 21:15:07 -07004185 } else if (mode == hal::PowerMode::OFF) {
Tim Murrayf9d4e442016-08-02 15:43:59 -07004186 // Turn off the display
Martin Liu4a322352020-03-24 21:30:38 +08004187 if (SurfaceFlinger::setSchedFifo(false) != NO_ERROR) {
4188 ALOGW("Couldn't set SCHED_OTHER on display off: %s\n", strerror(errno));
Tim Murrayf9d4e442016-08-02 15:43:59 -07004189 }
Peiyong Lin65248e02020-04-18 21:15:07 -07004190 if (display->isPrimary() && currentMode != hal::PowerMode::DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08004191 mScheduler->disableHardwareVsync(true);
4192 mScheduler->onScreenReleased(mAppConnectionHandle);
Mathias Agopiancde87a32012-09-13 14:09:01 -07004193 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004194
Ady Abraham27c70212019-06-11 10:52:26 -07004195 // Make sure HWVsync is disabled before turning off the display
Peiyong Line9d809e2020-04-14 13:10:48 -07004196 setVsyncEnabledInHWC(*displayId, hal::Vsync::DISABLE);
Ady Abraham27c70212019-06-11 10:52:26 -07004197
Dominik Laskowski075d3172018-05-24 15:50:06 -07004198 getHwComposer().setPowerMode(*displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004199 mVisibleRegionsDirty = true;
4200 // from this point on, SF will stop drawing on this display
Peiyong Lin65248e02020-04-18 21:15:07 -07004201 } else if (mode == hal::PowerMode::DOZE || mode == hal::PowerMode::ON) {
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004202 // Update display while dozing
Dominik Laskowski075d3172018-05-24 15:50:06 -07004203 getHwComposer().setPowerMode(*displayId, mode);
Peiyong Lin65248e02020-04-18 21:15:07 -07004204 if (display->isPrimary() && currentMode == hal::PowerMode::DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08004205 mScheduler->onScreenAcquired(mAppConnectionHandle);
4206 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004207 }
Peiyong Lin65248e02020-04-18 21:15:07 -07004208 } else if (mode == hal::PowerMode::DOZE_SUSPEND) {
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004209 // Leave display going to doze
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004210 if (display->isPrimary()) {
Ana Krulecc2870422019-01-29 19:00:58 -08004211 mScheduler->disableHardwareVsync(true);
4212 mScheduler->onScreenReleased(mAppConnectionHandle);
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004213 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07004214 getHwComposer().setPowerMode(*displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004215 } else {
Matthew Bouyack38d49612017-05-12 12:49:32 -07004216 ALOGE("Attempting to set unknown power mode: %d\n", mode);
Dominik Laskowski075d3172018-05-24 15:50:06 -07004217 getHwComposer().setPowerMode(*displayId, mode);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004218 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004219
Yiwei Zhang3a226d22018-10-16 09:23:03 -07004220 if (display->isPrimary()) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08004221 mTimeStats->setPowerMode(mode);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07004222 mRefreshRateStats->setPowerMode(mode);
Peiyong Lin65248e02020-04-18 21:15:07 -07004223 mScheduler->setDisplayPowerState(mode == hal::PowerMode::ON);
Yiwei Zhang3a226d22018-10-16 09:23:03 -07004224 }
4225
Dominik Laskowski34157762018-10-31 13:07:19 -07004226 ALOGD("Finished setting power mode %d on display %s", mode, to_string(*displayId).c_str());
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004227}
4228
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004229void SurfaceFlinger::setPowerMode(const sp<IBinder>& displayToken, int mode) {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07004230 schedule([=]() NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07004231 const auto display = getDisplayDeviceLocked(displayToken);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004232 if (!display) {
4233 ALOGE("Attempt to set power mode %d for invalid display token %p", mode,
4234 displayToken.get());
4235 } else if (display->isVirtual()) {
4236 ALOGW("Attempt to set power mode %d for virtual display", mode);
4237 } else {
Peiyong Lin65248e02020-04-18 21:15:07 -07004238 setPowerModeInternal(display, static_cast<hal::PowerMode>(mode));
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004239 }
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07004240 }).wait();
Mathias Agopianb60314a2012-04-10 22:09:54 -07004241}
4242
Dominik Laskowskic2867142019-01-21 11:33:38 -08004243status_t SurfaceFlinger::doDump(int fd, const DumpArgs& args,
4244 bool asProto) NO_THREAD_SAFETY_ANALYSIS {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004245 std::string result;
Mathias Agopian99b49842011-06-27 16:05:52 -07004246
Mathias Agopianbd115332013-04-18 16:41:04 -07004247 IPCThreadState* ipc = IPCThreadState::self();
4248 const int pid = ipc->getCallingPid();
4249 const int uid = ipc->getCallingUid();
Vishnu Nair6a408532017-10-24 09:11:27 -07004250
Mathias Agopianbd115332013-04-18 16:41:04 -07004251 if ((uid != AID_SHELL) &&
4252 !PermissionCache::checkPermission(sDump, pid, uid)) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004253 StringAppendF(&result, "Permission Denial: can't dump SurfaceFlinger from pid=%d, uid=%d\n",
4254 pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004255 } else {
Jesse Hallfcd15b42014-12-23 13:57:23 -08004256 // Try to get the main lock, but give up after one second
Mathias Agopian9795c422009-08-26 16:36:26 -07004257 // (this would indicate SF is stuck, but we want to be able to
4258 // print something in dumpsys).
Jesse Hallfcd15b42014-12-23 13:57:23 -08004259 status_t err = mStateLock.timedLock(s2ns(1));
4260 bool locked = (err == NO_ERROR);
Mathias Agopian9795c422009-08-26 16:36:26 -07004261 if (!locked) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004262 StringAppendF(&result,
4263 "SurfaceFlinger appears to be unresponsive (%s [%d]), dumping anyways "
4264 "(no locks held)\n",
4265 strerror(-err), err);
Mathias Agopian9795c422009-08-26 16:36:26 -07004266 }
4267
Dominik Laskowskic2867142019-01-21 11:33:38 -08004268 static const std::unordered_map<std::string, Dumper> dumpers = {
Dominik Laskowskic2867142019-01-21 11:33:38 -08004269 {"--display-id"s, dumper(&SurfaceFlinger::dumpDisplayIdentificationData)},
Dominik Laskowski98041832019-08-01 18:35:59 -07004270 {"--dispsync"s,
4271 dumper([this](std::string& s) { mScheduler->getPrimaryDispSync().dump(s); })},
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004272 {"--edid"s, argsDumper(&SurfaceFlinger::dumpRawDisplayIdentificationData)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08004273 {"--frame-events"s, dumper(&SurfaceFlinger::dumpFrameEventsLocked)},
4274 {"--latency"s, argsDumper(&SurfaceFlinger::dumpStatsLocked)},
4275 {"--latency-clear"s, argsDumper(&SurfaceFlinger::clearStatsLocked)},
4276 {"--list"s, dumper(&SurfaceFlinger::listLayersLocked)},
4277 {"--static-screen"s, dumper(&SurfaceFlinger::dumpStaticScreenStats)},
4278 {"--timestats"s, protoDumper(&SurfaceFlinger::dumpTimeStats)},
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004279 {"--vsync"s, dumper(&SurfaceFlinger::dumpVSync)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08004280 {"--wide-color"s, dumper(&SurfaceFlinger::dumpWideColorInfo)},
4281 };
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004282
Dominik Laskowskic2867142019-01-21 11:33:38 -08004283 const auto flag = args.empty() ? ""s : std::string(String8(args[0]));
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004284
Dominik Laskowski46470112019-08-02 13:13:11 -07004285 const auto it = dumpers.find(flag);
4286 if (it != dumpers.end()) {
Dominik Laskowskic2867142019-01-21 11:33:38 -08004287 (it->second)(args, asProto, result);
Vishnu Nair8406fd72019-07-30 11:29:31 -07004288 } else if (!asProto) {
4289 dumpAllLocked(args, result);
Mathias Agopian48b888a2011-01-19 16:15:53 -08004290 }
4291
Mathias Agopian9795c422009-08-26 16:36:26 -07004292 if (locked) {
4293 mStateLock.unlock();
4294 }
Vishnu Nair8406fd72019-07-30 11:29:31 -07004295
Dominik Laskowski46470112019-08-02 13:13:11 -07004296 if (it == dumpers.end()) {
4297 const LayersProto layersProto = dumpProtoFromMainThread();
4298 if (asProto) {
4299 result.append(layersProto.SerializeAsString());
4300 } else {
Vishnu Nair0f085c62019-08-30 08:49:12 -07004301 // Dump info that we need to access from the main thread
Dominik Laskowski46470112019-08-02 13:13:11 -07004302 const auto layerTree = LayerProtoParser::generateLayerTree(layersProto);
4303 result.append(LayerProtoParser::layerTreeToString(layerTree));
4304 result.append("\n");
Vishnu Nair0f085c62019-08-30 08:49:12 -07004305 dumpOffscreenLayers(result);
Dominik Laskowski46470112019-08-02 13:13:11 -07004306 }
Vishnu Nair8406fd72019-07-30 11:29:31 -07004307 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004308 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08004309 write(fd, result.c_str(), result.size());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004310 return NO_ERROR;
4311}
4312
Nataniel Borges8e7dc722019-02-28 15:10:28 -08004313status_t SurfaceFlinger::dumpCritical(int fd, const DumpArgs&, bool asProto) {
4314 if (asProto && mTracing.isEnabled()) {
4315 mTracing.writeToFileAsync();
4316 }
4317
4318 return doDump(fd, DumpArgs(), asProto);
4319}
4320
Dominik Laskowskic2867142019-01-21 11:33:38 -08004321void SurfaceFlinger::listLayersLocked(std::string& result) const {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004322 mCurrentState.traverseInZOrder(
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004323 [&](Layer* layer) { StringAppendF(&result, "%s\n", layer->getDebugName()); });
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004324}
4325
Dominik Laskowskic2867142019-01-21 11:33:38 -08004326void SurfaceFlinger::dumpStatsLocked(const DumpArgs& args, std::string& result) const {
Dominik Laskowski83b88212018-12-11 13:34:06 -08004327 StringAppendF(&result, "%" PRId64 "\n", getVsyncPeriod());
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004328
Dominik Laskowskic2867142019-01-21 11:33:38 -08004329 if (args.size() > 1) {
4330 const auto name = String8(args[1]);
Robert Carr2047fae2016-11-28 14:09:09 -08004331 mCurrentState.traverseInZOrder([&](Layer* layer) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004332 if (layer->getName() == name.string()) {
Svetoslavd85084b2014-03-20 10:28:31 -07004333 layer->dumpFrameStats(result);
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004334 }
Robert Carr2047fae2016-11-28 14:09:09 -08004335 });
Dominik Laskowskic2867142019-01-21 11:33:38 -08004336 } else {
4337 mAnimFrameTracker.dumpStats(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004338 }
4339}
4340
Dominik Laskowskic2867142019-01-21 11:33:38 -08004341void SurfaceFlinger::clearStatsLocked(const DumpArgs& args, std::string&) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004342 const bool clearAll = args.size() < 2;
4343 const auto name = clearAll ? String8() : String8(args[1]);
4344
Edgar Arriaga844fa672020-01-16 14:21:42 -08004345 mCurrentState.traverse([&](Layer* layer) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004346 if (clearAll || layer->getName() == name.string()) {
Svetoslavd85084b2014-03-20 10:28:31 -07004347 layer->clearFrameStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004348 }
Robert Carr2047fae2016-11-28 14:09:09 -08004349 });
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004350
Svetoslavd85084b2014-03-20 10:28:31 -07004351 mAnimFrameTracker.clearStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004352}
4353
Dominik Laskowskic2867142019-01-21 11:33:38 -08004354void SurfaceFlinger::dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const {
4355 mTimeStats->parseArgs(asProto, args, result);
4356}
4357
Jamie Gennis6547ff42013-07-16 20:12:42 -07004358// This should only be called from the main thread. Otherwise it would need
4359// the lock and should use mCurrentState rather than mDrawingState.
4360void SurfaceFlinger::logFrameStats() {
Edgar Arriaga844fa672020-01-16 14:21:42 -08004361 mDrawingState.traverse([&](Layer* layer) {
Jamie Gennis6547ff42013-07-16 20:12:42 -07004362 layer->logFrameStats();
Robert Carr2047fae2016-11-28 14:09:09 -08004363 });
Jamie Gennis6547ff42013-07-16 20:12:42 -07004364
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004365 mAnimFrameTracker.logAndResetStats("<win-anim>");
Jamie Gennis6547ff42013-07-16 20:12:42 -07004366}
4367
Yiwei Zhang5434a782018-12-05 18:06:32 -08004368void SurfaceFlinger::appendSfConfigString(std::string& result) const {
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004369 result.append(" [sf");
Fabien Sanglardc93afd52017-03-13 13:02:42 -07004370
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004371 if (isLayerTripleBufferingDisabled())
4372 result.append(" DISABLE_TRIPLE_BUFFERING");
Fabien Sanglardc45a7d92017-03-14 13:24:22 -07004373
Yiwei Zhang5434a782018-12-05 18:06:32 -08004374 StringAppendF(&result, " PRESENT_TIME_OFFSET=%" PRId64, dispSyncPresentTimeOffset);
4375 StringAppendF(&result, " FORCE_HWC_FOR_RBG_TO_YUV=%d", useHwcForRgbToYuv);
4376 StringAppendF(&result, " MAX_VIRT_DISPLAY_DIM=%" PRIu64, maxVirtualDisplaySize);
4377 StringAppendF(&result, " RUNNING_WITHOUT_SYNC_FRAMEWORK=%d", !hasSyncFramework);
4378 StringAppendF(&result, " NUM_FRAMEBUFFER_SURFACE_BUFFERS=%" PRId64,
4379 maxFrameBufferAcquiredBuffers);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004380 result.append("]");
Andy McFadden4803b742012-09-24 19:07:20 -07004381}
4382
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004383void SurfaceFlinger::dumpVSync(std::string& result) const {
Dominik Laskowski98041832019-08-01 18:35:59 -07004384 mScheduler->dump(result);
Dominik Laskowski98041832019-08-01 18:35:59 -07004385
Steven Thomas2bbaabe2019-08-28 16:08:35 -07004386 mRefreshRateStats->dump(result);
Dominik Laskowski98041832019-08-01 18:35:59 -07004387 result.append("\n");
4388
Ady Abraham9e16a482019-12-03 17:19:41 -08004389 mPhaseConfiguration->dump(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004390 StringAppendF(&result,
Dominik Laskowski98041832019-08-01 18:35:59 -07004391 " present offset: %9" PRId64 " ns\t VSYNC period: %9" PRId64 " ns\n\n",
Ana Krulec757f63a2019-01-25 10:46:18 -08004392 dispSyncPresentTimeOffset, getVsyncPeriod());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004393
Steven Thomasd4071902020-03-24 16:02:53 -07004394 scheduler::RefreshRateConfigs::Policy policy = mRefreshRateConfigs->getDisplayManagerPolicy();
Ana Krulec234bb162019-11-10 22:55:55 +01004395 StringAppendF(&result,
Ady Abraham07e54702020-04-16 15:05:37 -07004396 "DesiredDisplayConfigSpecs (DisplayManager): default config ID: %d"
Steven Thomasf734df42020-04-13 21:09:28 -07004397 ", primary range: [%.2f %.2f], app request range: [%.2f %.2f]\n\n",
4398 policy.defaultConfig.value(), policy.primaryRange.min, policy.primaryRange.max,
4399 policy.appRequestRange.min, policy.appRequestRange.max);
Ady Abraham42b3beb2019-07-09 18:09:52 -07004400 StringAppendF(&result, "(config override by backdoor: %s)\n\n",
4401 mDebugDisplayConfigSetByBackdoor ? "yes" : "no");
Ady Abraham07e54702020-04-16 15:05:37 -07004402 scheduler::RefreshRateConfigs::Policy currentPolicy = mRefreshRateConfigs->getCurrentPolicy();
4403 if (currentPolicy != policy) {
4404 StringAppendF(&result,
4405 "DesiredDisplayConfigSpecs (Override): default config ID: %d"
Steven Thomasf734df42020-04-13 21:09:28 -07004406 ", primary range: [%.2f %.2f], app request range: [%.2f %.2f]\n\n",
4407 currentPolicy.defaultConfig.value(), currentPolicy.primaryRange.min,
4408 currentPolicy.primaryRange.max, currentPolicy.appRequestRange.min,
4409 currentPolicy.appRequestRange.max);
Ady Abraham07e54702020-04-16 15:05:37 -07004410 }
Dominik Laskowski98041832019-08-01 18:35:59 -07004411
Ana Krulecc2870422019-01-29 19:00:58 -08004412 mScheduler->dump(mAppConnectionHandle, result);
Ady Abraham75398722020-04-07 14:08:45 -07004413 mScheduler->getPrimaryDispSync().dump(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004414}
4415
Yiwei Zhang5434a782018-12-05 18:06:32 -08004416void SurfaceFlinger::dumpStaticScreenStats(std::string& result) const {
4417 result.append("Static screen stats:\n");
David Sodman4a36e932017-11-07 14:29:47 -08004418 for (size_t b = 0; b < SurfaceFlingerBE::NUM_BUCKETS - 1; ++b) {
4419 float bucketTimeSec = getBE().mFrameBuckets[b] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08004420 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08004421 static_cast<float>(getBE().mFrameBuckets[b]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004422 StringAppendF(&result, " < %zd frames: %.3f s (%.1f%%)\n", b + 1, bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08004423 }
David Sodman4a36e932017-11-07 14:29:47 -08004424 float bucketTimeSec = getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08004425 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08004426 static_cast<float>(getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004427 StringAppendF(&result, " %zd+ frames: %.3f s (%.1f%%)\n", SurfaceFlingerBE::NUM_BUCKETS - 1,
4428 bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08004429}
4430
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004431void SurfaceFlinger::recordBufferingStats(const std::string& layerName,
4432 std::vector<OccupancyTracker::Segment>&& history) {
David Sodmancbaf0832017-11-07 14:21:36 -08004433 Mutex::Autolock lock(getBE().mBufferingStatsMutex);
4434 auto& stats = getBE().mBufferingStats[layerName];
Dan Stozae77c7662016-05-13 11:37:28 -07004435 for (const auto& segment : history) {
4436 if (!segment.usedThirdBuffer) {
4437 stats.twoBufferTime += segment.totalTime;
4438 }
4439 if (segment.occupancyAverage < 1.0f) {
4440 stats.doubleBufferedTime += segment.totalTime;
4441 } else if (segment.occupancyAverage < 2.0f) {
4442 stats.tripleBufferedTime += segment.totalTime;
4443 }
4444 ++stats.numSegments;
4445 stats.totalTime += segment.totalTime;
4446 }
4447}
4448
Yiwei Zhang5434a782018-12-05 18:06:32 -08004449void SurfaceFlinger::dumpFrameEventsLocked(std::string& result) {
4450 result.append("Layer frame timestamps:\n");
Brian Andersond6927fb2016-07-23 23:37:30 -07004451
4452 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
4453 const size_t count = currentLayers.size();
4454 for (size_t i=0 ; i<count ; i++) {
4455 currentLayers[i]->dumpFrameEvents(result);
4456 }
4457}
4458
Yiwei Zhang5434a782018-12-05 18:06:32 -08004459void SurfaceFlinger::dumpBufferingStats(std::string& result) const {
Dan Stozae77c7662016-05-13 11:37:28 -07004460 result.append("Buffering stats:\n");
4461 result.append(" [Layer name] <Active time> <Two buffer> "
4462 "<Double buffered> <Triple buffered>\n");
David Sodmancbaf0832017-11-07 14:21:36 -08004463 Mutex::Autolock lock(getBE().mBufferingStatsMutex);
Dan Stozae77c7662016-05-13 11:37:28 -07004464 typedef std::tuple<std::string, float, float, float> BufferTuple;
4465 std::map<float, BufferTuple, std::greater<float>> sorted;
David Sodmancbaf0832017-11-07 14:21:36 -08004466 for (const auto& statsPair : getBE().mBufferingStats) {
Dan Stozae77c7662016-05-13 11:37:28 -07004467 const char* name = statsPair.first.c_str();
David Sodmancbaf0832017-11-07 14:21:36 -08004468 const SurfaceFlingerBE::BufferingStats& stats = statsPair.second;
Dan Stozae77c7662016-05-13 11:37:28 -07004469 if (stats.numSegments == 0) {
4470 continue;
4471 }
4472 float activeTime = ns2ms(stats.totalTime) / 1000.0f;
4473 float twoBufferRatio = static_cast<float>(stats.twoBufferTime) /
4474 stats.totalTime;
4475 float doubleBufferRatio = static_cast<float>(
4476 stats.doubleBufferedTime) / stats.totalTime;
4477 float tripleBufferRatio = static_cast<float>(
4478 stats.tripleBufferedTime) / stats.totalTime;
4479 sorted.insert({activeTime, {name, twoBufferRatio,
4480 doubleBufferRatio, tripleBufferRatio}});
4481 }
4482 for (const auto& sortedPair : sorted) {
4483 float activeTime = sortedPair.first;
4484 const BufferTuple& values = sortedPair.second;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004485 StringAppendF(&result, " [%s] %.2f %.3f %.3f %.3f\n", std::get<0>(values).c_str(),
4486 activeTime, std::get<1>(values), std::get<2>(values), std::get<3>(values));
Dan Stozae77c7662016-05-13 11:37:28 -07004487 }
4488 result.append("\n");
4489}
4490
Yiwei Zhang5434a782018-12-05 18:06:32 -08004491void SurfaceFlinger::dumpDisplayIdentificationData(std::string& result) const {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004492 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004493 const auto displayId = display->getId();
4494 if (!displayId) {
4495 continue;
4496 }
4497 const auto hwcDisplayId = getHwComposer().fromPhysicalDisplayId(*displayId);
Dominik Laskowski7e045462018-05-30 13:02:02 -07004498 if (!hwcDisplayId) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004499 continue;
4500 }
4501
Yiwei Zhang5434a782018-12-05 18:06:32 -08004502 StringAppendF(&result,
4503 "Display %s (HWC display %" PRIu64 "): ", to_string(*displayId).c_str(),
4504 *hwcDisplayId);
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004505 uint8_t port;
4506 DisplayIdentificationData data;
Dominik Laskowski7e045462018-05-30 13:02:02 -07004507 if (!getHwComposer().getDisplayIdentificationData(*hwcDisplayId, &port, &data)) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004508 result.append("no identification data\n");
4509 continue;
4510 }
4511
4512 if (!isEdid(data)) {
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004513 result.append("unknown identification data\n");
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004514 continue;
4515 }
4516
4517 const auto edid = parseEdid(data);
4518 if (!edid) {
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004519 result.append("invalid EDID\n");
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004520 continue;
4521 }
4522
Yiwei Zhang5434a782018-12-05 18:06:32 -08004523 StringAppendF(&result, "port=%u pnpId=%s displayName=\"", port, edid->pnpId.data());
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004524 result.append(edid->displayName.data(), edid->displayName.length());
4525 result.append("\"\n");
4526 }
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004527}
4528
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004529void SurfaceFlinger::dumpRawDisplayIdentificationData(const DumpArgs& args,
4530 std::string& result) const {
Peiyong Line9d809e2020-04-14 13:10:48 -07004531 hal::HWDisplayId hwcDisplayId;
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004532 uint8_t port;
4533 DisplayIdentificationData data;
4534
4535 if (args.size() > 1 && base::ParseUint(String8(args[1]), &hwcDisplayId) &&
4536 getHwComposer().getDisplayIdentificationData(hwcDisplayId, &port, &data)) {
4537 result.append(reinterpret_cast<const char*>(data.data()), data.size());
4538 }
4539}
4540
Yiwei Zhang5434a782018-12-05 18:06:32 -08004541void SurfaceFlinger::dumpWideColorInfo(std::string& result) const {
Peiyong Linff84a152019-05-17 18:36:19 -07004542 StringAppendF(&result, "Device has wide color built-in display: %d\n", hasWideColorDisplay);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004543 StringAppendF(&result, "Device uses color management: %d\n", useColorManagement);
4544 StringAppendF(&result, "DisplayColorSetting: %s\n",
4545 decodeDisplayColorSetting(mDisplayColorSetting).c_str());
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004546
4547 // TODO: print out if wide-color mode is active or not
4548
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004549 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004550 const auto displayId = display->getId();
4551 if (!displayId) {
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004552 continue;
4553 }
4554
Yiwei Zhang5434a782018-12-05 18:06:32 -08004555 StringAppendF(&result, "Display %s color modes:\n", to_string(*displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004556 std::vector<ColorMode> modes = getHwComposer().getColorModes(*displayId);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004557 for (auto&& mode : modes) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004558 StringAppendF(&result, " %s (%d)\n", decodeColorMode(mode).c_str(), mode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004559 }
4560
Lloyd Pique32cbe282018-10-19 13:09:22 -07004561 ColorMode currentMode = display->getCompositionDisplay()->getState().colorMode;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004562 StringAppendF(&result, " Current color mode: %s (%d)\n",
4563 decodeColorMode(currentMode).c_str(), currentMode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004564 }
4565 result.append("\n");
4566}
4567
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07004568LayersProto SurfaceFlinger::dumpDrawingStateProto(uint32_t traceFlags) const {
4569 // If context is SurfaceTracing thread, mTracingLock blocks display transactions on main thread.
4570 const auto display = getDefaultDisplayDeviceLocked();
4571
chaviw1d044282017-09-27 12:19:28 -07004572 LayersProto layersProto;
chaviw08f3cb22020-01-13 13:17:21 -08004573 for (const sp<Layer>& layer : mDrawingState.layersSortedByZ) {
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07004574 layer->writeToProto(layersProto, traceFlags, display);
chaviw08f3cb22020-01-13 13:17:21 -08004575 }
Alec Mouri6b9e9912020-01-21 10:50:24 -08004576
chaviw1d044282017-09-27 12:19:28 -07004577 return layersProto;
4578}
4579
Alec Mouri6b9e9912020-01-21 10:50:24 -08004580void SurfaceFlinger::dumpHwc(std::string& result) const {
4581 getHwComposer().dump(result);
4582}
4583
Vishnu Nair0f085c62019-08-30 08:49:12 -07004584void SurfaceFlinger::dumpOffscreenLayersProto(LayersProto& layersProto, uint32_t traceFlags) const {
4585 // Add a fake invisible root layer to the proto output and parent all the offscreen layers to
4586 // it.
4587 LayerProto* rootProto = layersProto.add_layers();
4588 const int32_t offscreenRootLayerId = INT32_MAX - 2;
4589 rootProto->set_id(offscreenRootLayerId);
4590 rootProto->set_name("Offscreen Root");
Vishnu Naird5aeb612019-09-20 14:39:39 -07004591 rootProto->set_parent(-1);
Vishnu Nair0f085c62019-08-30 08:49:12 -07004592
4593 for (Layer* offscreenLayer : mOffscreenLayers) {
4594 // Add layer as child of the fake root
4595 rootProto->add_children(offscreenLayer->sequence);
4596
4597 // Add layer
Alec Mouri6b9e9912020-01-21 10:50:24 -08004598 LayerProto* layerProto =
4599 offscreenLayer->writeToProto(layersProto, traceFlags, nullptr /*device*/);
Vishnu Nair0f085c62019-08-30 08:49:12 -07004600 layerProto->set_parent(offscreenRootLayerId);
Vishnu Nair0f085c62019-08-30 08:49:12 -07004601 }
4602}
4603
Vishnu Nair8406fd72019-07-30 11:29:31 -07004604LayersProto SurfaceFlinger::dumpProtoFromMainThread(uint32_t traceFlags) {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07004605 return schedule([=] { return dumpDrawingStateProto(traceFlags); }).get();
Vishnu Nair8406fd72019-07-30 11:29:31 -07004606}
4607
Vishnu Nair0f085c62019-08-30 08:49:12 -07004608void SurfaceFlinger::dumpOffscreenLayers(std::string& result) {
4609 result.append("Offscreen Layers:\n");
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07004610 result.append(schedule([this] {
4611 std::string result;
4612 for (Layer* offscreenLayer : mOffscreenLayers) {
4613 offscreenLayer->traverse(LayerVector::StateSet::Drawing,
4614 [&](Layer* layer) {
4615 layer->dumpCallingUidPid(result);
4616 });
4617 }
4618 return result;
4619 }).get());
Vishnu Nair0f085c62019-08-30 08:49:12 -07004620}
4621
Dominik Laskowskic2867142019-01-21 11:33:38 -08004622void SurfaceFlinger::dumpAllLocked(const DumpArgs& args, std::string& result) const {
4623 const bool colorize = !args.empty() && args[0] == String16("--color");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004624 Colorizer colorizer(colorize);
4625
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004626 // figure out if we're stuck somewhere
4627 const nsecs_t now = systemTime();
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004628 const nsecs_t inTransaction(mDebugInTransaction);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004629 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
4630
4631 /*
Andy McFadden4803b742012-09-24 19:07:20 -07004632 * Dump library configuration.
4633 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004634
4635 colorizer.bold(result);
Andy McFadden4803b742012-09-24 19:07:20 -07004636 result.append("Build configuration:");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004637 colorizer.reset(result);
Andy McFadden4803b742012-09-24 19:07:20 -07004638 appendSfConfigString(result);
4639 appendUiConfigString(result);
4640 appendGuiConfigString(result);
4641 result.append("\n");
4642
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004643 result.append("\nDisplay identification data:\n");
4644 dumpDisplayIdentificationData(result);
4645
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004646 result.append("\nWide-Color information:\n");
4647 dumpWideColorInfo(result);
4648
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004649 colorizer.bold(result);
Mathias Agopianca088332013-03-28 17:44:13 -07004650 result.append("Sync configuration: ");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004651 colorizer.reset(result);
Mathias Agopianca088332013-03-28 17:44:13 -07004652 result.append(SyncFeatures::getInstance().toString());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004653 result.append("\n\n");
Mathias Agopianca088332013-03-28 17:44:13 -07004654
Andy McFadden41d67d72014-04-25 16:58:34 -07004655 colorizer.bold(result);
Dominik Laskowski98041832019-08-01 18:35:59 -07004656 result.append("Scheduler:\n");
Andy McFadden41d67d72014-04-25 16:58:34 -07004657 colorizer.reset(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004658 dumpVSync(result);
Dan Stozab90cf072015-03-05 11:05:59 -08004659 result.append("\n");
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004660
Dan Stozab90cf072015-03-05 11:05:59 -08004661 dumpStaticScreenStats(result);
4662 result.append("\n");
4663
Alec Mouri40189b02019-03-05 15:07:54 -08004664 StringAppendF(&result, "Total missed frame count: %u\n", mFrameMissedCount.load());
4665 StringAppendF(&result, "HWC missed frame count: %u\n", mHwcFrameMissedCount.load());
4666 StringAppendF(&result, "GPU missed frame count: %u\n\n", mGpuFrameMissedCount.load());
Marissa Wallcfcdaa52018-05-21 15:45:59 -07004667
Dan Stozae77c7662016-05-13 11:37:28 -07004668 dumpBufferingStats(result);
4669
Andy McFadden4803b742012-09-24 19:07:20 -07004670 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004671 * Dump the visible layer list
4672 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004673 colorizer.bold(result);
chaviweadf0d42019-08-12 13:28:29 -07004674 StringAppendF(&result, "Visible layers (count = %zu)\n", mNumLayers.load());
Yiwei Zhang5434a782018-12-05 18:06:32 -08004675 StringAppendF(&result, "GraphicBufferProducers: %zu, max %zu\n",
4676 mGraphicBufferProducerList.size(), mMaxGraphicBufferProducerListSize);
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004677 colorizer.reset(result);
chaviw1d044282017-09-27 12:19:28 -07004678
Chia-I Wu2f884132018-09-13 15:17:58 -07004679 {
Lloyd Pique207def92019-02-28 16:09:52 -08004680 StringAppendF(&result, "Composition layers\n");
4681 mDrawingState.traverseInZOrder([&](Layer* layer) {
Lloyd Piquede196652020-01-22 17:29:58 -08004682 auto* compositionState = layer->getCompositionState();
4683 if (!compositionState) return;
4684
4685 android::base::StringAppendF(&result, "* Layer %p (%s)\n", layer,
4686 layer->getDebugName() ? layer->getDebugName()
4687 : "<unknown>");
4688 compositionState->dump(result);
Lloyd Pique207def92019-02-28 16:09:52 -08004689 });
4690 }
4691
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004692 /*
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004693 * Dump Display state
4694 */
4695
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004696 colorizer.bold(result);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004697 StringAppendF(&result, "Displays (%zu entries)\n", mDisplays.size());
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004698 colorizer.reset(result);
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004699 for (const auto& [token, display] : mDisplays) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004700 display->dump(result);
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004701 }
Chia-I Wu1e043612018-03-01 09:45:09 -08004702 result.append("\n");
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004703
4704 /*
Lloyd Piquec3cb7292019-05-17 15:25:14 -07004705 * Dump CompositionEngine state
4706 */
4707
4708 mCompositionEngine->dump(result);
4709
4710 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004711 * Dump SurfaceFlinger global state
4712 */
4713
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004714 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02004715 result.append("SurfaceFlinger global state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004716 colorizer.reset(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004717
Lloyd Piqueb97e04f2018-10-18 17:07:05 -07004718 getRenderEngine().dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004719
Ady Abrahama3b08ef2019-07-15 18:43:10 -07004720 DebugEGLImageTracker::getInstance()->dump(result);
4721
Dominik Laskowski075d3172018-05-24 15:50:06 -07004722 if (const auto display = getDefaultDisplayDeviceLocked()) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07004723 display->getCompositionDisplay()->getState().undefinedRegion.dump(result,
4724 "undefinedRegion");
Dominik Laskowski718f9602019-11-09 20:01:35 -08004725 StringAppendF(&result, " orientation=%s, isPoweredOn=%d\n",
4726 toCString(display->getOrientation()), display->isPoweredOn());
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08004727 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08004728 StringAppendF(&result,
4729 " transaction-flags : %08x\n"
4730 " gpu_to_cpu_unsupported : %d\n",
4731 mTransactionFlags.load(), !mGpuToCpuSupported);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004732
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08004733 if (const auto displayId = getInternalDisplayIdLocked();
Dominik Laskowski075d3172018-05-24 15:50:06 -07004734 displayId && getHwComposer().isConnected(*displayId)) {
4735 const auto activeConfig = getHwComposer().getActiveConfig(*displayId);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004736 StringAppendF(&result,
4737 " refresh-rate : %f fps\n"
4738 " x-dpi : %f\n"
4739 " y-dpi : %f\n",
Ady Abraham3a77a7b2019-12-02 18:46:59 -08004740 1e9 / getHwComposer().getDisplayVsyncPeriod(*displayId),
4741 activeConfig->getDpiX(), activeConfig->getDpiY());
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004742 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004743
Yiwei Zhang5434a782018-12-05 18:06:32 -08004744 StringAppendF(&result, " transaction time: %f us\n", inTransactionDuration / 1000.0);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004745
Dan Stozae22aec72016-08-01 13:20:59 -07004746 /*
Yichi Chenadc69612018-09-15 14:51:18 +08004747 * Tracing state
4748 */
4749 mTracing.dump(result);
4750 result.append("\n");
4751
4752 /*
Dan Stozae22aec72016-08-01 13:20:59 -07004753 * HWC layer minidump
4754 */
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004755 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004756 const auto displayId = display->getId();
4757 if (!displayId) {
Dan Stozae22aec72016-08-01 13:20:59 -07004758 continue;
4759 }
4760
Yiwei Zhang5434a782018-12-05 18:06:32 -08004761 StringAppendF(&result, "Display %s HWC layers:\n", to_string(*displayId).c_str());
Dan Stozae22aec72016-08-01 13:20:59 -07004762 Layer::miniDumpHeader(result);
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004763 const sp<DisplayDevice> displayDevice = display;
4764 mCurrentState.traverseInZOrder(
4765 [&](Layer* layer) { layer->miniDump(result, displayDevice); });
Dan Stozae22aec72016-08-01 13:20:59 -07004766 result.append("\n");
4767 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004768
4769 /*
4770 * Dump HWComposer state
4771 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004772 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02004773 result.append("h/w composer state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004774 colorizer.reset(result);
Dan Stoza9f26a9c2016-06-22 14:51:09 -07004775 bool hwcDisabled = mDebugDisableHWC || mDebugRegion;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004776 StringAppendF(&result, " h/w composer %s\n", hwcDisabled ? "disabled" : "enabled");
Dominik Laskowski075d3172018-05-24 15:50:06 -07004777 getHwComposer().dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004778
4779 /*
4780 * Dump gralloc state
4781 */
4782 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
4783 alloc.dump(result);
Karthik Ravi Shankar171155a2017-06-28 15:40:24 -07004784
4785 /*
4786 * Dump VrFlinger state if in use.
4787 */
4788 if (mVrFlingerRequestsDisplay && mVrFlinger) {
4789 result.append("VrFlinger state:\n");
Yiwei Zhang5434a782018-12-05 18:06:32 -08004790 result.append(mVrFlinger->Dump());
Karthik Ravi Shankar171155a2017-06-28 15:40:24 -07004791 result.append("\n");
4792 }
Ana Krulecb43429d2019-01-09 14:28:51 -08004793
Yiwei Zhang7eb58b72019-04-22 19:00:02 -07004794 result.append(mTimeStats->miniDump());
4795 result.append("\n");
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004796}
4797
Chia-I Wu28f320b2018-05-03 11:02:56 -07004798void SurfaceFlinger::updateColorMatrixLocked() {
4799 mat4 colorMatrix;
4800 if (mGlobalSaturationFactor != 1.0f) {
4801 // Rec.709 luma coefficients
4802 float3 luminance{0.213f, 0.715f, 0.072f};
4803 luminance *= 1.0f - mGlobalSaturationFactor;
4804 mat4 saturationMatrix = mat4(
4805 vec4{luminance.r + mGlobalSaturationFactor, luminance.r, luminance.r, 0.0f},
4806 vec4{luminance.g, luminance.g + mGlobalSaturationFactor, luminance.g, 0.0f},
4807 vec4{luminance.b, luminance.b, luminance.b + mGlobalSaturationFactor, 0.0f},
4808 vec4{0.0f, 0.0f, 0.0f, 1.0f}
4809 );
4810 colorMatrix = mClientColorMatrix * saturationMatrix * mDaltonizer();
4811 } else {
4812 colorMatrix = mClientColorMatrix * mDaltonizer();
4813 }
4814
4815 if (mCurrentState.colorMatrix != colorMatrix) {
4816 mCurrentState.colorMatrix = colorMatrix;
4817 mCurrentState.colorMatrixChanged = true;
4818 setTransactionFlags(eTransactionNeeded);
4819 }
4820}
4821
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07004822status_t SurfaceFlinger::CheckTransactCodeCredentials(uint32_t code) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004823#pragma clang diagnostic push
4824#pragma clang diagnostic error "-Wswitch-enum"
4825 switch (static_cast<ISurfaceComposerTag>(code)) {
4826 // These methods should at minimum make sure that the client requested
4827 // access to SF.
Dan Stozae3344402018-08-20 19:53:42 +00004828 case BOOT_FINISHED:
4829 case CLEAR_ANIMATION_FRAME_STATS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004830 case CREATE_DISPLAY:
4831 case DESTROY_DISPLAY:
Dan Stozae3344402018-08-20 19:53:42 +00004832 case ENABLE_VSYNC_INJECTIONS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004833 case GET_ANIMATION_FRAME_STATS:
4834 case GET_HDR_CAPABILITIES:
Ana Krulec0782b882019-10-15 17:34:54 -07004835 case SET_DESIRED_DISPLAY_CONFIG_SPECS:
Ana Krulec234bb162019-11-10 22:55:55 +01004836 case GET_DESIRED_DISPLAY_CONFIG_SPECS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004837 case SET_ACTIVE_COLOR_MODE:
Galia Peycheva5492cb52019-10-30 14:13:16 +01004838 case GET_AUTO_LOW_LATENCY_MODE_SUPPORT:
4839 case SET_AUTO_LOW_LATENCY_MODE:
4840 case GET_GAME_CONTENT_TYPE_SUPPORT:
4841 case SET_GAME_CONTENT_TYPE:
Chia-I Wu90f669f2017-10-05 14:24:41 -07004842 case INJECT_VSYNC:
Kevin DuBois9c0a1762018-10-16 13:32:31 -07004843 case SET_POWER_MODE:
Kevin DuBois74e53772018-11-19 10:52:38 -08004844 case GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES:
Kevin DuBois1d4249a2018-08-29 10:45:14 -07004845 case SET_DISPLAY_CONTENT_SAMPLING_ENABLED:
Ady Abraham8532d012019-05-08 14:50:56 -07004846 case GET_DISPLAYED_CONTENT_SAMPLE:
Vishnu Nairb13bb952019-11-15 10:24:08 -08004847 case NOTIFY_POWER_HINT:
Steven Thomasd4071902020-03-24 16:02:53 -07004848 case SET_GLOBAL_SHADOW_SETTINGS:
4849 case ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN: {
4850 // ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN is used by CTS tests, which acquire the
4851 // necessary permission dynamically. Don't use the permission cache for this check.
4852 bool usePermissionCache = code != ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN;
4853 if (!callingThreadHasUnscopedSurfaceFlingerAccess(usePermissionCache)) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07004854 IPCThreadState* ipc = IPCThreadState::self();
4855 ALOGE("Permission Denial: can't access SurfaceFlinger pid=%d, uid=%d",
4856 ipc->getCallingPid(), ipc->getCallingUid());
Mathias Agopian375f5632009-06-15 18:24:59 -07004857 return PERMISSION_DENIED;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004858 }
Robert Carr1db73f62016-12-21 12:58:51 -08004859 return OK;
4860 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004861 case GET_LAYER_DEBUG_INFO: {
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07004862 IPCThreadState* ipc = IPCThreadState::self();
4863 const int pid = ipc->getCallingPid();
4864 const int uid = ipc->getCallingUid();
Ana Krulec13be8ad2018-08-21 02:43:56 +00004865 if ((uid != AID_SHELL) && !PermissionCache::checkPermission(sDump, pid, uid)) {
4866 ALOGE("Layer debug info permission denied for pid=%d, uid=%d", pid, uid);
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07004867 return PERMISSION_DENIED;
4868 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004869 return OK;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004870 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004871 // Used by apps to hook Choreographer to SurfaceFlinger.
4872 case CREATE_DISPLAY_EVENT_CONNECTION:
4873 // The following calls are currently used by clients that do not
4874 // request necessary permissions. However, they do not expose any secret
4875 // information, so it is OK to pass them.
4876 case AUTHENTICATE_SURFACE:
Peiyong Lind1fedb42019-03-11 17:48:41 -07004877 case GET_ACTIVE_COLOR_MODE:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004878 case GET_ACTIVE_CONFIG:
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08004879 case GET_PHYSICAL_DISPLAY_IDS:
4880 case GET_PHYSICAL_DISPLAY_TOKEN:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004881 case GET_DISPLAY_COLOR_MODES:
Daniel Solomon42d04562019-01-20 21:03:19 -08004882 case GET_DISPLAY_NATIVE_PRIMARIES:
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08004883 case GET_DISPLAY_INFO:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004884 case GET_DISPLAY_CONFIGS:
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08004885 case GET_DISPLAY_STATE:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004886 case GET_DISPLAY_STATS:
4887 case GET_SUPPORTED_FRAME_TIMESTAMPS:
4888 // Calling setTransactionState is safe, because you need to have been
4889 // granted a reference to Client* and Handle* to do anything with it.
4890 case SET_TRANSACTION_STATE:
Robert Carrb89ea9d2018-12-10 13:01:14 -08004891 case CREATE_CONNECTION:
Ady Abraham37965d42018-11-01 13:43:32 -07004892 case GET_COLOR_MANAGEMENT:
Peiyong Lin3c2791e2019-01-14 17:05:18 -08004893 case GET_COMPOSITION_PREFERENCE:
Marissa Wallebc2c052019-01-16 19:16:55 -08004894 case GET_PROTECTED_CONTENT_SUPPORT:
Dan Gittik57e63c52019-01-18 16:37:54 +00004895 case IS_WIDE_COLOR_DISPLAY:
Steven Thomas62a4cf82020-01-31 12:04:03 -08004896 // setFrameRate() is deliberately available for apps to call without any
4897 // special permissions.
4898 case SET_FRAME_RATE:
Dan Gittik57e63c52019-01-18 16:37:54 +00004899 case GET_DISPLAY_BRIGHTNESS_SUPPORT:
4900 case SET_DISPLAY_BRIGHTNESS: {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004901 return OK;
4902 }
Chong Zhangd1690d12019-10-04 17:47:13 +00004903 case CAPTURE_LAYERS:
Dan Stoza84ab9372018-12-17 15:27:57 -08004904 case CAPTURE_SCREEN:
4905 case ADD_REGION_SAMPLING_LISTENER:
4906 case REMOVE_REGION_SAMPLING_LISTENER: {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004907 // codes that require permission check
chaviwa76b2712017-09-20 12:02:26 -07004908 IPCThreadState* ipc = IPCThreadState::self();
4909 const int pid = ipc->getCallingPid();
4910 const int uid = ipc->getCallingUid();
4911 if ((uid != AID_GRAPHICS) &&
4912 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
4913 ALOGE("Permission Denial: can't read framebuffer pid=%d, uid=%d", pid, uid);
4914 return PERMISSION_DENIED;
4915 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004916 return OK;
4917 }
chaviw93df2ea2019-04-30 16:45:12 -07004918 case CAPTURE_SCREEN_BY_ID: {
4919 IPCThreadState* ipc = IPCThreadState::self();
4920 const int uid = ipc->getCallingUid();
Peiyong Lin96cfebc2019-05-15 11:36:13 -07004921 if (uid == AID_ROOT || uid == AID_GRAPHICS || uid == AID_SYSTEM || uid == AID_SHELL) {
chaviw93df2ea2019-04-30 16:45:12 -07004922 return OK;
4923 }
4924 return PERMISSION_DENIED;
4925 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004926 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004927
4928 // These codes are used for the IBinder protocol to either interrogate the recipient
4929 // side of the transaction for its canonical interface descriptor or to dump its state.
4930 // We let them pass by default.
4931 if (code == IBinder::INTERFACE_TRANSACTION || code == IBinder::DUMP_TRANSACTION ||
4932 code == IBinder::PING_TRANSACTION || code == IBinder::SHELL_COMMAND_TRANSACTION ||
4933 code == IBinder::SYSPROPS_TRANSACTION) {
4934 return OK;
4935 }
Ady Abraham07e54702020-04-16 15:05:37 -07004936 // Numbers from 1000 to 1036 are currently used for backdoors. The code
Ana Krulec13be8ad2018-08-21 02:43:56 +00004937 // in onTransact verifies that the user is root, and has access to use SF.
Ady Abraham07e54702020-04-16 15:05:37 -07004938 if (code >= 1000 && code <= 1036) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004939 ALOGV("Accessing SurfaceFlinger through backdoor code: %u", code);
4940 return OK;
4941 }
4942 ALOGE("Permission Denial: SurfaceFlinger did not recognize request code: %u", code);
4943 return PERMISSION_DENIED;
4944#pragma clang diagnostic pop
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07004945}
4946
Ana Krulec13be8ad2018-08-21 02:43:56 +00004947status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
4948 uint32_t flags) {
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07004949 status_t credentialCheck = CheckTransactCodeCredentials(code);
4950 if (credentialCheck != OK) {
4951 return credentialCheck;
4952 }
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07004953
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004954 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
4955 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
Mathias Agopianb8a55602009-06-26 19:06:36 -07004956 CHECK_INTERFACE(ISurfaceComposer, data, reply);
Romain Guy8c6bbd62017-06-05 13:51:43 -07004957 IPCThreadState* ipc = IPCThreadState::self();
4958 const int uid = ipc->getCallingUid();
4959 if (CC_UNLIKELY(uid != AID_SYSTEM
4960 && !PermissionCache::checkCallingPermission(sHardwareTest))) {
Mathias Agopian375f5632009-06-15 18:24:59 -07004961 const int pid = ipc->getCallingPid();
Steve Blocke6f43dd2012-01-06 19:20:56 +00004962 ALOGE("Permission Denial: "
Mathias Agopian375f5632009-06-15 18:24:59 -07004963 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004964 return PERMISSION_DENIED;
4965 }
4966 int n;
4967 switch (code) {
Mathias Agopian01b76682009-04-16 20:04:08 -07004968 case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
Mathias Agopian35b48d12010-09-13 22:57:58 -07004969 case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004970 return NO_ERROR;
4971 case 1002: // SHOW_UPDATES
4972 n = data.readInt32();
4973 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
Mathias Agopian53331da2011-08-22 21:44:41 -07004974 invalidateHwcGeometry();
4975 repaintEverything();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004976 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004977 case 1004:{ // repaint everything
Mathias Agopian53331da2011-08-22 21:44:41 -07004978 repaintEverything();
Mathias Agopiancbb288b2009-09-07 16:32:45 -07004979 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004980 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -07004981 case 1005:{ // force transaction
Steven Thomas6d8110b2017-08-31 18:24:21 -07004982 Mutex::Autolock _l(mStateLock);
Mathias Agopiane57f2922012-08-09 16:29:12 -07004983 setTransactionFlags(
4984 eTransactionNeeded|
4985 eDisplayTransactionNeeded|
4986 eTraversalNeeded);
Mathias Agopiancbb288b2009-09-07 16:32:45 -07004987 return NO_ERROR;
4988 }
Mathias Agopian4d143ee2012-02-23 20:05:39 -08004989 case 1006:{ // send empty update
4990 signalRefresh();
4991 return NO_ERROR;
4992 }
Mathias Agopian53331da2011-08-22 21:44:41 -07004993 case 1008: // toggle use of hw composer
4994 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07004995 mDebugDisableHWC = n != 0;
Mathias Agopian53331da2011-08-22 21:44:41 -07004996 invalidateHwcGeometry();
4997 repaintEverything();
4998 return NO_ERROR;
Mathias Agopiana4583642011-08-23 18:03:18 -07004999 case 1009: // toggle use of transform hint
5000 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005001 mDebugDisableTransformHint = n != 0;
Mathias Agopiana4583642011-08-23 18:03:18 -07005002 invalidateHwcGeometry();
5003 repaintEverything();
5004 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005005 case 1010: // interrogate.
Mathias Agopian01b76682009-04-16 20:04:08 -07005006 reply->writeInt32(0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005007 reply->writeInt32(0);
5008 reply->writeInt32(mDebugRegion);
Mathias Agopianb9494d52012-04-18 02:28:45 -07005009 reply->writeInt32(0);
Dianne Hackborn12839be2012-02-06 21:21:05 -08005010 reply->writeInt32(mDebugDisableHWC);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005011 return NO_ERROR;
5012 case 1013: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005013 const auto display = getDefaultDisplayDevice();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07005014 if (!display) {
5015 return NAME_NOT_FOUND;
5016 }
5017
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005018 reply->writeInt32(display->getPageFlipCount());
Mathias Agopianff2ed702013-09-01 21:36:12 -07005019 return NO_ERROR;
5020 }
5021 case 1014: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005022 Mutex::Autolock _l(mStateLock);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005023 // daltonize
5024 n = data.readInt32();
5025 switch (n % 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005026 case 1:
5027 mDaltonizer.setType(ColorBlindnessType::Protanomaly);
5028 break;
5029 case 2:
5030 mDaltonizer.setType(ColorBlindnessType::Deuteranomaly);
5031 break;
5032 case 3:
5033 mDaltonizer.setType(ColorBlindnessType::Tritanomaly);
5034 break;
5035 default:
5036 mDaltonizer.setType(ColorBlindnessType::None);
5037 break;
Mathias Agopianff2ed702013-09-01 21:36:12 -07005038 }
5039 if (n >= 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005040 mDaltonizer.setMode(ColorBlindnessMode::Correction);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005041 } else {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005042 mDaltonizer.setMode(ColorBlindnessMode::Simulation);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005043 }
Chia-I Wu28f320b2018-05-03 11:02:56 -07005044
5045 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005046 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005047 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005048 case 1015: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005049 Mutex::Autolock _l(mStateLock);
Alan Viverette9c5a3332013-09-12 20:04:35 -07005050 // apply a color matrix
5051 n = data.readInt32();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005052 if (n) {
Romain Guy0147a172017-06-01 13:53:56 -07005053 // color matrix is sent as a column-major mat4 matrix
Alan Viverette794c5ba2013-10-03 16:40:52 -07005054 for (size_t i = 0 ; i < 4; i++) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005055 for (size_t j = 0; j < 4; j++) {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005056 mClientColorMatrix[i][j] = data.readFloat();
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005057 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005058 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005059 } else {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005060 mClientColorMatrix = mat4();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005061 }
Romain Guy88d37dd2017-05-26 17:57:05 -07005062
5063 // Check that supplied matrix's last row is {0,0,0,1} so we can avoid
5064 // the division by w in the fragment shader
Chia-I Wu28f320b2018-05-03 11:02:56 -07005065 float4 lastRow(transpose(mClientColorMatrix)[3]);
Romain Guy88d37dd2017-05-26 17:57:05 -07005066 if (any(greaterThan(abs(lastRow - float4{0, 0, 0, 1}), float4{1e-4f}))) {
5067 ALOGE("The color transform's last row must be (0, 0, 0, 1)");
5068 }
5069
Chia-I Wu28f320b2018-05-03 11:02:56 -07005070 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005071 return NO_ERROR;
5072 }
Dominik Laskowski8d32ddc2019-08-07 11:25:35 -07005073 case 1016: { // Unused.
5074 return NAME_NOT_FOUND;
Ruchi Kandoif52b3c82014-04-24 16:42:35 -07005075 }
Dan Stozaee44edd2015-03-23 15:50:23 -07005076 case 1017: {
5077 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005078 mForceFullDamage = n != 0;
Dan Stozaee44edd2015-03-23 15:50:23 -07005079 return NO_ERROR;
5080 }
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005081 case 1018: { // Modify Choreographer's phase offset
5082 n = data.readInt32();
Ana Krulecc2870422019-01-29 19:00:58 -08005083 mScheduler->setPhaseOffset(mAppConnectionHandle, static_cast<nsecs_t>(n));
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005084 return NO_ERROR;
5085 }
5086 case 1019: { // Modify SurfaceFlinger's phase offset
5087 n = data.readInt32();
Ana Krulecc2870422019-01-29 19:00:58 -08005088 mScheduler->setPhaseOffset(mSfConnectionHandle, static_cast<nsecs_t>(n));
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005089 return NO_ERROR;
5090 }
Irvel468051e2016-06-13 16:44:44 -07005091 case 1020: { // Layer updates interceptor
5092 n = data.readInt32();
5093 if (n) {
5094 ALOGV("Interceptor enabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08005095 mInterceptor->enable(mDrawingState.layersSortedByZ, mDrawingState.displays);
Irvel468051e2016-06-13 16:44:44 -07005096 }
5097 else{
5098 ALOGV("Interceptor disabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08005099 mInterceptor->disable();
Irvel468051e2016-06-13 16:44:44 -07005100 }
5101 return NO_ERROR;
5102 }
Dan Stoza8cf150a2016-08-02 10:27:31 -07005103 case 1021: { // Disable HWC virtual displays
5104 n = data.readInt32();
5105 mUseHwcVirtualDisplays = !n;
5106 return NO_ERROR;
5107 }
Romain Guy0147a172017-06-01 13:53:56 -07005108 case 1022: { // Set saturation boost
Chia-I Wu28f320b2018-05-03 11:02:56 -07005109 Mutex::Autolock _l(mStateLock);
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005110 mGlobalSaturationFactor = std::max(0.0f, std::min(data.readFloat(), 2.0f));
Romain Guy0147a172017-06-01 13:53:56 -07005111
Chia-I Wu28f320b2018-05-03 11:02:56 -07005112 updateColorMatrixLocked();
Romain Guy0147a172017-06-01 13:53:56 -07005113 return NO_ERROR;
5114 }
Romain Guy54f154a2017-10-24 21:40:32 +01005115 case 1023: { // Set native mode
Daniel Solomon7c7ede22019-07-11 16:35:40 -07005116 int32_t colorMode;
5117
Chia-I Wu0d711262018-05-21 15:19:35 -07005118 mDisplayColorSetting = static_cast<DisplayColorSetting>(data.readInt32());
Daniel Solomon7c7ede22019-07-11 16:35:40 -07005119 if (data.readInt32(&colorMode) == NO_ERROR) {
5120 mForceColorMode = static_cast<ColorMode>(colorMode);
5121 }
Romain Guy54f154a2017-10-24 21:40:32 +01005122 invalidateHwcGeometry();
5123 repaintEverything();
5124 return NO_ERROR;
5125 }
Peiyong Lin4bac91c2018-10-25 09:48:33 -07005126 // Deprecate, use 1030 to check whether the device is color managed.
5127 case 1024: {
5128 return NAME_NOT_FOUND;
Romain Guy54f154a2017-10-24 21:40:32 +01005129 }
Vishnu Nair87704c92018-01-08 15:32:57 -08005130 case 1025: { // Set layer tracing
Adrian Roos1e1a1282017-11-01 19:05:31 +01005131 n = data.readInt32();
5132 if (n) {
Yichi Chenadc69612018-09-15 14:51:18 +08005133 ALOGD("LayerTracing enabled");
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07005134 mTracingEnabledChanged = mTracing.enable();
Adrian Roos1e1a1282017-11-01 19:05:31 +01005135 reply->writeInt32(NO_ERROR);
5136 } else {
Yichi Chenadc69612018-09-15 14:51:18 +08005137 ALOGD("LayerTracing disabled");
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07005138 mTracingEnabledChanged = mTracing.disable();
5139 if (mTracingEnabledChanged) {
Nataniel Borges2b796da2019-02-15 13:32:18 -08005140 reply->writeInt32(mTracing.writeToFile());
5141 } else {
5142 reply->writeInt32(NO_ERROR);
5143 }
Adrian Roos1e1a1282017-11-01 19:05:31 +01005144 }
5145 return NO_ERROR;
5146 }
Vishnu Nair87704c92018-01-08 15:32:57 -08005147 case 1026: { // Get layer tracing status
5148 reply->writeBool(mTracing.isEnabled());
5149 return NO_ERROR;
5150 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005151 // Is a DisplayColorSetting supported?
5152 case 1027: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005153 const auto display = getDefaultDisplayDevice();
5154 if (!display) {
Chia-I Wu0d711262018-05-21 15:19:35 -07005155 return NAME_NOT_FOUND;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005156 }
Chia-I Wu0d711262018-05-21 15:19:35 -07005157
5158 DisplayColorSetting setting = static_cast<DisplayColorSetting>(data.readInt32());
5159 switch (setting) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -08005160 case DisplayColorSetting::kManaged:
Peiyong Lin13effd12018-07-24 17:01:47 -07005161 reply->writeBool(useColorManagement);
Chia-I Wu0d711262018-05-21 15:19:35 -07005162 break;
Lloyd Pique6a3b4462019-03-07 20:58:12 -08005163 case DisplayColorSetting::kUnmanaged:
Chia-I Wu0d711262018-05-21 15:19:35 -07005164 reply->writeBool(true);
5165 break;
Lloyd Pique6a3b4462019-03-07 20:58:12 -08005166 case DisplayColorSetting::kEnhanced:
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005167 reply->writeBool(display->hasRenderIntent(RenderIntent::ENHANCE));
Chia-I Wu0d711262018-05-21 15:19:35 -07005168 break;
5169 default: // vendor display color setting
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005170 reply->writeBool(
5171 display->hasRenderIntent(static_cast<RenderIntent>(setting)));
Chia-I Wu0d711262018-05-21 15:19:35 -07005172 break;
5173 }
5174 return NO_ERROR;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005175 }
Steven Thomas97f1f4c2018-06-01 12:04:16 -07005176 // Is VrFlinger active?
5177 case 1028: {
5178 Mutex::Autolock _l(mStateLock);
Lloyd Pique441d5042018-10-18 16:49:51 -07005179 reply->writeBool(getHwComposer().isUsingVrComposer());
Steven Thomas97f1f4c2018-06-01 12:04:16 -07005180 return NO_ERROR;
5181 }
Nataniel Borges2b796da2019-02-15 13:32:18 -08005182 // Set buffer size for SF tracing (value in KB)
5183 case 1029: {
5184 n = data.readInt32();
5185 if (n <= 0 || n > MAX_TRACING_MEMORY) {
5186 ALOGW("Invalid buffer size: %d KB", n);
5187 reply->writeInt32(BAD_VALUE);
5188 return BAD_VALUE;
5189 }
5190
5191 ALOGD("Updating trace buffer to %d KB", n);
5192 mTracing.setBufferSize(n * 1024);
5193 reply->writeInt32(NO_ERROR);
5194 return NO_ERROR;
5195 }
Peiyong Lin13effd12018-07-24 17:01:47 -07005196 // Is device color managed?
5197 case 1030: {
5198 reply->writeBool(useColorManagement);
5199 return NO_ERROR;
5200 }
Peiyong Lin9d846a52018-11-05 13:18:20 -08005201 // Override default composition data space
5202 // adb shell service call SurfaceFlinger 1031 i32 1 DATASPACE_NUMBER DATASPACE_NUMBER \
5203 // && adb shell stop zygote && adb shell start zygote
5204 // to restore: adb shell service call SurfaceFlinger 1031 i32 0 && \
5205 // adb shell stop zygote && adb shell start zygote
5206 case 1031: {
5207 Mutex::Autolock _l(mStateLock);
5208 n = data.readInt32();
5209 if (n) {
5210 n = data.readInt32();
5211 if (n) {
5212 Dataspace dataspace = static_cast<Dataspace>(n);
5213 if (!validateCompositionDataspace(dataspace)) {
5214 return BAD_VALUE;
5215 }
5216 mDefaultCompositionDataspace = dataspace;
5217 }
5218 n = data.readInt32();
5219 if (n) {
5220 Dataspace dataspace = static_cast<Dataspace>(n);
5221 if (!validateCompositionDataspace(dataspace)) {
5222 return BAD_VALUE;
5223 }
5224 mWideColorGamutCompositionDataspace = dataspace;
5225 }
5226 } else {
5227 // restore composition data space.
5228 mDefaultCompositionDataspace = defaultCompositionDataspace;
5229 mWideColorGamutCompositionDataspace = wideColorGamutCompositionDataspace;
5230 }
5231 return NO_ERROR;
5232 }
Vishnu Nair9245d3b2019-03-22 13:38:56 -07005233 // Set trace flags
5234 case 1033: {
5235 n = data.readUint32();
5236 ALOGD("Updating trace flags to 0x%x", n);
5237 mTracing.setTraceFlags(n);
5238 reply->writeInt32(NO_ERROR);
5239 return NO_ERROR;
5240 }
Ady Abraham03b02dd2019-03-21 15:40:11 -07005241 case 1034: {
Ady Abraham03b02dd2019-03-21 15:40:11 -07005242 n = data.readInt32();
Ady Abraham2cb8b622019-12-02 18:55:33 -08005243 if (n == 1 && !mRefreshRateOverlay) {
Ady Abraham03b02dd2019-03-21 15:40:11 -07005244 mRefreshRateOverlay = std::make_unique<RefreshRateOverlay>(*this);
Ady Abraham2e1dd892020-03-05 13:48:36 -08005245 auto& current = mRefreshRateConfigs->getCurrentRefreshRate();
Ady Abraham2139f732019-11-13 18:56:40 -08005246 mRefreshRateOverlay->changeRefreshRate(current);
Ady Abraham2cb8b622019-12-02 18:55:33 -08005247 } else if (n == 0) {
Ady Abraham03b02dd2019-03-21 15:40:11 -07005248 mRefreshRateOverlay.reset();
Ady Abraham2cb8b622019-12-02 18:55:33 -08005249 } else {
5250 reply->writeBool(mRefreshRateOverlay != nullptr);
Ady Abraham03b02dd2019-03-21 15:40:11 -07005251 }
5252 return NO_ERROR;
5253 }
Ady Abraham34392f72019-04-10 11:29:27 -07005254 case 1035: {
5255 n = data.readInt32();
5256 mDebugDisplayConfigSetByBackdoor = false;
5257 if (n >= 0) {
5258 const auto displayToken = getInternalDisplayToken();
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005259 status_t result = setActiveConfig(displayToken, n);
Ady Abraham34392f72019-04-10 11:29:27 -07005260 if (result != NO_ERROR) {
5261 return result;
5262 }
5263 mDebugDisplayConfigSetByBackdoor = true;
5264 }
5265 return NO_ERROR;
5266 }
Ady Abraham07e54702020-04-16 15:05:37 -07005267 case 1036: {
5268 if (data.readInt32() > 0) {
5269 status_t result =
5270 acquireFrameRateFlexibilityToken(&mDebugFrameRateFlexibilityToken);
5271 if (result != NO_ERROR) {
5272 return result;
5273 }
5274 } else {
5275 mDebugFrameRateFlexibilityToken = nullptr;
5276 }
5277 return NO_ERROR;
5278 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005279 }
5280 }
5281 return err;
5282}
5283
Steven Thomas6d8110b2017-08-31 18:24:21 -07005284void SurfaceFlinger::repaintEverything() {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07005285 mRepaintEverything = true;
Dan Stozac7a25ad2018-04-12 11:45:09 -07005286 signalTransaction();
Steven Thomas6d8110b2017-08-31 18:24:21 -07005287}
5288
Ana Krulec7d1d6832018-12-27 11:10:09 -08005289void SurfaceFlinger::repaintEverythingForHWC() {
5290 mRepaintEverything = true;
Dan Stoza030fbc12020-02-19 15:32:01 -08005291 mPowerAdvisor.notifyDisplayUpdateImminent();
Ady Abraham8532d012019-05-08 14:50:56 -07005292 mEventQueue->invalidate();
Ana Krulec7d1d6832018-12-27 11:10:09 -08005293}
5294
Ady Abrahama09852a2020-02-20 14:23:42 -08005295void SurfaceFlinger::kernelTimerChanged(bool expired) {
5296 static bool updateOverlay =
5297 property_get_bool("debug.sf.kernel_idle_timer_update_overlay", true);
5298 if (!updateOverlay || !mRefreshRateOverlay) return;
5299
5300 // Update the overlay on the main thread to avoid race conditions with
5301 // mRefreshRateConfigs->getCurrentRefreshRate()
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07005302 static_cast<void>(schedule([=]() NO_THREAD_SAFETY_ANALYSIS {
Ady Abrahama09852a2020-02-20 14:23:42 -08005303 if (mRefreshRateOverlay) {
5304 const auto kernelTimerEnabled = property_get_bool(KERNEL_IDLE_TIMER_PROP, false);
5305 const bool timerExpired = kernelTimerEnabled && expired;
Ady Abraham2e1dd892020-03-05 13:48:36 -08005306 const auto& current = [this]() -> const RefreshRate& {
Ady Abrahama09852a2020-02-20 14:23:42 -08005307 std::lock_guard<std::mutex> lock(mActiveConfigLock);
5308 if (mDesiredActiveConfigChanged) {
5309 return mRefreshRateConfigs->getRefreshRateFromConfigId(
5310 mDesiredActiveConfig.configId);
5311 }
5312
5313 return mRefreshRateConfigs->getCurrentRefreshRate();
5314 }();
5315 const auto& min = mRefreshRateConfigs->getMinRefreshRate();
5316
5317 if (current != min) {
5318 mRefreshRateOverlay->changeRefreshRate(timerExpired ? min : current);
5319 mEventQueue->invalidate();
5320 }
5321 }
5322 }));
5323}
5324
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005325// A simple RAII class to disconnect from an ANativeWindow* when it goes out of scope
5326class WindowDisconnector {
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005327public:
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005328 WindowDisconnector(ANativeWindow* window, int api) : mWindow(window), mApi(api) {}
5329 ~WindowDisconnector() {
5330 native_window_api_disconnect(mWindow, mApi);
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005331 }
5332
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005333private:
5334 ANativeWindow* mWindow;
5335 const int mApi;
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005336};
5337
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005338status_t SurfaceFlinger::captureScreen(const sp<IBinder>& displayToken,
Robert Carr108b2c72019-04-02 16:32:58 -07005339 sp<GraphicBuffer>* outBuffer, bool& outCapturedSecureLayers,
Dominik Laskowski718f9602019-11-09 20:01:35 -08005340 Dataspace reqDataspace, ui::PixelFormat reqPixelFormat,
5341 const Rect& sourceCrop, uint32_t reqWidth,
5342 uint32_t reqHeight, bool useIdentityTransform,
5343 ui::Rotation rotation, bool captureSecureLayers) {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005344 ATRACE_CALL();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005345
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005346 if (!displayToken) return BAD_VALUE;
chaviwa76b2712017-09-20 12:02:26 -07005347
Dominik Laskowski718f9602019-11-09 20:01:35 -08005348 auto renderAreaRotation = ui::Transform::toRotationFlags(rotation);
5349 if (renderAreaRotation == ui::Transform::ROT_INVALID) {
5350 ALOGE("%s: Invalid rotation: %s", __FUNCTION__, toCString(rotation));
5351 renderAreaRotation = ui::Transform::ROT_0;
5352 }
Chia-I Wuc80dcbb2018-08-24 15:34:02 -07005353
Chia-I Wu20261cb2018-08-23 12:55:44 -07005354 sp<DisplayDevice> display;
5355 {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005356 Mutex::Autolock lock(mStateLock);
Garfield Tan3b1b8af2018-03-16 17:37:33 -07005357
Chia-I Wu20261cb2018-08-23 12:55:44 -07005358 display = getDisplayDeviceLocked(displayToken);
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005359 if (!display) return NAME_NOT_FOUND;
Chia-I Wu20261cb2018-08-23 12:55:44 -07005360
Chia-I Wucb023152018-08-28 12:57:23 -07005361 // set the requested width/height to the logical display viewport size
5362 // by default
5363 if (reqWidth == 0 || reqHeight == 0) {
5364 reqWidth = uint32_t(display->getViewport().width());
5365 reqHeight = uint32_t(display->getViewport().height());
Chia-I Wu20261cb2018-08-23 12:55:44 -07005366 }
Yiwei Zhang06a58e22018-08-20 16:42:23 -07005367 }
5368
Peiyong Lin0e003c92018-09-17 11:09:51 -07005369 DisplayRenderArea renderArea(display, sourceCrop, reqWidth, reqHeight, reqDataspace,
Robert Carrfa8855f2019-02-19 10:05:00 -08005370 renderAreaRotation, captureSecureLayers);
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08005371 auto traverseLayers = std::bind(&SurfaceFlinger::traverseLayersInDisplay, this, display,
5372 std::placeholders::_1);
Peiyong Lin0e003c92018-09-17 11:09:51 -07005373 return captureScreenCommon(renderArea, traverseLayers, outBuffer, reqPixelFormat,
Robert Carr108b2c72019-04-02 16:32:58 -07005374 useIdentityTransform, outCapturedSecureLayers);
chaviwa76b2712017-09-20 12:02:26 -07005375}
5376
chaviw93df2ea2019-04-30 16:45:12 -07005377static Dataspace pickDataspaceFromColorMode(const ColorMode colorMode) {
5378 switch (colorMode) {
5379 case ColorMode::DISPLAY_P3:
5380 case ColorMode::BT2100_PQ:
5381 case ColorMode::BT2100_HLG:
5382 case ColorMode::DISPLAY_BT2020:
5383 return Dataspace::DISPLAY_P3;
5384 default:
5385 return Dataspace::V0_SRGB;
5386 }
5387}
5388
Martin Liu4a322352020-03-24 21:30:38 +08005389status_t SurfaceFlinger::setSchedFifo(bool enabled) {
5390 static constexpr int kFifoPriority = 2;
5391 static constexpr int kOtherPriority = 0;
5392
5393 struct sched_param param = {0};
5394 int sched_policy;
5395 if (enabled) {
5396 sched_policy = SCHED_FIFO;
5397 param.sched_priority = kFifoPriority;
5398 } else {
5399 sched_policy = SCHED_OTHER;
5400 param.sched_priority = kOtherPriority;
5401 }
5402
5403 if (sched_setscheduler(0, sched_policy, &param) != 0) {
5404 return -errno;
5405 }
5406 return NO_ERROR;
5407}
5408
chaviw93df2ea2019-04-30 16:45:12 -07005409const sp<DisplayDevice> SurfaceFlinger::getDisplayByIdOrLayerStack(uint64_t displayOrLayerStack) {
5410 const sp<IBinder> displayToken = getPhysicalDisplayTokenLocked(DisplayId{displayOrLayerStack});
5411 if (displayToken) {
5412 return getDisplayDeviceLocked(displayToken);
5413 }
5414 // Couldn't find display by displayId. Try to get display by layerStack since virtual displays
5415 // may not have a displayId.
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005416 return getDisplayByLayerStack(displayOrLayerStack);
5417}
5418
5419const sp<DisplayDevice> SurfaceFlinger::getDisplayByLayerStack(uint64_t layerStack) {
chaviw93df2ea2019-04-30 16:45:12 -07005420 for (const auto& [token, display] : mDisplays) {
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005421 if (display->getLayerStack() == layerStack) {
chaviw93df2ea2019-04-30 16:45:12 -07005422 return display;
5423 }
5424 }
5425 return nullptr;
5426}
5427
5428status_t SurfaceFlinger::captureScreen(uint64_t displayOrLayerStack, Dataspace* outDataspace,
5429 sp<GraphicBuffer>* outBuffer) {
5430 sp<DisplayDevice> display;
5431 uint32_t width;
5432 uint32_t height;
Dominik Laskowski718f9602019-11-09 20:01:35 -08005433 ui::Transform::RotationFlags captureOrientation;
chaviw93df2ea2019-04-30 16:45:12 -07005434 {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005435 Mutex::Autolock lock(mStateLock);
chaviw93df2ea2019-04-30 16:45:12 -07005436 display = getDisplayByIdOrLayerStack(displayOrLayerStack);
5437 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005438 return NAME_NOT_FOUND;
chaviw93df2ea2019-04-30 16:45:12 -07005439 }
5440
5441 width = uint32_t(display->getViewport().width());
5442 height = uint32_t(display->getViewport().height());
5443
Dominik Laskowski718f9602019-11-09 20:01:35 -08005444 const auto orientation = display->getOrientation();
5445 captureOrientation = ui::Transform::toRotationFlags(orientation);
5446
5447 switch (captureOrientation) {
5448 case ui::Transform::ROT_90:
5449 captureOrientation = ui::Transform::ROT_270;
5450 break;
5451
5452 case ui::Transform::ROT_270:
5453 captureOrientation = ui::Transform::ROT_90;
5454 break;
5455
5456 case ui::Transform::ROT_INVALID:
5457 ALOGE("%s: Invalid orientation: %s", __FUNCTION__, toCString(orientation));
5458 captureOrientation = ui::Transform::ROT_0;
5459 break;
5460
5461 default:
5462 break;
Alec Mouri21fab752019-06-20 14:12:17 -07005463 }
chaviw93df2ea2019-04-30 16:45:12 -07005464 *outDataspace =
5465 pickDataspaceFromColorMode(display->getCompositionDisplay()->getState().colorMode);
5466 }
5467
5468 DisplayRenderArea renderArea(display, Rect(), width, height, *outDataspace, captureOrientation,
5469 false /* captureSecureLayers */);
5470
5471 auto traverseLayers = std::bind(&SurfaceFlinger::traverseLayersInDisplay, this, display,
5472 std::placeholders::_1);
5473 bool ignored = false;
5474 return captureScreenCommon(renderArea, traverseLayers, outBuffer, ui::PixelFormat::RGBA_8888,
5475 false /* useIdentityTransform */,
5476 ignored /* outCapturedSecureLayers */);
5477}
5478
Robert Carr866455f2019-04-02 16:28:26 -07005479status_t SurfaceFlinger::captureLayers(
5480 const sp<IBinder>& layerHandleBinder, sp<GraphicBuffer>* outBuffer,
5481 const Dataspace reqDataspace, const ui::PixelFormat reqPixelFormat, const Rect& sourceCrop,
5482 const std::unordered_set<sp<IBinder>, ISurfaceComposer::SpHash<IBinder>>& excludeHandles,
5483 float frameScale, bool childrenOnly) {
chaviwa76b2712017-09-20 12:02:26 -07005484 ATRACE_CALL();
5485
5486 class LayerRenderArea : public RenderArea {
5487 public:
Robert Carr578038f2018-03-09 12:25:24 -08005488 LayerRenderArea(SurfaceFlinger* flinger, const sp<Layer>& layer, const Rect crop,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005489 int32_t reqWidth, int32_t reqHeight, Dataspace reqDataSpace,
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005490 bool childrenOnly, const Rect& displayViewport)
5491 : RenderArea(reqWidth, reqHeight, CaptureFill::CLEAR, reqDataSpace, displayViewport),
Robert Carr578038f2018-03-09 12:25:24 -08005492 mLayer(layer),
5493 mCrop(crop),
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005494 mNeedsFiltering(false),
Robert Carr578038f2018-03-09 12:25:24 -08005495 mFlinger(flinger),
5496 mChildrenOnly(childrenOnly) {}
Peiyong Linefefaac2018-08-17 12:27:51 -07005497 const ui::Transform& getTransform() const override { return mTransform; }
Alec Mouri5a6d8572020-03-23 23:56:15 -07005498 Rect getBounds() const override { return mLayer->getBufferSize(mLayer->getDrawingState()); }
Marissa Wall61c58622018-07-18 10:12:20 -07005499 int getHeight() const override {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08005500 return mLayer->getBufferSize(mLayer->getDrawingState()).getHeight();
Marissa Wall61c58622018-07-18 10:12:20 -07005501 }
Vishnu Nair88a11f22018-11-28 18:30:57 -08005502 int getWidth() const override {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08005503 return mLayer->getBufferSize(mLayer->getDrawingState()).getWidth();
Vishnu Nair88a11f22018-11-28 18:30:57 -08005504 }
chaviwa76b2712017-09-20 12:02:26 -07005505 bool isSecure() const override { return false; }
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005506 bool needsFiltering() const override { return mNeedsFiltering; }
Dominik Laskowski718f9602019-11-09 20:01:35 -08005507 sp<const DisplayDevice> getDisplayDevice() const override { return nullptr; }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005508 Rect getSourceCrop() const override {
5509 if (mCrop.isEmpty()) {
5510 return getBounds();
5511 } else {
5512 return mCrop;
5513 }
5514 }
Robert Carr578038f2018-03-09 12:25:24 -08005515 class ReparentForDrawing {
5516 public:
5517 const sp<Layer>& oldParent;
5518 const sp<Layer>& newParent;
5519
Vishnu Nair4351ad52019-02-11 14:13:02 -08005520 ReparentForDrawing(const sp<Layer>& oldParent, const sp<Layer>& newParent,
5521 const Rect& drawingBounds)
Robert Carr578038f2018-03-09 12:25:24 -08005522 : oldParent(oldParent), newParent(newParent) {
Vishnu Nair4351ad52019-02-11 14:13:02 -08005523 // Compute and cache the bounds for the new parent layer.
Vishnu Nairc97b8db2019-10-29 18:19:35 -07005524 newParent->computeBounds(drawingBounds.toFloatRect(), ui::Transform(),
5525 0.f /* shadowRadius */);
Robert Carr15eae092018-03-23 13:43:53 -07005526 oldParent->setChildrenDrawingParent(newParent);
Robert Carr578038f2018-03-09 12:25:24 -08005527 }
Vishnu Nairbce6ffd2019-02-14 10:58:59 -08005528 ~ReparentForDrawing() { oldParent->setChildrenDrawingParent(oldParent); }
Robert Carr578038f2018-03-09 12:25:24 -08005529 };
5530
5531 void render(std::function<void()> drawLayers) override {
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005532 const Rect sourceCrop = getSourceCrop();
5533 // no need to check rotation because there is none
5534 mNeedsFiltering = sourceCrop.width() != getReqWidth() ||
5535 sourceCrop.height() != getReqHeight();
5536
Robert Carr578038f2018-03-09 12:25:24 -08005537 if (!mChildrenOnly) {
5538 mTransform = mLayer->getTransform().inverse();
5539 drawLayers();
5540 } else {
Alec Mouri5a6d8572020-03-23 23:56:15 -07005541 uint32_t w = static_cast<uint32_t>(getWidth());
5542 uint32_t h = static_cast<uint32_t>(getHeight());
chaviw32811fd2019-08-12 13:16:09 -07005543 // In the "childrenOnly" case we reparent the children to a screenshot
5544 // layer which has no properties set and which does not draw.
5545 sp<ContainerLayer> screenshotParentLayer =
Dominik Laskowski87a07e42019-10-10 20:38:02 -07005546 mFlinger->getFactory().createContainerLayer({mFlinger, nullptr,
5547 "Screenshot Parent"s, w, h, 0,
5548 LayerMetadata()});
Robert Carr578038f2018-03-09 12:25:24 -08005549
Vishnu Nair4351ad52019-02-11 14:13:02 -08005550 ReparentForDrawing reparent(mLayer, screenshotParentLayer, sourceCrop);
Robert Carr578038f2018-03-09 12:25:24 -08005551 drawLayers();
5552 }
5553 }
chaviwa76b2712017-09-20 12:02:26 -07005554
chaviwa76b2712017-09-20 12:02:26 -07005555 private:
chaviw7206d492017-11-10 16:16:12 -08005556 const sp<Layer> mLayer;
5557 const Rect mCrop;
Robert Carr578038f2018-03-09 12:25:24 -08005558
Peiyong Linefefaac2018-08-17 12:27:51 -07005559 ui::Transform mTransform;
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005560 bool mNeedsFiltering;
Robert Carr578038f2018-03-09 12:25:24 -08005561
5562 SurfaceFlinger* mFlinger;
5563 const bool mChildrenOnly;
chaviwa76b2712017-09-20 12:02:26 -07005564 };
5565
Robert Carrc0df3122019-04-11 13:18:21 -07005566 int reqWidth = 0;
5567 int reqHeight = 0;
5568 sp<Layer> parent;
chaviw7206d492017-11-10 16:16:12 -08005569 Rect crop(sourceCrop);
Robert Carrc0df3122019-04-11 13:18:21 -07005570 std::unordered_set<sp<Layer>, ISurfaceComposer::SpHash<Layer>> excludeLayers;
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005571 Rect displayViewport;
Robert Carrc0df3122019-04-11 13:18:21 -07005572 {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005573 Mutex::Autolock lock(mStateLock);
chaviw7206d492017-11-10 16:16:12 -08005574
Alec Mouri9a02eda2020-04-21 17:39:34 -07005575 parent = fromHandleLocked(layerHandleBinder).promote();
Robert Carrc0df3122019-04-11 13:18:21 -07005576 if (parent == nullptr || parent->isRemovedFromCurrentState()) {
5577 ALOGE("captureLayers called with an invalid or removed parent");
5578 return NAME_NOT_FOUND;
5579 }
5580
5581 const int uid = IPCThreadState::self()->getCallingUid();
5582 const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
5583 if (!forSystem && parent->getCurrentState().flags & layer_state_t::eLayerSecure) {
5584 ALOGW("Attempting to capture secure layer: PERMISSION_DENIED");
5585 return PERMISSION_DENIED;
5586 }
5587
Vishnu Nairefc42e22019-12-03 17:36:12 -08005588 Rect parentSourceBounds = parent->getCroppedBufferSize(parent->getCurrentState());
Robert Carrc0df3122019-04-11 13:18:21 -07005589 if (sourceCrop.width() <= 0) {
5590 crop.left = 0;
Vishnu Nairefc42e22019-12-03 17:36:12 -08005591 crop.right = parentSourceBounds.getWidth();
Robert Carrc0df3122019-04-11 13:18:21 -07005592 }
5593
5594 if (sourceCrop.height() <= 0) {
5595 crop.top = 0;
Vishnu Nairefc42e22019-12-03 17:36:12 -08005596 crop.bottom = parentSourceBounds.getHeight();
5597 }
5598
5599 if (crop.isEmpty() || frameScale <= 0.0f) {
5600 // Error out if the layer has no source bounds (i.e. they are boundless) and a source
5601 // crop was not specified, or an invalid frame scale was provided.
5602 return BAD_VALUE;
Robert Carrc0df3122019-04-11 13:18:21 -07005603 }
5604 reqWidth = crop.width() * frameScale;
5605 reqHeight = crop.height() * frameScale;
5606
5607 for (const auto& handle : excludeHandles) {
Alec Mouri9a02eda2020-04-21 17:39:34 -07005608 sp<Layer> excludeLayer = fromHandleLocked(handle).promote();
Robert Carrc0df3122019-04-11 13:18:21 -07005609 if (excludeLayer != nullptr) {
5610 excludeLayers.emplace(excludeLayer);
5611 } else {
5612 ALOGW("Invalid layer handle passed as excludeLayer to captureLayers");
5613 return NAME_NOT_FOUND;
5614 }
5615 }
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005616
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005617 const auto display = getDisplayByLayerStack(parent->getLayerStack());
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005618 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005619 return NAME_NOT_FOUND;
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005620 }
5621
5622 displayViewport = display->getViewport();
Robert Carrc0df3122019-04-11 13:18:21 -07005623 } // mStateLock
chaviw7206d492017-11-10 16:16:12 -08005624
Chia-I Wu20261cb2018-08-23 12:55:44 -07005625 // really small crop or frameScale
5626 if (reqWidth <= 0) {
5627 reqWidth = 1;
5628 }
5629 if (reqHeight <= 0) {
5630 reqHeight = 1;
5631 }
5632
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005633 LayerRenderArea renderArea(this, parent, crop, reqWidth, reqHeight, reqDataspace, childrenOnly,
5634 displayViewport);
Robert Carr866455f2019-04-02 16:28:26 -07005635 auto traverseLayers = [parent, childrenOnly,
5636 &excludeLayers](const LayerVector::Visitor& visitor) {
chaviwa76b2712017-09-20 12:02:26 -07005637 parent->traverseChildrenInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
5638 if (!layer->isVisible()) {
5639 return;
Robert Carr578038f2018-03-09 12:25:24 -08005640 } else if (childrenOnly && layer == parent.get()) {
5641 return;
chaviwa76b2712017-09-20 12:02:26 -07005642 }
Robert Carr866455f2019-04-02 16:28:26 -07005643
5644 sp<Layer> p = layer;
5645 while (p != nullptr) {
5646 if (excludeLayers.count(p) != 0) {
5647 return;
5648 }
5649 p = p->getParent();
5650 }
5651
chaviwa76b2712017-09-20 12:02:26 -07005652 visitor(layer);
5653 });
5654 };
Robert Carr108b2c72019-04-02 16:32:58 -07005655
5656 bool outCapturedSecureLayers = false;
5657 return captureScreenCommon(renderArea, traverseLayers, outBuffer, reqPixelFormat, false,
5658 outCapturedSecureLayers);
chaviwa76b2712017-09-20 12:02:26 -07005659}
5660
5661status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea,
5662 TraverseLayersFunction traverseLayers,
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005663 sp<GraphicBuffer>* outBuffer,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005664 const ui::PixelFormat reqPixelFormat,
Robert Carr108b2c72019-04-02 16:32:58 -07005665 bool useIdentityTransform,
5666 bool& outCapturedSecureLayers) {
chaviwa76b2712017-09-20 12:02:26 -07005667 ATRACE_CALL();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005668
Peiyong Lin0e003c92018-09-17 11:09:51 -07005669 // TODO(b/116112787) Make buffer usage a parameter.
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005670 const uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
5671 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
Lloyd Pique90c115d2018-09-18 21:39:42 -07005672 *outBuffer =
5673 getFactory().createGraphicBuffer(renderArea.getReqWidth(), renderArea.getReqHeight(),
5674 static_cast<android_pixel_format>(reqPixelFormat), 1,
5675 usage, "screenshot");
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005676
Robert Carr108b2c72019-04-02 16:32:58 -07005677 return captureScreenCommon(renderArea, traverseLayers, *outBuffer, useIdentityTransform,
Lucas Dupinf11eba52020-04-20 18:42:31 -07005678 false /* regionSampling */, outCapturedSecureLayers);
Dan Stozaec460082018-12-17 15:35:09 -08005679}
5680
Kevin DuBois7cbcc372019-02-25 14:53:28 -08005681status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea,
5682 TraverseLayersFunction traverseLayers,
5683 const sp<GraphicBuffer>& buffer,
Lucas Dupinf11eba52020-04-20 18:42:31 -07005684 bool useIdentityTransform, bool regionSampling,
Robert Carr108b2c72019-04-02 16:32:58 -07005685 bool& outCapturedSecureLayers) {
Robert Carr03480e22018-01-04 16:02:06 -08005686 const int uid = IPCThreadState::self()->getCallingUid();
5687 const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
5688
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07005689 status_t result;
5690 int syncFd;
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005691
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07005692 do {
5693 std::tie(result, syncFd) =
5694 schedule([&] {
5695 if (mRefreshPending) {
5696 ATRACE_NAME("Skipping screenshot for now");
5697 return std::make_pair(EAGAIN, -1);
5698 }
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005699
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07005700 status_t result = NO_ERROR;
5701 int fd = -1;
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005702
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07005703 Mutex::Autolock lock(mStateLock);
5704 renderArea.render([&] {
5705 result = captureScreenImplLocked(renderArea, traverseLayers, buffer.get(),
5706 useIdentityTransform, forSystem, &fd,
5707 regionSampling, outCapturedSecureLayers);
5708 });
5709
5710 return std::make_pair(result, fd);
5711 }).get();
5712 } while (result == EAGAIN);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005713
5714 if (result == NO_ERROR) {
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005715 sync_wait(syncFd, -1);
5716 close(syncFd);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005717 }
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005718
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005719 return result;
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005720}
5721
chaviwa76b2712017-09-20 12:02:26 -07005722void SurfaceFlinger::renderScreenImplLocked(const RenderArea& renderArea,
Chia-I Wu1be50b52018-08-29 10:44:48 -07005723 TraverseLayersFunction traverseLayers,
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005724 ANativeWindowBuffer* buffer, bool useIdentityTransform,
Lucas Dupinf11eba52020-04-20 18:42:31 -07005725 bool regionSampling, int* outSyncFd) {
Mathias Agopian180f10d2013-04-10 22:55:41 -07005726 ATRACE_CALL();
chaviwa76b2712017-09-20 12:02:26 -07005727
chaviwa76b2712017-09-20 12:02:26 -07005728 const auto reqWidth = renderArea.getReqWidth();
5729 const auto reqHeight = renderArea.getReqHeight();
Alec Mouriadb75f42019-03-28 21:42:24 -07005730 const auto sourceCrop = renderArea.getSourceCrop();
Alec Mouri5a6d8572020-03-23 23:56:15 -07005731 const auto transform = renderArea.getTransform();
5732 const auto rotation = renderArea.getRotationFlags();
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005733 const auto& displayViewport = renderArea.getDisplayViewport();
Dan Stozac1879002014-05-22 15:59:05 -07005734
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005735 renderengine::DisplaySettings clientCompositionDisplay;
Vishnu Nair9b079a22020-01-21 14:36:08 -08005736 std::vector<compositionengine::LayerFE::LayerSettings> clientCompositionLayers;
Romain Guy88d37dd2017-05-26 17:57:05 -07005737
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005738 // assume that bounds are never offset, and that they are the same as the
5739 // buffer bounds.
5740 clientCompositionDisplay.physicalDisplay = Rect(reqWidth, reqHeight);
Alec Mouriadb75f42019-03-28 21:42:24 -07005741 clientCompositionDisplay.clip = sourceCrop;
Alec Mouri5a6d8572020-03-23 23:56:15 -07005742 clientCompositionDisplay.orientation = rotation;
Alec Mouriadb75f42019-03-28 21:42:24 -07005743
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005744 clientCompositionDisplay.outputDataspace = renderArea.getReqDataSpace();
5745 clientCompositionDisplay.maxLuminance = DisplayDevice::sDefaultMaxLumiance;
Mathias Agopian180f10d2013-04-10 22:55:41 -07005746
chaviw50da5042018-04-09 13:49:37 -07005747 const float alpha = RenderArea::getCaptureFillValue(renderArea.getCaptureFill());
Mathias Agopian180f10d2013-04-10 22:55:41 -07005748
Vishnu Nair9b079a22020-01-21 14:36:08 -08005749 compositionengine::LayerFE::LayerSettings fillLayer;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005750 fillLayer.source.buffer.buffer = nullptr;
5751 fillLayer.source.solidColor = half3(0.0, 0.0, 0.0);
Alec Mouri5a6d8572020-03-23 23:56:15 -07005752 fillLayer.geometry.boundaries =
5753 FloatRect(sourceCrop.left, sourceCrop.top, sourceCrop.right, sourceCrop.bottom);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005754 fillLayer.alpha = half(alpha);
5755 clientCompositionLayers.push_back(fillLayer);
5756
Yichi Chen40773d92020-04-01 10:10:18 +08005757 std::vector<Layer*> renderedLayers;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005758 Region clearRegion = Region::INVALID_REGION;
chaviwa76b2712017-09-20 12:02:26 -07005759 traverseLayers([&](Layer* layer) {
Lloyd Piquef16688f2019-02-19 17:47:57 -08005760 const bool supportProtectedContent = false;
5761 Region clip(renderArea.getBounds());
5762 compositionengine::LayerFE::ClientCompositionTargetSettings targetSettings{
5763 clip,
5764 useIdentityTransform,
Alec Mouri5a6d8572020-03-23 23:56:15 -07005765 layer->needsFilteringForScreenshots(renderArea.getDisplayDevice(), transform) ||
5766 renderArea.needsFiltering(),
Lloyd Piquef16688f2019-02-19 17:47:57 -08005767 renderArea.isSecure(),
5768 supportProtectedContent,
5769 clearRegion,
Vishnu Nairb87d94f2020-02-13 09:17:36 -08005770 displayViewport,
5771 clientCompositionDisplay.outputDataspace,
5772 true, /* realContentIsVisible */
5773 false, /* clearContent */
Lloyd Piquef16688f2019-02-19 17:47:57 -08005774 };
Vishnu Nairb87d94f2020-02-13 09:17:36 -08005775 std::vector<compositionengine::LayerFE::LayerSettings> results =
5776 layer->prepareClientCompositionList(targetSettings);
Yichi Chen40773d92020-04-01 10:10:18 +08005777 if (results.size() > 0) {
Alec Mouri5a6d8572020-03-23 23:56:15 -07005778 for (auto& settings : results) {
5779 settings.geometry.positionTransform =
5780 transform.asMatrix4() * settings.geometry.positionTransform;
Lucas Dupinf11eba52020-04-20 18:42:31 -07005781 // There's no need to process blurs when we're executing region sampling,
5782 // we're just trying to understand what we're drawing, and doing so without
5783 // blurs is already a pretty good approximation.
5784 if (regionSampling) {
5785 settings.backgroundBlurRadius = 0;
5786 }
Alec Mouri5a6d8572020-03-23 23:56:15 -07005787 }
Yichi Chen40773d92020-04-01 10:10:18 +08005788 clientCompositionLayers.insert(clientCompositionLayers.end(),
5789 std::make_move_iterator(results.begin()),
5790 std::make_move_iterator(results.end()));
5791 renderedLayers.push_back(layer);
5792 }
chaviwa76b2712017-09-20 12:02:26 -07005793 });
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005794
Yichi Chen40773d92020-04-01 10:10:18 +08005795 std::vector<const renderengine::LayerSettings*> clientCompositionLayerPointers(
5796 clientCompositionLayers.size());
Vishnu Nair9b079a22020-01-21 14:36:08 -08005797 std::transform(clientCompositionLayers.begin(), clientCompositionLayers.end(),
Yichi Chen40773d92020-04-01 10:10:18 +08005798 clientCompositionLayerPointers.begin(),
5799 std::pointer_traits<renderengine::LayerSettings*>::pointer_to);
Vishnu Nair9b079a22020-01-21 14:36:08 -08005800
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005801 clientCompositionDisplay.clearRegion = clearRegion;
Alec Mouri6338c9d2019-02-07 16:57:51 -08005802 // Use an empty fence for the buffer fence, since we just created the buffer so
5803 // there is no need for synchronization with the GPU.
5804 base::unique_fd bufferFence;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005805 base::unique_fd drawFence;
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08005806 getRenderEngine().useProtectedContext(false);
Vishnu Nair9b079a22020-01-21 14:36:08 -08005807 getRenderEngine().drawLayers(clientCompositionDisplay, clientCompositionLayerPointers, buffer,
Alec Mourife0d72b2019-03-21 14:05:56 -07005808 /*useFramebufferCache=*/false, std::move(bufferFence), &drawFence);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005809
5810 *outSyncFd = drawFence.release();
Yichi Chen40773d92020-04-01 10:10:18 +08005811
5812 if (*outSyncFd >= 0) {
5813 sp<Fence> releaseFence = new Fence(dup(*outSyncFd));
5814 for (auto* layer : renderedLayers) {
5815 layer->onLayerDisplayed(releaseFence);
5816 }
5817 }
Mathias Agopian180f10d2013-04-10 22:55:41 -07005818}
5819
chaviwa76b2712017-09-20 12:02:26 -07005820status_t SurfaceFlinger::captureScreenImplLocked(const RenderArea& renderArea,
5821 TraverseLayersFunction traverseLayers,
5822 ANativeWindowBuffer* buffer,
Robert Carr108b2c72019-04-02 16:32:58 -07005823 bool useIdentityTransform, bool forSystem,
Lucas Dupinf11eba52020-04-20 18:42:31 -07005824 int* outSyncFd, bool regionSampling,
5825 bool& outCapturedSecureLayers) {
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005826 ATRACE_CALL();
5827
chaviwa76b2712017-09-20 12:02:26 -07005828 traverseLayers([&](Layer* layer) {
Robert Carr108b2c72019-04-02 16:32:58 -07005829 outCapturedSecureLayers =
5830 outCapturedSecureLayers || (layer->isVisible() && layer->isSecure());
chaviwa76b2712017-09-20 12:02:26 -07005831 });
Pablo Ceballosb5b35632016-02-23 11:18:51 -08005832
Robert Carr03480e22018-01-04 16:02:06 -08005833 // We allow the system server to take screenshots of secure layers for
5834 // use in situations like the Screen-rotation animation and place
5835 // the impetus on WindowManager to not persist them.
Robert Carr108b2c72019-04-02 16:32:58 -07005836 if (outCapturedSecureLayers && !forSystem) {
Pablo Ceballosb5b35632016-02-23 11:18:51 -08005837 ALOGW("FB is protected: PERMISSION_DENIED");
5838 return PERMISSION_DENIED;
5839 }
Lucas Dupinf11eba52020-04-20 18:42:31 -07005840 renderScreenImplLocked(renderArea, traverseLayers, buffer, useIdentityTransform, regionSampling,
5841 outSyncFd);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005842 return NO_ERROR;
Mathias Agopian74c40c02010-09-29 13:02:36 -07005843}
5844
chaviw95ef3c42019-02-14 10:55:09 -08005845void SurfaceFlinger::setInputWindowsFinished() {
5846 Mutex::Autolock _l(mStateLock);
5847
5848 mPendingSyncInputWindows = false;
Rob Carr9a2cc992020-03-06 12:44:45 -08005849
chaviw95ef3c42019-02-14 10:55:09 -08005850 mTransactionCV.broadcast();
5851}
chaviw5f21a5e2019-02-14 10:00:34 -08005852
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07005853// ---------------------------------------------------------------------------
5854
Edgar Arriaga844fa672020-01-16 14:21:42 -08005855void SurfaceFlinger::State::traverse(const LayerVector::Visitor& visitor) const {
5856 layersSortedByZ.traverse(visitor);
5857}
5858
Dan Stoza412903f2017-04-27 13:42:17 -07005859void SurfaceFlinger::State::traverseInZOrder(const LayerVector::Visitor& visitor) const {
5860 layersSortedByZ.traverseInZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07005861}
5862
Dan Stoza412903f2017-04-27 13:42:17 -07005863void SurfaceFlinger::State::traverseInReverseZOrder(const LayerVector::Visitor& visitor) const {
5864 layersSortedByZ.traverseInReverseZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07005865}
5866
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005867void SurfaceFlinger::traverseLayersInDisplay(const sp<const DisplayDevice>& display,
chaviwa76b2712017-09-20 12:02:26 -07005868 const LayerVector::Visitor& visitor) {
5869 // We loop through the first level of layers without traversing,
chaviw0e3479f2018-09-10 16:49:30 -07005870 // as we need to determine which layers belong to the requested display.
chaviwa76b2712017-09-20 12:02:26 -07005871 for (const auto& layer : mDrawingState.layersSortedByZ) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005872 if (!layer->belongsToDisplay(display->getLayerStack(), false)) {
chaviwa76b2712017-09-20 12:02:26 -07005873 continue;
5874 }
Chia-I Wuec2d9852017-11-21 09:21:01 -08005875 // relative layers are traversed in Layer::traverseInZOrder
chaviwa76b2712017-09-20 12:02:26 -07005876 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005877 if (!layer->belongsToDisplay(display->getLayerStack(), false)) {
Adrian Roos8acf5a02018-01-17 21:28:19 +01005878 return;
5879 }
chaviwa76b2712017-09-20 12:02:26 -07005880 if (!layer->isVisible()) {
5881 return;
5882 }
5883 visitor(layer);
5884 });
5885 }
5886}
5887
Steven Thomasd4071902020-03-24 16:02:53 -07005888status_t SurfaceFlinger::setDesiredDisplayConfigSpecsInternal(
5889 const sp<DisplayDevice>& display,
5890 const std::optional<scheduler::RefreshRateConfigs::Policy>& policy, bool overridePolicy) {
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005891 Mutex::Autolock lock(mStateLock);
5892
Steven Thomasd4071902020-03-24 16:02:53 -07005893 LOG_ALWAYS_FATAL_IF(!display->isPrimary() && overridePolicy,
5894 "Can only set override policy on the primary display");
5895 LOG_ALWAYS_FATAL_IF(!policy && !overridePolicy, "Can only clear the override policy");
5896
Dominik Laskowski22488f62019-03-28 09:53:04 -07005897 if (!display->isPrimary()) {
Ady Abraham3a77a7b2019-12-02 18:46:59 -08005898 // TODO(b/144711714): For non-primary displays we should be able to set an active config
5899 // as well. For now, just call directly to setActiveConfigWithConstraints but ideally
5900 // it should go thru setDesiredActiveConfig, similar to primary display.
5901 ALOGV("setAllowedDisplayConfigsInternal for non-primary display");
5902 const auto displayId = display->getId();
5903 LOG_ALWAYS_FATAL_IF(!displayId);
5904
Peiyong Line9d809e2020-04-14 13:10:48 -07005905 hal::VsyncPeriodChangeConstraints constraints;
Ady Abraham3a77a7b2019-12-02 18:46:59 -08005906 constraints.desiredTimeNanos = systemTime();
5907 constraints.seamlessRequired = false;
5908
Peiyong Line9d809e2020-04-14 13:10:48 -07005909 hal::VsyncPeriodChangeTimeline timeline = {0, 0, 0};
Steven Thomasd4071902020-03-24 16:02:53 -07005910 if (getHwComposer().setActiveConfigWithConstraints(*displayId,
5911 policy->defaultConfig.value(),
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005912 constraints, &timeline) < 0) {
5913 return BAD_VALUE;
5914 }
Ady Abraham3a77a7b2019-12-02 18:46:59 -08005915 if (timeline.refreshRequired) {
5916 repaintEverythingForHWC();
5917 }
5918
Steven Thomasd4071902020-03-24 16:02:53 -07005919 display->setActiveConfig(policy->defaultConfig);
5920 const nsecs_t vsyncPeriod = getHwComposer()
5921 .getConfigs(*displayId)[policy->defaultConfig.value()]
5922 ->getVsyncPeriod();
5923 mScheduler->onConfigChanged(mAppConnectionHandle, display->getId()->value,
5924 policy->defaultConfig, vsyncPeriod);
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005925 return NO_ERROR;
Ady Abraham838de062019-02-04 10:24:03 -08005926 }
5927
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005928 if (mDebugDisplayConfigSetByBackdoor) {
5929 // ignore this request as config is overridden by backdoor
5930 return NO_ERROR;
Adrian Salidoab6ef6c2019-08-28 10:02:49 -07005931 }
5932
Steven Thomasd4071902020-03-24 16:02:53 -07005933 status_t setPolicyResult = overridePolicy
5934 ? mRefreshRateConfigs->setOverridePolicy(policy)
5935 : mRefreshRateConfigs->setDisplayManagerPolicy(*policy);
5936 if (setPolicyResult < 0) {
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005937 return BAD_VALUE;
5938 }
Steven Thomasd4071902020-03-24 16:02:53 -07005939 if (setPolicyResult == scheduler::RefreshRateConfigs::CURRENT_POLICY_UNCHANGED) {
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005940 return NO_ERROR;
5941 }
Steven Thomasd4071902020-03-24 16:02:53 -07005942 scheduler::RefreshRateConfigs::Policy currentPolicy = mRefreshRateConfigs->getCurrentPolicy();
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005943
Steven Thomasf734df42020-04-13 21:09:28 -07005944 ALOGV("Setting desired display config specs: defaultConfig: %d primaryRange: [%.0f %.0f]"
5945 " expandedRange: [%.0f %.0f]",
5946 currentPolicy.defaultConfig.value(), currentPolicy.primaryRange.min,
5947 currentPolicy.primaryRange.max, currentPolicy.appRequestRange.min,
5948 currentPolicy.appRequestRange.max);
Adrian Salidoab6ef6c2019-08-28 10:02:49 -07005949
5950 // TODO(b/140204874): This hack triggers a notification that something has changed, so
5951 // that listeners that care about a change in allowed configs can get the notification.
5952 // Giving current ActiveConfig so that most other listeners would just drop the event
Alec Mouri60aee1c2019-10-28 16:18:59 -07005953 const nsecs_t vsyncPeriod =
Ady Abrahamabc27602020-04-08 17:20:29 -07005954 mRefreshRateConfigs->getRefreshRateFromConfigId(display->getActiveConfig())
5955 .getVsyncPeriod();
Adrian Salidoab6ef6c2019-08-28 10:02:49 -07005956 mScheduler->onConfigChanged(mAppConnectionHandle, display->getId()->value,
Alec Mouri60aee1c2019-10-28 16:18:59 -07005957 display->getActiveConfig(), vsyncPeriod);
Ady Abraham838de062019-02-04 10:24:03 -08005958
Ana Krulec3f6a2062020-01-23 15:48:01 -08005959 auto configId = mScheduler->getPreferredConfigId();
Ady Abraham2e1dd892020-03-05 13:48:36 -08005960 auto& preferredRefreshRate = configId
Ana Krulec3f6a2062020-01-23 15:48:01 -08005961 ? mRefreshRateConfigs->getRefreshRateFromConfigId(*configId)
5962 // NOTE: Choose the default config ID, if Scheduler doesn't have one in mind.
Steven Thomasd4071902020-03-24 16:02:53 -07005963 : mRefreshRateConfigs->getRefreshRateFromConfigId(currentPolicy.defaultConfig);
Ana Krulec3f6a2062020-01-23 15:48:01 -08005964 ALOGV("trying to switch to Scheduler preferred config %d (%s)",
Ady Abrahamabc27602020-04-08 17:20:29 -07005965 preferredRefreshRate.getConfigId().value(), preferredRefreshRate.getName().c_str());
Ana Krulec3f6a2062020-01-23 15:48:01 -08005966
Ady Abrahamabc27602020-04-08 17:20:29 -07005967 if (isDisplayConfigAllowed(preferredRefreshRate.getConfigId())) {
5968 ALOGV("switching to Scheduler preferred config %d",
5969 preferredRefreshRate.getConfigId().value());
5970 setDesiredActiveConfig(
5971 {preferredRefreshRate.getConfigId(), Scheduler::ConfigEvent::Changed});
Ady Abraham2139f732019-11-13 18:56:40 -08005972 } else {
Ady Abrahamabc27602020-04-08 17:20:29 -07005973 LOG_ALWAYS_FATAL("Desired config not allowed: %d",
5974 preferredRefreshRate.getConfigId().value());
Dominik Laskowski4f1dd8c2019-04-17 15:54:30 -07005975 }
5976
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08005977 return NO_ERROR;
5978}
5979
Ana Krulec0782b882019-10-15 17:34:54 -07005980status_t SurfaceFlinger::setDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken,
Steven Thomasf734df42020-04-13 21:09:28 -07005981 int32_t defaultConfig,
5982 float primaryRefreshRateMin,
5983 float primaryRefreshRateMax,
5984 float appRequestRefreshRateMin,
5985 float appRequestRefreshRateMax) {
Ana Krulec0782b882019-10-15 17:34:54 -07005986 ATRACE_CALL();
5987
5988 if (!displayToken) {
5989 return BAD_VALUE;
5990 }
5991
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07005992 auto future = schedule([=]() -> status_t {
Ana Krulec234bb162019-11-10 22:55:55 +01005993 const auto display = getDisplayDeviceLocked(displayToken);
5994 if (!display) {
5995 ALOGE("Attempt to set desired display configs for invalid display token %p",
5996 displayToken.get());
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07005997 return NAME_NOT_FOUND;
Ana Krulec234bb162019-11-10 22:55:55 +01005998 } else if (display->isVirtual()) {
5999 ALOGW("Attempt to set desired display configs for virtual display");
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006000 return INVALID_OPERATION;
Ana Krulec234bb162019-11-10 22:55:55 +01006001 } else {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006002 using Policy = scheduler::RefreshRateConfigs::Policy;
Steven Thomasf734df42020-04-13 21:09:28 -07006003 const Policy policy{HwcConfigIndexType(defaultConfig),
6004 {primaryRefreshRateMin, primaryRefreshRateMax},
6005 {appRequestRefreshRateMin, appRequestRefreshRateMax}};
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006006 constexpr bool kOverridePolicy = false;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006007
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006008 return setDesiredDisplayConfigSpecsInternal(display, policy, kOverridePolicy);
6009 }
6010 });
6011
6012 return future.get();
Ana Krulec234bb162019-11-10 22:55:55 +01006013}
6014
6015status_t SurfaceFlinger::getDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken,
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006016 int32_t* outDefaultConfig,
Steven Thomasf734df42020-04-13 21:09:28 -07006017 float* outPrimaryRefreshRateMin,
6018 float* outPrimaryRefreshRateMax,
6019 float* outAppRequestRefreshRateMin,
6020 float* outAppRequestRefreshRateMax) {
Ana Krulec234bb162019-11-10 22:55:55 +01006021 ATRACE_CALL();
6022
Steven Thomasf734df42020-04-13 21:09:28 -07006023 if (!displayToken || !outDefaultConfig || !outPrimaryRefreshRateMin ||
6024 !outPrimaryRefreshRateMax || !outAppRequestRefreshRateMin || !outAppRequestRefreshRateMax) {
Ana Krulec234bb162019-11-10 22:55:55 +01006025 return BAD_VALUE;
6026 }
6027
6028 Mutex::Autolock lock(mStateLock);
6029 const auto display = getDisplayDeviceLocked(displayToken);
6030 if (!display) {
6031 return NAME_NOT_FOUND;
6032 }
6033
6034 if (display->isPrimary()) {
Steven Thomasd4071902020-03-24 16:02:53 -07006035 scheduler::RefreshRateConfigs::Policy policy =
6036 mRefreshRateConfigs->getDisplayManagerPolicy();
6037 *outDefaultConfig = policy.defaultConfig.value();
Steven Thomasf734df42020-04-13 21:09:28 -07006038 *outPrimaryRefreshRateMin = policy.primaryRange.min;
6039 *outPrimaryRefreshRateMax = policy.primaryRange.max;
6040 *outAppRequestRefreshRateMin = policy.appRequestRange.min;
6041 *outAppRequestRefreshRateMax = policy.appRequestRange.max;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006042 return NO_ERROR;
6043 } else if (display->isVirtual()) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07006044 return INVALID_OPERATION;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006045 } else {
6046 const auto displayId = display->getId();
Dominik Laskowski470df5f2020-04-02 22:27:42 -07006047 LOG_FATAL_IF(!displayId);
6048
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006049 *outDefaultConfig = getHwComposer().getActiveConfigIndex(*displayId);
6050 auto vsyncPeriod = getHwComposer().getActiveConfig(*displayId)->getVsyncPeriod();
Steven Thomasf734df42020-04-13 21:09:28 -07006051 *outPrimaryRefreshRateMin = 1e9f / vsyncPeriod;
6052 *outPrimaryRefreshRateMax = 1e9f / vsyncPeriod;
6053 *outAppRequestRefreshRateMin = 1e9f / vsyncPeriod;
6054 *outAppRequestRefreshRateMax = 1e9f / vsyncPeriod;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006055 return NO_ERROR;
Ana Krulec234bb162019-11-10 22:55:55 +01006056 }
Ana Krulec0782b882019-10-15 17:34:54 -07006057}
6058
Dominik Laskowski9dab3432019-03-27 13:21:10 -07006059void SurfaceFlinger::SetInputWindowsListener::onSetInputWindowsFinished() {
chaviw291d88a2019-02-14 10:33:58 -08006060 mFlinger->setInputWindowsFinished();
6061}
6062
Alec Mouri9a02eda2020-04-21 17:39:34 -07006063wp<Layer> SurfaceFlinger::fromHandle(const sp<IBinder>& handle) {
6064 Mutex::Autolock _l(mStateLock);
6065 return fromHandleLocked(handle);
6066}
6067
6068wp<Layer> SurfaceFlinger::fromHandleLocked(const sp<IBinder>& handle) {
Valerie Hau09e60052019-12-15 14:51:15 -08006069 BBinder* b = nullptr;
6070 if (handle) {
6071 b = handle->localBinder();
6072 }
Robert Carrc0df3122019-04-11 13:18:21 -07006073 if (b == nullptr) {
6074 return nullptr;
6075 }
6076 auto it = mLayersByLocalBinderToken.find(b);
6077 if (it != mLayersByLocalBinderToken.end()) {
Alec Mouri9a02eda2020-04-21 17:39:34 -07006078 return it->second;
Robert Carrc0df3122019-04-11 13:18:21 -07006079 }
6080 return nullptr;
6081}
6082
Dominik Laskowski75848362019-11-11 17:57:20 -08006083void SurfaceFlinger::onLayerFirstRef(Layer* layer) {
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -07006084 mNumLayers++;
6085 mScheduler->registerLayer(layer);
6086}
6087
6088void SurfaceFlinger::onLayerDestroyed(Layer* layer) {
6089 mNumLayers--;
Valerie Hauc5686802019-11-22 14:18:09 -08006090 removeFromOffscreenLayers(layer);
6091}
6092
6093// WARNING: ONLY CALL THIS FROM LAYER DTOR
6094// Here we add children in the current state to offscreen layers and remove the
6095// layer itself from the offscreen layer list. Since
6096// this is the dtor, it is safe to access the current state. This keeps us
6097// from dangling children layers such that they are not reachable from the
6098// Drawing state nor the offscreen layer list
6099// See b/141111965
6100void SurfaceFlinger::removeFromOffscreenLayers(Layer* layer) {
6101 for (auto& child : layer->getCurrentChildren()) {
6102 mOffscreenLayers.emplace(child.get());
6103 }
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -07006104 mOffscreenLayers.erase(layer);
6105}
6106
Alec Mouri4545a8a2019-08-08 20:05:32 -07006107void SurfaceFlinger::bufferErased(const client_cache_t& clientCacheId) {
6108 getRenderEngine().unbindExternalTextureBuffer(clientCacheId.id);
6109}
6110
Vishnu Nair08f6eae2019-11-26 14:01:39 -08006111status_t SurfaceFlinger::setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
6112 float lightPosY, float lightPosZ,
6113 float lightRadius) {
6114 Mutex::Autolock _l(mStateLock);
6115 mCurrentState.globalShadowSettings.ambientColor = vec4(ambientColor);
6116 mCurrentState.globalShadowSettings.spotColor = vec4(spotColor);
6117 mCurrentState.globalShadowSettings.lightPos.y = lightPosY;
6118 mCurrentState.globalShadowSettings.lightPos.z = lightPosZ;
6119 mCurrentState.globalShadowSettings.lightRadius = lightRadius;
6120
6121 // these values are overridden when calculating the shadow settings for a layer.
6122 mCurrentState.globalShadowSettings.lightPos.x = 0.f;
6123 mCurrentState.globalShadowSettings.length = 0.f;
Vishnu Nairb13bb952019-11-15 10:24:08 -08006124 return NO_ERROR;
6125}
6126
Lloyd Pique8d9f8362020-02-11 19:13:09 -08006127const std::unordered_map<std::string, uint32_t>& SurfaceFlinger::getGenericLayerMetadataKeyMap()
6128 const {
6129 // TODO(b/149500060): Remove this fixed/static mapping. Please prefer taking
6130 // on the work to remove the table in that bug rather than adding more to
6131 // it.
6132 static const std::unordered_map<std::string, uint32_t> genericLayerMetadataKeyMap{
6133 // Note: METADATA_OWNER_UID and METADATA_WINDOW_TYPE are officially
6134 // supported, and exposed via the
6135 // IVrComposerClient::VrCommand::SET_LAYER_INFO command.
6136 {"org.chromium.arc.V1_0.TaskId", METADATA_TASK_ID},
6137 {"org.chromium.arc.V1_0.CursorInfo", METADATA_MOUSE_CURSOR},
6138 };
6139 return genericLayerMetadataKeyMap;
6140}
6141
Steven Thomas62a4cf82020-01-31 12:04:03 -08006142status_t SurfaceFlinger::setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,
6143 int8_t compatibility) {
6144 if (!ValidateFrameRate(frameRate, compatibility, "SurfaceFlinger::setFrameRate")) {
6145 return BAD_VALUE;
6146 }
6147
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006148 static_cast<void>(schedule([=]() NO_THREAD_SAFETY_ANALYSIS {
Ady Abraham60e42ea2020-03-09 19:17:31 -07006149 Mutex::Autolock lock(mStateLock);
6150 if (authenticateSurfaceTextureLocked(surface)) {
6151 sp<Layer> layer = (static_cast<MonitoredProducer*>(surface.get()))->getLayer();
6152 if (layer->setFrameRate(
6153 Layer::FrameRate(frameRate,
6154 Layer::FrameRate::convertCompatibility(compatibility)))) {
6155 setTransactionFlags(eTraversalNeeded);
6156 }
6157 } else {
6158 ALOGE("Attempt to set frame rate on an unrecognized IGraphicBufferProducer");
6159 return BAD_VALUE;
Steven Thomas62a4cf82020-01-31 12:04:03 -08006160 }
Ady Abraham60e42ea2020-03-09 19:17:31 -07006161 return NO_ERROR;
6162 }));
6163
Steven Thomas62a4cf82020-01-31 12:04:03 -08006164 return NO_ERROR;
6165}
6166
Steven Thomasd4071902020-03-24 16:02:53 -07006167status_t SurfaceFlinger::acquireFrameRateFlexibilityToken(sp<IBinder>* outToken) {
6168 if (!outToken) {
6169 return BAD_VALUE;
6170 }
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006171
6172 auto future = schedule([this] {
6173 status_t result = NO_ERROR;
6174 sp<IBinder> token;
6175
Steven Thomasd4071902020-03-24 16:02:53 -07006176 if (mFrameRateFlexibilityTokenCount == 0) {
6177 // |mStateLock| not needed as we are on the main thread
6178 const auto display = getDefaultDisplayDeviceLocked();
6179
6180 // This is a little racy, but not in a way that hurts anything. As we grab the
6181 // defaultConfig from the display manager policy, we could be setting a new display
6182 // manager policy, leaving us using a stale defaultConfig. The defaultConfig doesn't
6183 // matter for the override policy though, since we set allowGroupSwitching to true, so
6184 // it's not a problem.
6185 scheduler::RefreshRateConfigs::Policy overridePolicy;
6186 overridePolicy.defaultConfig =
6187 mRefreshRateConfigs->getDisplayManagerPolicy().defaultConfig;
6188 overridePolicy.allowGroupSwitching = true;
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006189 constexpr bool kOverridePolicy = true;
6190 result = setDesiredDisplayConfigSpecsInternal(display, overridePolicy, kOverridePolicy);
Steven Thomasd4071902020-03-24 16:02:53 -07006191 }
6192
6193 if (result == NO_ERROR) {
6194 mFrameRateFlexibilityTokenCount++;
6195 // Handing out a reference to the SurfaceFlinger object, as we're doing in the line
6196 // below, is something to consider carefully. The lifetime of the
6197 // FrameRateFlexibilityToken isn't tied to SurfaceFlinger object lifetime, so if this
6198 // SurfaceFlinger object were to be destroyed while the token still exists, the token
6199 // destructor would be accessing a stale SurfaceFlinger reference, and crash. This is ok
6200 // in this case, for two reasons:
6201 // 1. Once SurfaceFlinger::run() is called by main_surfaceflinger.cpp, the only way
6202 // the program exits is via a crash. So we won't have a situation where the
6203 // SurfaceFlinger object is dead but the process is still up.
6204 // 2. The frame rate flexibility token is acquired/released only by CTS tests, so even
6205 // if condition 1 were changed, the problem would only show up when running CTS tests,
6206 // not on end user devices, so we could spot it and fix it without serious impact.
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006207 token = new FrameRateFlexibilityToken(
Steven Thomasd4071902020-03-24 16:02:53 -07006208 [this]() { onFrameRateFlexibilityTokenReleased(); });
6209 ALOGD("Frame rate flexibility token acquired. count=%d",
6210 mFrameRateFlexibilityTokenCount);
6211 }
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006212
6213 return std::make_pair(result, token);
6214 });
6215
6216 status_t result;
6217 std::tie(result, *outToken) = future.get();
Steven Thomasd4071902020-03-24 16:02:53 -07006218 return result;
6219}
6220
6221void SurfaceFlinger::onFrameRateFlexibilityTokenReleased() {
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006222 static_cast<void>(schedule([this] {
Steven Thomasd4071902020-03-24 16:02:53 -07006223 LOG_ALWAYS_FATAL_IF(mFrameRateFlexibilityTokenCount == 0,
6224 "Failed tracking frame rate flexibility tokens");
6225 mFrameRateFlexibilityTokenCount--;
6226 ALOGD("Frame rate flexibility token released. count=%d", mFrameRateFlexibilityTokenCount);
6227 if (mFrameRateFlexibilityTokenCount == 0) {
6228 // |mStateLock| not needed as we are on the main thread
6229 const auto display = getDefaultDisplayDeviceLocked();
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07006230 constexpr bool kOverridePolicy = true;
6231 status_t result = setDesiredDisplayConfigSpecsInternal(display, {}, kOverridePolicy);
Steven Thomasd4071902020-03-24 16:02:53 -07006232 LOG_ALWAYS_FATAL_IF(result < 0, "Failed releasing frame rate flexibility token");
6233 }
6234 }));
6235}
6236
Dominik Laskowski9dab3432019-03-27 13:21:10 -07006237} // namespace android
Lloyd Pique074e8122018-07-26 12:57:23 -07006238
Mathias Agopian3f844832013-08-07 21:24:32 -07006239#if defined(__gl_h_)
6240#error "don't include gl/gl.h in this file"
6241#endif
6242
6243#if defined(__gl2_h_)
6244#error "don't include gl2/gl2.h in this file"
Chia-I Wu767fcf72017-11-30 22:07:38 -08006245#endif
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08006246
6247// TODO(b/129481165): remove the #pragma below and fix conversion issues
6248#pragma clang diagnostic pop // ignored "-Wconversion"