blob: 63b77afa80b7b63d758239b6ea8e2076b3e4c039 [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
Alec Mourie7d1d4a2019-02-05 01:13:46 +000017//#define LOG_NDEBUG 0
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080018#define ATRACE_TAG ATRACE_TAG_GRAPHICS
19
Mathias Agopian921e6ac2012-07-23 23:11:29 -070020#include <sys/types.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080021#include <errno.h>
Keun young Park63f165f2012-08-31 10:53:36 -070022#include <dlfcn.h>
Dominik Laskowski83b88212018-12-11 13:34:06 -080023
24#include <algorithm>
25#include <cinttypes>
26#include <cmath>
27#include <cstdint>
28#include <functional>
29#include <mutex>
Dan Stoza2b6d38e2017-06-01 16:40:30 -070030#include <optional>
Dominik Laskowskic2867142019-01-21 11:33:38 -080031#include <unordered_map>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070032
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080033#include <cutils/properties.h>
Mark Salyzyn7823e122016-09-29 08:08:05 -070034#include <log/log.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080035
Mathias Agopianc5b2c0b2009-05-19 19:08:10 -070036#include <binder/IPCThreadState.h>
37#include <binder/IServiceManager.h>
Mathias Agopian99b49842011-06-27 16:05:52 -070038#include <binder/PermissionCache.h>
Mathias Agopian7303c6b2009-07-02 18:11:53 -070039
Lloyd Pique70d91362018-10-18 16:02:55 -070040#include <compositionengine/CompositionEngine.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070041#include <compositionengine/Display.h>
Lloyd Pique3d0c02e2018-10-19 18:38:12 -070042#include <compositionengine/DisplayColorProfile.h>
Lloyd Piquecc01a452018-12-04 17:24:00 -080043#include <compositionengine/Layer.h>
44#include <compositionengine/OutputLayer.h>
Lloyd Pique31cb2942018-10-19 17:23:03 -070045#include <compositionengine/RenderSurface.h>
Lloyd Pique0b785d82018-12-04 17:25:27 -080046#include <compositionengine/impl/LayerCompositionState.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070047#include <compositionengine/impl/OutputCompositionState.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080048#include <compositionengine/impl/OutputLayerCompositionState.h>
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -080049#include <dvr/vr_flinger.h>
Jamie Gennis1a4d8832012-08-02 20:11:05 -070050#include <gui/BufferQueue.h>
Andy McFadden4803b742012-09-24 19:07:20 -070051#include <gui/GuiConfig.h>
Jamie Gennis1a4d8832012-08-02 20:11:05 -070052#include <gui/IDisplayEventConnection.h>
Alec Mouri0a9c7b82018-11-16 13:05:25 -080053#include <gui/IProducerListener.h>
Kalle Raitaa099a242017-01-11 11:17:29 -080054#include <gui/LayerDebugInfo.h>
Mathias Agopiane3c697f2013-02-14 17:11:02 -080055#include <gui/Surface.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070056#include <input/IInputFlinger.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070057#include <renderengine/RenderEngine.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070058#include <ui/ColorSpace.h>
59#include <ui/DebugUtils.h>
60#include <ui/DisplayInfo.h>
61#include <ui/DisplayStatInfo.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070062#include <ui/GraphicBufferAllocator.h>
63#include <ui/PixelFormat.h>
Andy McFadden4803b742012-09-24 19:07:20 -070064#include <ui/UiConfig.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080065#include <utils/StopWatch.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070066#include <utils/String16.h>
67#include <utils/String8.h>
Yusuke Sato0a688f52015-07-30 23:05:39 -070068#include <utils/Timers.h>
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080069#include <utils/Trace.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070070#include <utils/misc.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080071
Mathias Agopian921e6ac2012-07-23 23:11:29 -070072#include <private/android_filesystem_config.h>
Mathias Agopianca088332013-03-28 17:44:13 -070073#include <private/gui/SyncFeatures.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080074
Robert Carr578038f2018-03-09 12:25:24 -080075#include "BufferLayer.h"
Marissa Wallfd668622018-05-10 10:21:13 -070076#include "BufferQueueLayer.h"
Marissa Wall61c58622018-07-18 10:12:20 -070077#include "BufferStateLayer.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +020078#include "Client.h"
Robert Carr578038f2018-03-09 12:25:24 -080079#include "ColorLayer.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +020080#include "Colorizer.h"
Robert Carr578038f2018-03-09 12:25:24 -080081#include "ContainerLayer.h"
Robert Carr578038f2018-03-09 12:25:24 -080082#include "DisplayDevice.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080083#include "Layer.h"
Robert Carr1f0a16a2016-10-24 16:27:39 -070084#include "LayerVector.h"
Robert Carr1db73f62016-12-21 12:58:51 -080085#include "MonitoredProducer.h"
Lloyd Pique22098362018-09-13 11:46:49 -070086#include "NativeWindowSurface.h"
Ady Abraham03b02dd2019-03-21 15:40:11 -070087#include "RefreshRateOverlay.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070088#include "StartPropertySetThread.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080089#include "SurfaceFlinger.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070090#include "SurfaceInterceptor.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080091
Steven Thomasb02664d2017-07-26 18:48:28 -070092#include "DisplayHardware/ComposerHal.h"
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -070093#include "DisplayHardware/DisplayIdentification.h"
Mathias Agopiana4912602012-07-12 14:25:33 -070094#include "DisplayHardware/FramebufferSurface.h"
Mathias Agopiana350ff92010-08-10 17:14:02 -070095#include "DisplayHardware/HWComposer.h"
Jesse Hall99c7dbb2013-03-14 14:29:29 -070096#include "DisplayHardware/VirtualDisplaySurface.h"
Mathias Agopianff2ed702013-09-01 21:36:12 -070097#include "Effects/Daltonizer.h"
Ana Krulecfefcb582018-08-07 14:22:37 -070098#include "Scheduler/DispSync.h"
Ana Krulec241cf832018-08-10 15:03:23 -070099#include "Scheduler/DispSyncSource.h"
Ana Krulecfefcb582018-08-07 14:22:37 -0700100#include "Scheduler/EventControlThread.h"
101#include "Scheduler/EventThread.h"
Ana Krulec47454452018-08-14 11:04:14 -0700102#include "Scheduler/InjectVSyncSource.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -0700103#include "Scheduler/MessageQueue.h"
Ana Krulec98b5b242018-08-10 15:03:23 -0700104#include "Scheduler/Scheduler.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800105#include "TimeStats/TimeStats.h"
Ana Krulecfefcb582018-08-07 14:22:37 -0700106
Mathias Agopianff2ed702013-09-01 21:36:12 -0700107#include <cutils/compiler.h>
Mathias Agopian875d8e12013-06-07 15:35:48 -0700108
David Sodman7e4ae112018-02-09 15:02:28 -0800109#include "android-base/stringprintf.h"
110
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900111#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
Iris Chang7501ed62018-04-30 14:45:42 +0800112#include <android/hardware/configstore/1.1/ISurfaceFlingerConfigs.h>
113#include <android/hardware/configstore/1.1/types.h>
Jaesoo Lee43518572017-01-23 19:03:16 +0900114#include <configstore/Utils.h>
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900115
chaviw1d044282017-09-27 12:19:28 -0700116#include <layerproto/LayerProtoParser.h>
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900117#include "SurfaceFlingerProperties.h"
chaviw1d044282017-09-27 12:19:28 -0700118
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800119namespace android {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700120
Jaesoo Lee43518572017-01-23 19:03:16 +0900121using namespace android::hardware::configstore;
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900122using namespace android::hardware::configstore::V1_0;
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900123using namespace android::sysprop;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -0800124
Yiwei Zhang5434a782018-12-05 18:06:32 -0800125using base::StringAppendF;
Peiyong Lin9f034472018-03-28 15:29:00 -0700126using ui::ColorMode;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700127using ui::Dataspace;
Daniel Solomon42d04562019-01-20 21:03:19 -0800128using ui::DisplayPrimaries;
Peiyong Lin62665892018-04-16 11:07:44 -0700129using ui::Hdr;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700130using ui::RenderIntent;
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900131
Steven Thomasb02664d2017-07-26 18:48:28 -0700132namespace {
Peiyong Linfca547f2018-07-09 13:03:33 -0700133
134#pragma clang diagnostic push
135#pragma clang diagnostic error "-Wswitch-enum"
136
137bool isWideColorMode(const ColorMode colorMode) {
138 switch (colorMode) {
139 case ColorMode::DISPLAY_P3:
140 case ColorMode::ADOBE_RGB:
141 case ColorMode::DCI_P3:
142 case ColorMode::BT2020:
Valerie Hau9758ae02018-10-09 16:05:09 -0700143 case ColorMode::DISPLAY_BT2020:
Peiyong Linfca547f2018-07-09 13:03:33 -0700144 case ColorMode::BT2100_PQ:
145 case ColorMode::BT2100_HLG:
146 return true;
147 case ColorMode::NATIVE:
148 case ColorMode::STANDARD_BT601_625:
149 case ColorMode::STANDARD_BT601_625_UNADJUSTED:
150 case ColorMode::STANDARD_BT601_525:
151 case ColorMode::STANDARD_BT601_525_UNADJUSTED:
152 case ColorMode::STANDARD_BT709:
153 case ColorMode::SRGB:
154 return false;
155 }
156 return false;
157}
158
Peiyong Lin34ea5b92019-03-15 18:40:15 -0700159bool isHdrColorMode(const ColorMode colorMode) {
160 switch (colorMode) {
161 case ColorMode::BT2100_PQ:
162 case ColorMode::BT2100_HLG:
163 return true;
164 case ColorMode::DISPLAY_P3:
165 case ColorMode::ADOBE_RGB:
166 case ColorMode::DCI_P3:
167 case ColorMode::BT2020:
168 case ColorMode::DISPLAY_BT2020:
169 case ColorMode::NATIVE:
170 case ColorMode::STANDARD_BT601_625:
171 case ColorMode::STANDARD_BT601_625_UNADJUSTED:
172 case ColorMode::STANDARD_BT601_525:
173 case ColorMode::STANDARD_BT601_525_UNADJUSTED:
174 case ColorMode::STANDARD_BT709:
175 case ColorMode::SRGB:
176 return false;
177 }
178 return false;
179}
180
Chia-I Wuc80dcbb2018-08-24 15:34:02 -0700181ui::Transform::orientation_flags fromSurfaceComposerRotation(ISurfaceComposer::Rotation rotation) {
182 switch (rotation) {
183 case ISurfaceComposer::eRotateNone:
184 return ui::Transform::ROT_0;
185 case ISurfaceComposer::eRotate90:
186 return ui::Transform::ROT_90;
187 case ISurfaceComposer::eRotate180:
188 return ui::Transform::ROT_180;
189 case ISurfaceComposer::eRotate270:
190 return ui::Transform::ROT_270;
191 }
192 ALOGE("Invalid rotation passed to captureScreen(): %d\n", rotation);
193 return ui::Transform::ROT_0;
194}
195
Peiyong Linfca547f2018-07-09 13:03:33 -0700196#pragma clang diagnostic pop
197
Steven Thomasb02664d2017-07-26 18:48:28 -0700198class ConditionalLock {
199public:
200 ConditionalLock(Mutex& mutex, bool lock) : mMutex(mutex), mLocked(lock) {
201 if (lock) {
202 mMutex.lock();
203 }
204 }
205 ~ConditionalLock() { if (mLocked) mMutex.unlock(); }
206private:
207 Mutex& mMutex;
208 bool mLocked;
209};
Peiyong Linfca547f2018-07-09 13:03:33 -0700210
Peiyong Lin9d846a52018-11-05 13:18:20 -0800211// Currently we only support V0_SRGB and DISPLAY_P3 as composition preference.
212bool validateCompositionDataspace(Dataspace dataspace) {
213 return dataspace == Dataspace::V0_SRGB || dataspace == Dataspace::DISPLAY_P3;
214}
215
Steven Thomasb02664d2017-07-26 18:48:28 -0700216} // namespace anonymous
217
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800218// ---------------------------------------------------------------------------
219
Mathias Agopian99b49842011-06-27 16:05:52 -0700220const String16 sHardwareTest("android.permission.HARDWARE_TEST");
221const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER");
222const String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER");
223const String16 sDump("android.permission.DUMP");
224
225// ---------------------------------------------------------------------------
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700226int64_t SurfaceFlinger::dispSyncPresentTimeOffset;
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700227bool SurfaceFlinger::useHwcForRgbToYuv;
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800228uint64_t SurfaceFlinger::maxVirtualDisplaySize;
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800229bool SurfaceFlinger::hasSyncFramework;
Steven Thomas050b2c82017-03-06 11:45:16 -0800230bool SurfaceFlinger::useVrFlinger;
Fabien Sanglard1971b632017-03-10 14:50:03 -0800231int64_t SurfaceFlinger::maxFrameBufferAcquiredBuffers;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600232bool SurfaceFlinger::hasWideColorDisplay;
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700233int SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientationDefault;
Peiyong Lin13effd12018-07-24 17:01:47 -0700234bool SurfaceFlinger::useColorManagement;
Peiyong Linb3839ad2018-09-05 15:37:19 -0700235bool SurfaceFlinger::useContextPriority;
Peiyong Linc6780972018-10-28 15:24:08 -0700236Dataspace SurfaceFlinger::defaultCompositionDataspace = Dataspace::V0_SRGB;
237ui::PixelFormat SurfaceFlinger::defaultCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
238Dataspace SurfaceFlinger::wideColorGamutCompositionDataspace = Dataspace::V0_SRGB;
239ui::PixelFormat SurfaceFlinger::wideColorGamutCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
Mathias Agopian99b49842011-06-27 16:05:52 -0700240
Kalle Raitaa099a242017-01-11 11:17:29 -0800241std::string getHwcServiceName() {
242 char value[PROPERTY_VALUE_MAX] = {};
243 property_get("debug.sf.hwc_service_name", value, "default");
244 ALOGI("Using HWComposer service: '%s'", value);
245 return std::string(value);
246}
247
248bool useTrebleTestingOverride() {
249 char value[PROPERTY_VALUE_MAX] = {};
250 property_get("debug.sf.treble_testing_override", value, "false");
251 ALOGI("Treble testing override: '%s'", value);
252 return std::string(value) == "true";
253}
254
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800255std::string decodeDisplayColorSetting(DisplayColorSetting displayColorSetting) {
256 switch(displayColorSetting) {
257 case DisplayColorSetting::MANAGED:
Chia-I Wu0d711262018-05-21 15:19:35 -0700258 return std::string("Managed");
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800259 case DisplayColorSetting::UNMANAGED:
Chia-I Wu0d711262018-05-21 15:19:35 -0700260 return std::string("Unmanaged");
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800261 case DisplayColorSetting::ENHANCED:
Chia-I Wu0d711262018-05-21 15:19:35 -0700262 return std::string("Enhanced");
263 default:
264 return std::string("Unknown ") +
265 std::to_string(static_cast<int>(displayColorSetting));
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800266 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800267}
268
David Sodmanbc815282017-11-05 18:57:52 -0800269SurfaceFlingerBE::SurfaceFlingerBE()
270 : mHwcServiceName(getHwcServiceName()),
David Sodman4a36e932017-11-07 14:29:47 -0800271 mFrameBuckets(),
272 mTotalTime(0),
273 mLastSwapTime(0),
David Sodmanbc815282017-11-05 18:57:52 -0800274 mComposerSequenceId(0) {
275}
276
Lloyd Pique90c115d2018-09-18 21:39:42 -0700277SurfaceFlinger::SurfaceFlinger(surfaceflinger::Factory& factory,
278 SurfaceFlinger::SkipInitializationTag)
Lloyd Pique12eb4232018-01-17 11:54:43 -0800279 : BnSurfaceComposer(),
Lloyd Pique90c115d2018-09-18 21:39:42 -0700280 mFactory(factory),
Jamie Gennis2d5e2302012-10-15 18:24:43 -0700281 mTransactionPending(false),
282 mAnimTransactionPending(false),
Marissa Wall06255332019-03-27 13:48:27 -0700283 mTraversalNeededMainThread(false),
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700284 mLayersRemoved(false),
Robert Carr1f0a16a2016-10-24 16:27:39 -0700285 mLayersAdded(false),
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800286 mBootTime(systemTime()),
Ana Krulec757f63a2019-01-25 10:46:18 -0800287 mPhaseOffsets{getFactory().createPhaseOffsets()},
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800288 mVisibleRegionsDirty(false),
Dan Stoza9e56aa02015-11-02 13:00:03 -0800289 mGeometryInvalid(false),
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800290 mAnimCompositionPending(false),
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800291 mBootStage(BootStage::BOOTLOADER),
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800292 mDebugRegion(0),
Mathias Agopian73d3ba92010-09-22 18:58:01 -0700293 mDebugDisableHWC(0),
Mathias Agopiana4583642011-08-23 18:03:18 -0700294 mDebugDisableTransformHint(0),
Peiyong Lin8f28a1d2019-02-07 17:25:12 -0800295 mDebugEnableProtectedContent(false),
Mathias Agopian9795c422009-08-26 16:36:26 -0700296 mDebugInTransaction(0),
297 mLastTransactionTime(0),
Dan Stozaee44edd2015-03-23 15:50:23 -0700298 mForceFullDamage(false),
Nataniel Borges2b796da2019-02-15 13:32:18 -0800299 mTracing(*this),
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800300 mTimeStats(factory.createTimeStats()),
David Sodman2b406362017-12-15 13:33:47 -0800301 mRefreshStartTime(0),
Dan Stozab90cf072015-03-05 11:05:59 -0800302 mHasPoweredOff(false),
Steven Thomas050b2c82017-03-06 11:45:16 -0800303 mNumLayers(0),
Steven Thomasb02664d2017-07-26 18:48:28 -0700304 mVrFlingerRequestsDisplay(false),
Lloyd Pique70d91362018-10-18 16:02:55 -0700305 mMainThreadId(std::this_thread::get_id()),
chaviw291d88a2019-02-14 10:33:58 -0800306 mCompositionEngine{getFactory().createCompositionEngine()} {
307 mSetInputWindowsListener = new SetInputWindowsListener(this);
308}
Lloyd Piqueac648ee2018-01-17 13:42:24 -0800309
Lloyd Pique90c115d2018-09-18 21:39:42 -0700310SurfaceFlinger::SurfaceFlinger(surfaceflinger::Factory& factory)
311 : SurfaceFlinger(factory, SkipInitialization) {
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800312 ALOGI("SurfaceFlinger is starting");
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800313
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900314 hasSyncFramework = running_without_sync_framework(true);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800315
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900316 dispSyncPresentTimeOffset = present_time_offset_from_vsync_ns(0);
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700317
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900318 useHwcForRgbToYuv = force_hwc_copy_for_virtual_displays(false);
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700319
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900320 maxVirtualDisplaySize = max_virtual_display_dimension(0);
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800321
Steven Thomas050b2c82017-03-06 11:45:16 -0800322 // Vr flinger is only enabled on Daydream ready devices.
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900323 useVrFlinger = use_vr_flinger(false);
Steven Thomas050b2c82017-03-06 11:45:16 -0800324
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900325 maxFrameBufferAcquiredBuffers = max_frame_buffer_acquired_buffers(2);
Fabien Sanglard1971b632017-03-10 14:50:03 -0800326
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900327 hasWideColorDisplay = has_wide_color_display(false);
Peiyong Lin0256f722018-08-31 15:45:10 -0700328
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900329 useColorManagement = use_color_management(false);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600330
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900331 mDefaultCompositionDataspace =
332 static_cast<ui::Dataspace>(default_composition_dataspace(Dataspace::V0_SRGB));
333 mWideColorGamutCompositionDataspace =
334 static_cast<ui::Dataspace>(wcg_composition_dataspace(Dataspace::V0_SRGB));
335 defaultCompositionDataspace = mDefaultCompositionDataspace;
336 wideColorGamutCompositionDataspace = mWideColorGamutCompositionDataspace;
337 defaultCompositionPixelFormat = static_cast<ui::PixelFormat>(
338 default_composition_pixel_format(ui::PixelFormat::RGBA_8888));
339 wideColorGamutCompositionPixelFormat =
340 static_cast<ui::PixelFormat>(wcg_composition_pixel_format(ui::PixelFormat::RGBA_8888));
Peiyong Linb3839ad2018-09-05 15:37:19 -0700341
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900342 useContextPriority = use_context_priority(true);
Iris Chang7501ed62018-04-30 14:45:42 +0800343
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900344 auto tmpPrimaryDisplayOrientation = primary_display_orientation(
345 SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_0);
346 switch (tmpPrimaryDisplayOrientation) {
347 case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_90:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700348 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientation90;
Iris Chang7501ed62018-04-30 14:45:42 +0800349 break;
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900350 case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_180:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700351 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientation180;
Iris Chang7501ed62018-04-30 14:45:42 +0800352 break;
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900353 case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_270:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700354 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientation270;
Iris Chang7501ed62018-04-30 14:45:42 +0800355 break;
356 default:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700357 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientationDefault;
Iris Chang7501ed62018-04-30 14:45:42 +0800358 break;
359 }
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700360 ALOGV("Primary Display Orientation is set to %2d.", SurfaceFlinger::primaryDisplayOrientation);
Iris Chang7501ed62018-04-30 14:45:42 +0800361
Sundong Ahn85131bd2019-02-18 15:51:53 +0900362 mInternalDisplayPrimaries = sysprop::getDisplayNativePrimaries();
Daniel Solomon42d04562019-01-20 21:03:19 -0800363
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800364 // debugging stuff...
365 char value[PROPERTY_VALUE_MAX];
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700366
Mathias Agopianb4b17302013-03-20 18:36:41 -0700367 property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");
Mathias Agopian50210b92013-03-21 21:13:21 -0700368 mGpuToCpuSupported = !atoi(value);
Mathias Agopianb4b17302013-03-20 18:36:41 -0700369
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800370 property_get("debug.sf.showupdates", value, "0");
371 mDebugRegion = atoi(value);
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700372
Mathias Agopianc1d359d2012-08-04 20:09:03 -0700373 ALOGI_IF(mDebugRegion, "showupdates enabled");
Orion Hodson34397da2019-02-04 09:36:10 +0000374
375 // DDMS debugging deprecated (b/120782499)
376 property_get("debug.sf.ddms", value, "0");
377 int debugDdms = atoi(value);
378 ALOGI_IF(debugDdms, "DDMS debugging not supported");
Dan Stozac5da2712016-07-20 15:38:12 -0700379
380 property_get("debug.sf.disable_backpressure", value, "0");
381 mPropagateBackpressure = !atoi(value);
382 ALOGI_IF(!mPropagateBackpressure, "Disabling backpressure propagation");
Dan Stoza8cf150a2016-08-02 10:27:31 -0700383
Fabien Sanglard642b23d2017-02-09 12:29:39 -0800384 property_get("debug.sf.enable_hwc_vds", value, "0");
385 mUseHwcVirtualDisplays = atoi(value);
Chia-I Wu11d10612018-06-21 15:41:13 +0800386 ALOGI_IF(mUseHwcVirtualDisplays, "Enabling HWC virtual displays");
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800387
Yiwei Zhangb770ed32018-12-17 17:44:28 -0800388 property_get("ro.sf.disable_triple_buffer", value, "0");
Fabien Sanglardc65dafa2017-02-07 14:06:39 -0800389 mLayerTripleBufferingDisabled = atoi(value);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800390 ALOGI_IF(mLayerTripleBufferingDisabled, "Disabling Triple Buffering");
Romain Guy3054f002017-06-05 18:38:53 -0700391
Yiwei Zhang243b3782018-05-15 17:40:04 -0700392 const size_t defaultListSize = MAX_LAYERS;
Dan Stoza0a0158c2018-03-16 13:38:54 -0700393 auto listSize = property_get_int32("debug.sf.max_igbp_list_size", int32_t(defaultListSize));
394 mMaxGraphicBufferProducerListSize = (listSize > 0) ? size_t(listSize) : defaultListSize;
395
Ana Krulece5a06e02019-03-06 17:09:03 -0800396 mUseSmart90ForVideo = use_smart_90_for_video(false);
Ana Krulecba13ab32019-02-20 14:14:12 -0800397 property_get("debug.sf.use_smart_90_for_video", value, "0");
Ana Krulece5a06e02019-03-06 17:09:03 -0800398
399 int int_value = atoi(value);
400 if (int_value) {
401 mUseSmart90ForVideo = true;
402 }
Ana Krulecba13ab32019-02-20 14:14:12 -0800403
Dan Stozaec460082018-12-17 15:35:09 -0800404 property_get("debug.sf.luma_sampling", value, "1");
405 mLumaSampling = atoi(value);
406
Ana Krulec757f63a2019-01-25 10:46:18 -0800407 const auto [early, gl, late] = mPhaseOffsets->getCurrentOffsets();
408 mVsyncModulator.setPhaseOffsets(early, gl, late);
Dan Stoza84d619e2018-03-28 17:07:36 -0700409
Romain Guy11d63f42017-07-20 12:47:14 -0700410 // We should be reading 'persist.sys.sf.color_saturation' here
411 // but since /data may be encrypted, we need to wait until after vold
412 // comes online to attempt to read the property. The property is
413 // instead read after the boot animation
Kalle Raitaa099a242017-01-11 11:17:29 -0800414
415 if (useTrebleTestingOverride()) {
416 // Without the override SurfaceFlinger cannot connect to HIDL
417 // services that are not listed in the manifests. Considered
418 // deriving the setting from the set service name, but it
419 // would be brittle if the name that's not 'default' is used
420 // for production purposes later on.
421 setenv("TREBLE_TESTING_OVERRIDE", "true", true);
422 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800423}
424
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800425void SurfaceFlinger::onFirstRef()
426{
Lloyd Pique3fcdef12018-01-22 17:14:00 -0800427 mEventQueue->init(this);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800428}
429
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800430SurfaceFlinger::~SurfaceFlinger()
431{
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800432}
433
Dan Stozac7014012014-02-14 15:03:43 -0800434void SurfaceFlinger::binderDied(const wp<IBinder>& /* who */)
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800435{
436 // the window manager died on us. prepare its eulogy.
437
Andy McFadden13a082e2012-08-24 10:16:42 -0700438 // restore initial conditions (default device unblank, etc)
439 initializeDisplays();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800440
441 // restart the boot-animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700442 startBootAnim();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800443}
444
Robert Carr1db73f62016-12-21 12:58:51 -0800445static sp<ISurfaceComposerClient> initClient(const sp<Client>& client) {
Mathias Agopian96f08192010-06-02 23:28:45 -0700446 status_t err = client->initCheck();
447 if (err == NO_ERROR) {
Robert Carr1db73f62016-12-21 12:58:51 -0800448 return client;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800449 }
Robert Carr1db73f62016-12-21 12:58:51 -0800450 return nullptr;
451}
452
453sp<ISurfaceComposerClient> SurfaceFlinger::createConnection() {
454 return initClient(new Client(this));
455}
456
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700457sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName,
458 bool secure)
Mathias Agopiane57f2922012-08-09 16:29:12 -0700459{
460 class DisplayToken : public BBinder {
461 sp<SurfaceFlinger> flinger;
462 virtual ~DisplayToken() {
463 // no more references, this display must be terminated
464 Mutex::Autolock _l(flinger->mStateLock);
465 flinger->mCurrentState.displays.removeItem(this);
466 flinger->setTransactionFlags(eDisplayTransactionNeeded);
467 }
468 public:
Chih-Hung Hsiehc4067912016-05-03 14:03:27 -0700469 explicit DisplayToken(const sp<SurfaceFlinger>& flinger)
Mathias Agopiane57f2922012-08-09 16:29:12 -0700470 : flinger(flinger) {
471 }
472 };
473
474 sp<BBinder> token = new DisplayToken(this);
475
476 Mutex::Autolock _l(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700477 // Display ID is assigned when virtual display is allocated by HWC.
478 DisplayDeviceState state;
479 state.isSecure = secure;
480 state.displayName = displayName;
481 mCurrentState.displays.add(token, state);
482 mInterceptor->saveDisplayCreation(state);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700483 return token;
484}
485
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700486void SurfaceFlinger::destroyDisplay(const sp<IBinder>& displayToken) {
Jesse Hall6c913be2013-08-08 12:15:49 -0700487 Mutex::Autolock _l(mStateLock);
488
Dominik Laskowski075d3172018-05-24 15:50:06 -0700489 ssize_t index = mCurrentState.displays.indexOfKey(displayToken);
490 if (index < 0) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700491 ALOGE("destroyDisplay: Invalid display token %p", displayToken.get());
Jesse Hall6c913be2013-08-08 12:15:49 -0700492 return;
493 }
494
Dominik Laskowski075d3172018-05-24 15:50:06 -0700495 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
496 if (!state.isVirtual()) {
Jesse Hall6c913be2013-08-08 12:15:49 -0700497 ALOGE("destroyDisplay called for non-virtual display");
498 return;
499 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700500 mInterceptor->saveDisplayDeletion(state.sequenceId);
501 mCurrentState.displays.removeItemsAt(index);
Jesse Hall6c913be2013-08-08 12:15:49 -0700502 setTransactionFlags(eDisplayTransactionNeeded);
503}
504
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800505std::vector<PhysicalDisplayId> SurfaceFlinger::getPhysicalDisplayIds() const {
506 Mutex::Autolock lock(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700507
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800508 const auto internalDisplayId = getInternalDisplayIdLocked();
509 if (!internalDisplayId) {
510 return {};
Dominik Laskowski075d3172018-05-24 15:50:06 -0700511 }
512
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800513 std::vector<PhysicalDisplayId> displayIds;
514 displayIds.reserve(mPhysicalDisplayTokens.size());
515 displayIds.push_back(internalDisplayId->value);
516
517 for (const auto& [id, token] : mPhysicalDisplayTokens) {
518 if (id != *internalDisplayId) {
519 displayIds.push_back(id.value);
520 }
Mathias Agopiane57f2922012-08-09 16:29:12 -0700521 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700522
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800523 return displayIds;
524}
525
526sp<IBinder> SurfaceFlinger::getPhysicalDisplayToken(PhysicalDisplayId displayId) const {
527 Mutex::Autolock lock(mStateLock);
528 return getPhysicalDisplayTokenLocked(DisplayId{displayId});
Mathias Agopiane57f2922012-08-09 16:29:12 -0700529}
530
Ady Abraham37965d42018-11-01 13:43:32 -0700531status_t SurfaceFlinger::getColorManagement(bool* outGetColorManagement) const {
532 if (!outGetColorManagement) {
533 return BAD_VALUE;
534 }
535 *outGetColorManagement = useColorManagement;
536 return NO_ERROR;
Ady Abraham2a6ab2a2018-10-26 14:25:30 -0700537}
538
Lloyd Pique441d5042018-10-18 16:49:51 -0700539HWComposer& SurfaceFlinger::getHwComposer() const {
540 return mCompositionEngine->getHwComposer();
541}
542
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700543renderengine::RenderEngine& SurfaceFlinger::getRenderEngine() const {
544 return mCompositionEngine->getRenderEngine();
545}
546
Lloyd Pique70d91362018-10-18 16:02:55 -0700547compositionengine::CompositionEngine& SurfaceFlinger::getCompositionEngine() const {
548 return *mCompositionEngine.get();
549}
550
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800551void SurfaceFlinger::bootFinished()
552{
Wei Wangf9b05ee2017-07-19 20:59:39 -0700553 if (mStartPropertySetThread->join() != NO_ERROR) {
554 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800555 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800556 const nsecs_t now = systemTime();
557 const nsecs_t duration = now - mBootTime;
Steve Blocka19954a2012-01-04 20:05:49 +0000558 ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700559
560 // wait patiently for the window manager death
561 const String16 name("window");
562 sp<IBinder> window(defaultServiceManager()->getService(name));
563 if (window != 0) {
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700564 window->linkToDeath(static_cast<IBinder::DeathRecipient*>(this));
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700565 }
Robert Carr720e5062018-07-30 17:45:14 -0700566 sp<IBinder> input(defaultServiceManager()->getService(
567 String16("inputflinger")));
568 if (input == nullptr) {
569 ALOGE("Failed to link to input service");
570 } else {
571 mInputFlinger = interface_cast<IInputFlinger>(input);
572 }
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700573
Steven Thomas050b2c82017-03-06 11:45:16 -0800574 if (mVrFlinger) {
575 mVrFlinger->OnBootFinished();
576 }
577
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700578 // stop boot animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700579 // formerly we would just kill the process, but we now ask it to exit so it
580 // can choose where to stop the animation.
581 property_set("service.bootanim.exit", "1");
Yusuke Sato0a688f52015-07-30 23:05:39 -0700582
583 const int LOGTAG_SF_STOP_BOOTANIM = 60110;
584 LOG_EVENT_LONG(LOGTAG_SF_STOP_BOOTANIM,
585 ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
Romain Guy11d63f42017-07-20 12:47:14 -0700586
Ana Krulecbd6654b2019-02-15 15:18:15 -0800587 postMessageAsync(new LambdaMessage([this]() NO_THREAD_SAFETY_ANALYSIS {
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800588 readPersistentProperties();
589 mBootStage = BootStage::FINISHED;
Ana Krulecbd6654b2019-02-15 15:18:15 -0800590
Ady Abraham97d04232019-03-05 19:48:12 -0800591 // set the refresh rate according to the policy
592 const auto displayId = getInternalDisplayIdLocked();
593 LOG_ALWAYS_FATAL_IF(!displayId);
Ana Krulecbd6654b2019-02-15 15:18:15 -0800594
Alec Mouri0a1cc962019-03-14 12:33:02 -0700595 const auto& performanceRefreshRate =
Ady Abraham97d04232019-03-05 19:48:12 -0800596 mRefreshRateConfigs[*displayId]->getRefreshRate(RefreshRateType::PERFORMANCE);
597
Alec Mouri0a1cc962019-03-14 12:33:02 -0700598 if (performanceRefreshRate &&
599 isConfigAllowed(*displayId, performanceRefreshRate->configId)) {
Ana Krulec8d3e4f32019-03-05 10:40:33 -0800600 setRefreshRateTo(RefreshRateType::PERFORMANCE, Scheduler::ConfigEvent::None);
Ana Krulecbd6654b2019-02-15 15:18:15 -0800601 } else {
Ana Krulec8d3e4f32019-03-05 10:40:33 -0800602 setRefreshRateTo(RefreshRateType::DEFAULT, Scheduler::ConfigEvent::None);
Ana Krulecbd6654b2019-02-15 15:18:15 -0800603 }
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800604 }));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800605}
606
Dan Stoza436ccf32018-06-21 12:10:12 -0700607uint32_t SurfaceFlinger::getNewTexture() {
608 {
609 std::lock_guard lock(mTexturePoolMutex);
610 if (!mTexturePool.empty()) {
611 uint32_t name = mTexturePool.back();
612 mTexturePool.pop_back();
613 ATRACE_INT("TexturePoolSize", mTexturePool.size());
614 return name;
615 }
616
617 // The pool was too small, so increase it for the future
618 ++mTexturePoolSize;
619 }
620
621 // The pool was empty, so we need to get a new texture name directly using a
622 // blocking call to the main thread
623 uint32_t name = 0;
624 postMessageSync(new LambdaMessage([&]() { getRenderEngine().genTextures(1, &name); }));
625 return name;
626}
627
Mathias Agopian3f844832013-08-07 21:24:32 -0700628void SurfaceFlinger::deleteTextureAsync(uint32_t texture) {
Dominik Laskowski8c001672018-05-30 16:52:06 -0700629 postMessageAsync(new LambdaMessage([=] { getRenderEngine().deleteTextures(1, &texture); }));
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700630}
631
Wei Wangf9b05ee2017-07-19 20:59:39 -0700632// Do not call property_set on main thread which will be blocked by init
633// Use StartPropertySetThread instead.
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700634void SurfaceFlinger::init() {
Mathias Agopiana4912602012-07-12 14:25:33 -0700635 ALOGI( "SurfaceFlinger's main thread ready to run. "
636 "Initializing graphics H/W...");
637
Ana Krulec757f63a2019-01-25 10:46:18 -0800638 ALOGI("Phase offset NS: %" PRId64 "", mPhaseOffsets->getCurrentAppOffset());
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900639
Steven Thomasb02664d2017-07-26 18:48:28 -0700640 Mutex::Autolock _l(mStateLock);
Steven Thomasb02664d2017-07-26 18:48:28 -0700641 // start the EventThread
Ana Krulecc2870422019-01-29 19:00:58 -0800642 mScheduler =
643 getFactory().createScheduler([this](bool enabled) { setPrimaryVsyncEnabled(enabled); });
644 auto resyncCallback =
645 mScheduler->makeResyncCallback(std::bind(&SurfaceFlinger::getVsyncPeriod, this));
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800646
Ana Krulecc2870422019-01-29 19:00:58 -0800647 mAppConnectionHandle =
648 mScheduler->createConnection("app", mPhaseOffsets->getCurrentAppOffset(),
649 resyncCallback,
650 impl::EventThread::InterceptVSyncsCallback());
651 mSfConnectionHandle = mScheduler->createConnection("sf", mPhaseOffsets->getCurrentSfOffset(),
652 resyncCallback, [this](nsecs_t timestamp) {
653 mInterceptor->saveVSyncEvent(timestamp);
654 });
655
656 mEventQueue->setEventConnection(mScheduler->getEventConnection(mSfConnectionHandle));
657 mVsyncModulator.setSchedulerAndHandles(mScheduler.get(), mAppConnectionHandle.get(),
658 mSfConnectionHandle.get());
659
Kevin DuBois413287f2019-02-25 08:46:47 -0800660 mRegionSamplingThread =
661 new RegionSamplingThread(*this, *mScheduler,
662 RegionSamplingThread::EnvironmentTimingTunables());
663
Steven Thomasb02664d2017-07-26 18:48:28 -0700664 // Get a RenderEngine for the given display / config (can't fail)
Peiyong Lin13effd12018-07-24 17:01:47 -0700665 int32_t renderEngineFeature = 0;
Peiyong Lin833074a2018-08-28 11:53:54 -0700666 renderEngineFeature |= (useColorManagement ?
667 renderengine::RenderEngine::USE_COLOR_MANAGEMENT : 0);
Peiyong Linb3839ad2018-09-05 15:37:19 -0700668 renderEngineFeature |= (useContextPriority ?
669 renderengine::RenderEngine::USE_HIGH_PRIORITY_CONTEXT : 0);
Peiyong Lin6a043d52019-04-01 17:18:21 -0700670 renderEngineFeature |=
671 (enable_protected_contents(false) ? renderengine::RenderEngine::ENABLE_PROTECTED_CONTEXT
672 : 0);
Peiyong Lin0256f722018-08-31 15:45:10 -0700673
674 // TODO(b/77156734): We need to stop casting and use HAL types when possible.
Alec Mourida4cf3b2019-02-12 15:33:01 -0800675 // Sending maxFrameBufferAcquiredBuffers as the cache size is tightly tuned to single-display.
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700676 mCompositionEngine->setRenderEngine(
Peiyong Linc6780972018-10-28 15:24:08 -0700677 renderengine::RenderEngine::create(static_cast<int32_t>(defaultCompositionPixelFormat),
Alec Mourida4cf3b2019-02-12 15:33:01 -0800678 renderEngineFeature, maxFrameBufferAcquiredBuffers));
Steven Thomasb02664d2017-07-26 18:48:28 -0700679
680 LOG_ALWAYS_FATAL_IF(mVrFlingerRequestsDisplay,
681 "Starting with vr flinger active is not currently supported.");
Lloyd Pique441d5042018-10-18 16:49:51 -0700682 mCompositionEngine->setHwComposer(getFactory().createHWComposer(getBE().mHwcServiceName));
683 mCompositionEngine->getHwComposer().registerCallback(this, getBE().mComposerSequenceId);
Lloyd Piqueba04e622017-12-14 17:11:26 -0800684 // Process any initial hotplug and resulting display changes.
685 processDisplayHotplugEventsLocked();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700686 const auto display = getDefaultDisplayDeviceLocked();
687 LOG_ALWAYS_FATAL_IF(!display, "Missing internal display after registering composer callback.");
Dominik Laskowski075d3172018-05-24 15:50:06 -0700688 LOG_ALWAYS_FATAL_IF(!getHwComposer().isConnected(*display->getId()),
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700689 "Internal display is disconnected.");
Jesse Hall692c7232012-11-08 15:41:56 -0800690
Steven Thomas050b2c82017-03-06 11:45:16 -0800691 if (useVrFlinger) {
Dominik Laskowski8c001672018-05-30 16:52:06 -0700692 auto vrFlingerRequestDisplayCallback = [this](bool requestDisplay) {
Steven Thomasbe6cbae2017-09-28 15:30:23 -0700693 // This callback is called from the vr flinger dispatch thread. We
694 // need to call signalTransaction(), which requires holding
695 // mStateLock when we're not on the main thread. Acquiring
696 // mStateLock from the vr flinger dispatch thread might trigger a
697 // deadlock in surface flinger (see b/66916578), so post a message
698 // to be handled on the main thread instead.
Dominik Laskowski8c001672018-05-30 16:52:06 -0700699 postMessageAsync(new LambdaMessage([=] {
Steven Thomasbe6cbae2017-09-28 15:30:23 -0700700 ALOGI("VR request display mode: requestDisplay=%d", requestDisplay);
701 mVrFlingerRequestsDisplay = requestDisplay;
702 signalTransaction();
Dominik Laskowski8c001672018-05-30 16:52:06 -0700703 }));
Steven Thomas050b2c82017-03-06 11:45:16 -0800704 };
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700705 mVrFlinger = dvr::VrFlinger::Create(getHwComposer().getComposer(),
706 getHwComposer()
Dominik Laskowski075d3172018-05-24 15:50:06 -0700707 .fromPhysicalDisplayId(*display->getId())
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700708 .value_or(0),
709 vrFlingerRequestDisplayCallback);
Steven Thomas050b2c82017-03-06 11:45:16 -0800710 if (!mVrFlinger) {
711 ALOGE("Failed to start vrflinger");
712 }
713 }
714
Mathias Agopian92a979a2012-08-02 18:32:23 -0700715 // initialize our drawing state
716 mDrawingState = mCurrentState;
Mathias Agopian86303202012-07-24 22:46:10 -0700717
Andy McFadden13a082e2012-08-24 10:16:42 -0700718 // set initial conditions (e.g. unblank default device)
719 initializeDisplays();
720
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700721 getRenderEngine().primeCache();
Dan Stoza4e637772016-07-28 13:31:51 -0700722
Wei Wangf9b05ee2017-07-19 20:59:39 -0700723 // Inform native graphics APIs whether the present timestamp is supported:
Lloyd Pique90c115d2018-09-18 21:39:42 -0700724
725 const bool presentFenceReliable =
726 !getHwComposer().hasCapability(HWC2::Capability::PresentFenceIsNotReliable);
727 mStartPropertySetThread = getFactory().createStartPropertySetThread(presentFenceReliable);
Wei Wangf9b05ee2017-07-19 20:59:39 -0700728
729 if (mStartPropertySetThread->Start() != NO_ERROR) {
730 ALOGE("Run StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800731 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800732
Ady Abraham97d04232019-03-05 19:48:12 -0800733 if (mScheduler->isIdleTimerEnabled()) {
Ana Krulec8d3e4f32019-03-05 10:40:33 -0800734 mScheduler->setChangeRefreshRateCallback(
735 [this](RefreshRateType type, Scheduler::ConfigEvent event) {
736 Mutex::Autolock lock(mStateLock);
737 setRefreshRateTo(type, event);
738 });
Kevin DuBois36233132019-02-19 14:08:55 -0800739 }
Ady Abraham1902d072019-03-01 17:18:59 -0800740 mRefreshRateConfigs[*display->getId()] = std::make_shared<scheduler::RefreshRateConfigs>(
741 getHwComposer().getConfigs(*display->getId()));
742 mRefreshRateStats =
743 std::make_unique<scheduler::RefreshRateStats>(mRefreshRateConfigs[*display->getId()],
744 mTimeStats);
Alec Mouri62c8bd12019-03-22 15:55:23 -0700745 mRefreshRateStats->setConfigMode(getHwComposer().getActiveConfigIndex(*display->getId()));
Ana Krulec7d1d6832018-12-27 11:10:09 -0800746
Dan Stoza9e56aa02015-11-02 13:00:03 -0800747 ALOGV("Done initializing");
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700748}
749
Romain Guy11d63f42017-07-20 12:47:14 -0700750void SurfaceFlinger::readPersistentProperties() {
Chia-I Wu28f320b2018-05-03 11:02:56 -0700751 Mutex::Autolock _l(mStateLock);
752
Romain Guy11d63f42017-07-20 12:47:14 -0700753 char value[PROPERTY_VALUE_MAX];
754
755 property_get("persist.sys.sf.color_saturation", value, "1.0");
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800756 mGlobalSaturationFactor = atof(value);
Chia-I Wu28f320b2018-05-03 11:02:56 -0700757 updateColorMatrixLocked();
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800758 ALOGV("Saturation is set to %.2f", mGlobalSaturationFactor);
Romain Guy54f154a2017-10-24 21:40:32 +0100759
760 property_get("persist.sys.sf.native_mode", value, "0");
Chia-I Wu0d711262018-05-21 15:19:35 -0700761 mDisplayColorSetting = static_cast<DisplayColorSetting>(atoi(value));
Peiyong Lina3ea5592019-02-10 14:45:00 -0800762
763 property_get("persist.sys.sf.color_mode", value, "0");
764 mForceColorMode = static_cast<ColorMode>(atoi(value));
Romain Guy11d63f42017-07-20 12:47:14 -0700765}
766
Mathias Agopiana67e4182012-06-19 17:26:12 -0700767void SurfaceFlinger::startBootAnim() {
Wei Wangb254fa32017-01-31 17:43:23 -0800768 // Start boot animation service by setting a property mailbox
769 // if property setting thread is already running, Start() will be just a NOP
Wei Wangf9b05ee2017-07-19 20:59:39 -0700770 mStartPropertySetThread->Start();
Wei Wangb254fa32017-01-31 17:43:23 -0800771 // Wait until property was set
Wei Wangf9b05ee2017-07-19 20:59:39 -0700772 if (mStartPropertySetThread->join() != NO_ERROR) {
773 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800774 }
Mathias Agopiana67e4182012-06-19 17:26:12 -0700775}
776
Mathias Agopian875d8e12013-06-07 15:35:48 -0700777size_t SurfaceFlinger::getMaxTextureSize() const {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700778 return getRenderEngine().getMaxTextureSize();
Mathias Agopiana4912602012-07-12 14:25:33 -0700779}
780
Mathias Agopian875d8e12013-06-07 15:35:48 -0700781size_t SurfaceFlinger::getMaxViewportDims() const {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700782 return getRenderEngine().getMaxViewportDims();
Mathias Agopiana4912602012-07-12 14:25:33 -0700783}
784
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800785// ----------------------------------------------------------------------------
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800786
Jamie Gennis582270d2011-08-17 18:19:00 -0700787bool SurfaceFlinger::authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800788 const sp<IGraphicBufferProducer>& bufferProducer) const {
Jamie Gennis134f0422011-03-08 12:18:54 -0800789 Mutex::Autolock _l(mStateLock);
Robert Carr0d480722017-01-10 16:42:54 -0800790 return authenticateSurfaceTextureLocked(bufferProducer);
791}
792
793bool SurfaceFlinger::authenticateSurfaceTextureLocked(
794 const sp<IGraphicBufferProducer>& bufferProducer) const {
Marco Nelissen097ca272014-11-14 08:01:01 -0800795 sp<IBinder> surfaceTextureBinder(IInterface::asBinder(bufferProducer));
Dan Stoza101d8dc2018-02-27 15:42:25 -0800796 return mGraphicBufferProducerList.count(surfaceTextureBinder.get()) > 0;
Jamie Gennis134f0422011-03-08 12:18:54 -0800797}
798
Brian Anderson6b376712017-04-04 10:51:39 -0700799status_t SurfaceFlinger::getSupportedFrameTimestamps(
800 std::vector<FrameEvent>* outSupported) const {
801 *outSupported = {
802 FrameEvent::REQUESTED_PRESENT,
803 FrameEvent::ACQUIRE,
804 FrameEvent::LATCH,
805 FrameEvent::FIRST_REFRESH_START,
806 FrameEvent::LAST_REFRESH_START,
807 FrameEvent::GPU_COMPOSITION_DONE,
808 FrameEvent::DEQUEUE_READY,
809 FrameEvent::RELEASE,
810 };
Steven Thomas6d8110b2017-08-31 18:24:21 -0700811 ConditionalLock _l(mStateLock,
812 std::this_thread::get_id() != mMainThreadId);
Brian Anderson6b376712017-04-04 10:51:39 -0700813 if (!getHwComposer().hasCapability(
814 HWC2::Capability::PresentFenceIsNotReliable)) {
815 outSupported->push_back(FrameEvent::DISPLAY_PRESENT);
816 }
817 return NO_ERROR;
818}
819
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800820status_t SurfaceFlinger::getDisplayConfigsLocked(const sp<IBinder>& displayToken,
821 Vector<DisplayInfo>* configs) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700822 if (!displayToken || !configs) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700823 return BAD_VALUE;
824 }
825
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800826 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700827 if (!displayId) {
828 return NAME_NOT_FOUND;
Mathias Agopianc666cae2012-07-25 18:56:13 -0700829 }
Mathias Agopian8b736f12012-08-13 17:54:26 -0700830
Mathias Agopian8b736f12012-08-13 17:54:26 -0700831 // TODO: Not sure if display density should handled by SF any longer
832 class Density {
Hernan Liatis57568932018-08-16 17:07:08 -0700833 static float getDensityFromProperty(char const* propName) {
Mathias Agopian8b736f12012-08-13 17:54:26 -0700834 char property[PROPERTY_VALUE_MAX];
Hernan Liatis57568932018-08-16 17:07:08 -0700835 float density = 0.0f;
Peiyong Lin566a3b42018-01-09 18:22:43 -0800836 if (property_get(propName, property, nullptr) > 0) {
Hernan Liatis57568932018-08-16 17:07:08 -0700837 density = strtof(property, nullptr);
Mathias Agopian8b736f12012-08-13 17:54:26 -0700838 }
839 return density;
840 }
841 public:
Hernan Liatis57568932018-08-16 17:07:08 -0700842 static float getEmuDensity() {
Mathias Agopian8b736f12012-08-13 17:54:26 -0700843 return getDensityFromProperty("qemu.sf.lcd_density"); }
Hernan Liatis57568932018-08-16 17:07:08 -0700844 static float getBuildDensity() {
Mathias Agopian8b736f12012-08-13 17:54:26 -0700845 return getDensityFromProperty("ro.sf.lcd_density"); }
846 };
Mathias Agopian1604f772012-09-18 21:54:42 -0700847
Dan Stoza7f7da322014-05-02 15:26:25 -0700848 configs->clear();
Mathias Agopian1604f772012-09-18 21:54:42 -0700849
Dominik Laskowski075d3172018-05-24 15:50:06 -0700850 for (const auto& hwConfig : getHwComposer().getConfigs(*displayId)) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700851 DisplayInfo info = DisplayInfo();
852
Dan Stoza9e56aa02015-11-02 13:00:03 -0800853 float xdpi = hwConfig->getDpiX();
854 float ydpi = hwConfig->getDpiY();
Dan Stoza7f7da322014-05-02 15:26:25 -0700855
Yiwei Zhang27de5df2018-08-23 17:04:51 -0700856 info.w = hwConfig->getWidth();
857 info.h = hwConfig->getHeight();
858 // Default display viewport to display width and height
859 info.viewportW = info.w;
860 info.viewportH = info.h;
861
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800862 if (displayId == getInternalDisplayIdLocked()) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700863 // The density of the device is provided by a build property
864 float density = Density::getBuildDensity() / 160.0f;
865 if (density == 0) {
866 // the build doesn't provide a density -- this is wrong!
867 // use xdpi instead
868 ALOGE("ro.sf.lcd_density must be defined as a build property");
869 density = xdpi / 160.0f;
870 }
871 if (Density::getEmuDensity()) {
872 // if "qemu.sf.lcd_density" is specified, it overrides everything
873 xdpi = ydpi = density = Density::getEmuDensity();
874 density /= 160.0f;
875 }
876 info.density = density;
877
878 // TODO: this needs to go away (currently needed only by webkit)
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700879 const auto display = getDefaultDisplayDeviceLocked();
880 info.orientation = display ? display->getOrientation() : 0;
Yiwei Zhang27de5df2018-08-23 17:04:51 -0700881
882 // This is for screenrecord
883 const Rect viewport = display->getViewport();
884 if (viewport.isValid()) {
885 info.viewportW = uint32_t(viewport.getWidth());
886 info.viewportH = uint32_t(viewport.getHeight());
887 }
Dan Stoza7f7da322014-05-02 15:26:25 -0700888 } else {
889 // TODO: where should this value come from?
890 static const int TV_DENSITY = 213;
891 info.density = TV_DENSITY / 160.0f;
892 info.orientation = 0;
893 }
894
Dan Stoza7f7da322014-05-02 15:26:25 -0700895 info.xdpi = xdpi;
896 info.ydpi = ydpi;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800897 info.fps = 1e9 / hwConfig->getVsyncPeriod();
Ana Krulec757f63a2019-01-25 10:46:18 -0800898 info.appVsyncOffset = mPhaseOffsets->getCurrentAppOffset();
Dan Stoza9e56aa02015-11-02 13:00:03 -0800899
Andy McFadden91b2ca82014-06-13 14:04:23 -0700900 // This is how far in advance a buffer must be queued for
901 // presentation at a given time. If you want a buffer to appear
902 // on the screen at time N, you must submit the buffer before
903 // (N - presentationDeadline).
904 //
905 // Normally it's one full refresh period (to give SF a chance to
906 // latch the buffer), but this can be reduced by configuring a
907 // DispSync offset. Any additional delays introduced by the hardware
908 // composer or panel must be accounted for here.
909 //
910 // We add an additional 1ms to allow for processing time and
911 // differences between the ideal and actual refresh rate.
Ana Krulec757f63a2019-01-25 10:46:18 -0800912 info.presentationDeadline =
913 hwConfig->getVsyncPeriod() - mPhaseOffsets->getCurrentSfOffset() + 1000000;
Dan Stoza7f7da322014-05-02 15:26:25 -0700914
915 // All non-virtual displays are currently considered secure.
916 info.secure = true;
917
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800918 if (displayId == getInternalDisplayIdLocked() &&
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700919 primaryDisplayOrientation & DisplayState::eOrientationSwapMask) {
Iris Chang7501ed62018-04-30 14:45:42 +0800920 std::swap(info.w, info.h);
921 }
922
Michael Wright28f24d02016-07-12 13:30:53 -0700923 configs->push_back(info);
Mathias Agopian8b736f12012-08-13 17:54:26 -0700924 }
925
Dan Stoza7f7da322014-05-02 15:26:25 -0700926 return NO_ERROR;
927}
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700928
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700929status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>&, DisplayStatInfo* stats) {
930 if (!stats) {
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700931 return BAD_VALUE;
932 }
933
Ana Krulecc2870422019-01-29 19:00:58 -0800934 mScheduler->getDisplayStatInfo(stats);
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700935 return NO_ERROR;
936}
937
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700938int SurfaceFlinger::getActiveConfig(const sp<IBinder>& displayToken) {
939 const auto display = getDisplayDevice(displayToken);
940 if (!display) {
941 ALOGE("getActiveConfig: Invalid display token %p", displayToken.get());
Jinguang Dong9f8b9ae2016-11-29 13:55:57 +0800942 return BAD_VALUE;
943 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700944
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700945 return display->getActiveConfig();
Dan Stoza7f7da322014-05-02 15:26:25 -0700946}
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700947
Ady Abraham03b02dd2019-03-21 15:40:11 -0700948void SurfaceFlinger::setDesiredActiveConfig(const ActiveConfigInfo& info) {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800949 ATRACE_CALL();
Ana Krulec7d1d6832018-12-27 11:10:09 -0800950
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800951 // Lock is acquired by setRefreshRateTo.
Ady Abraham03b02dd2019-03-21 15:40:11 -0700952 const auto display = getDisplayDeviceLocked(info.displayToken);
Ana Krulec7d1d6832018-12-27 11:10:09 -0800953 if (!display) {
Ady Abraham03b02dd2019-03-21 15:40:11 -0700954 ALOGE("Attempt to set active config %d for invalid display token %p", info.configId,
955 info.displayToken.get());
Ana Krulec7d1d6832018-12-27 11:10:09 -0800956 return;
957 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700958 if (display->isVirtual()) {
Ady Abraham03b02dd2019-03-21 15:40:11 -0700959 ALOGW("Attempt to set active config %d for virtual display", info.configId);
Ana Krulec7d1d6832018-12-27 11:10:09 -0800960 return;
961 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700962
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800963 // Don't check against the current mode yet. Worst case we set the desired
Ady Abraham9360a222019-02-27 17:05:30 -0800964 // config twice. However event generation config might have changed so we need to update it
965 // accordingly
Ady Abrahamb838aed2019-02-12 15:30:16 -0800966 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Ady Abraham03b02dd2019-03-21 15:40:11 -0700967 const Scheduler::ConfigEvent prevConfig = mDesiredActiveConfig.event;
968 mDesiredActiveConfig = info;
969 mDesiredActiveConfig.event = mDesiredActiveConfig.event | prevConfig;
Ady Abrahamb838aed2019-02-12 15:30:16 -0800970
971 if (!mDesiredActiveConfigChanged) {
972 // This is the first time we set the desired
973 mScheduler->pauseVsyncCallback(mAppConnectionHandle, true);
974
975 // This will trigger HWC refresh without resetting the idle timer.
976 repaintEverythingForHWC();
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800977 }
Ady Abrahamb838aed2019-02-12 15:30:16 -0800978 mDesiredActiveConfigChanged = true;
979 ATRACE_INT("DesiredActiveConfigChanged", mDesiredActiveConfigChanged);
Ady Abraham03b02dd2019-03-21 15:40:11 -0700980
981 if (mRefreshRateOverlay) {
982 mRefreshRateOverlay->changeRefreshRate(mDesiredActiveConfig.type);
983 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800984}
985
986status_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& displayToken, int mode) {
987 ATRACE_CALL();
Ady Abraham838de062019-02-04 10:24:03 -0800988
989 std::vector<int32_t> allowedConfig;
990 allowedConfig.push_back(mode);
991
992 return setAllowedDisplayConfigs(displayToken, allowedConfig);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800993}
994
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800995void SurfaceFlinger::setActiveConfigInternal() {
996 ATRACE_CALL();
997
998 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Ana Krulecc2870422019-01-29 19:00:58 -0800999 mRefreshRateStats->setConfigMode(mUpcomingActiveConfig.configId);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001000
1001 const auto display = getDisplayDeviceLocked(mUpcomingActiveConfig.displayToken);
1002 display->setActiveConfig(mUpcomingActiveConfig.configId);
1003
Ana Krulecc2870422019-01-29 19:00:58 -08001004 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
Alec Mouri1c9e82b2019-03-07 12:24:05 -08001005 const auto [early, gl, late] = mPhaseOffsets->getCurrentOffsets();
1006 mVsyncModulator.setPhaseOffsets(early, gl, late);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001007 ATRACE_INT("ActiveConfigMode", mUpcomingActiveConfig.configId);
Ana Krulec8d3e4f32019-03-05 10:40:33 -08001008 if (mUpcomingActiveConfig.event != Scheduler::ConfigEvent::None) {
Ady Abraham447052e2019-02-13 16:07:27 -08001009 mScheduler->onConfigChanged(mAppConnectionHandle, display->getId()->value,
1010 mUpcomingActiveConfig.configId);
1011 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001012}
1013
Ady Abrahamb838aed2019-02-12 15:30:16 -08001014bool SurfaceFlinger::performSetActiveConfig() NO_THREAD_SAFETY_ANALYSIS {
Alec Mourife3dc942019-02-12 14:19:18 -08001015 ATRACE_CALL();
Ady Abrahamb838aed2019-02-12 15:30:16 -08001016 if (mCheckPendingFence) {
1017 if (mPreviousPresentFence != Fence::NO_FENCE &&
1018 (mPreviousPresentFence->getStatus() == Fence::Status::Unsignaled)) {
1019 // fence has not signaled yet. wait for the next invalidate
1020 repaintEverythingForHWC();
1021 return true;
1022 }
1023
1024 // We received the present fence from the HWC, so we assume it successfully updated
1025 // the config, hence we update SF.
1026 mCheckPendingFence = false;
1027 setActiveConfigInternal();
1028 }
1029
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001030 // Store the local variable to release the lock.
1031 ActiveConfigInfo desiredActiveConfig;
1032 {
1033 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Ady Abrahamb838aed2019-02-12 15:30:16 -08001034 if (!mDesiredActiveConfigChanged) {
1035 return false;
1036 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001037 desiredActiveConfig = mDesiredActiveConfig;
1038 }
1039
1040 const auto display = getDisplayDevice(desiredActiveConfig.displayToken);
Ady Abrahamb838aed2019-02-12 15:30:16 -08001041 if (!display || display->getActiveConfig() == desiredActiveConfig.configId) {
1042 // display is not valid or we are already in the requested mode
1043 // on both cases there is nothing left to do
1044 std::lock_guard<std::mutex> lock(mActiveConfigLock);
1045 mScheduler->pauseVsyncCallback(mAppConnectionHandle, false);
Ady Abrahamde3b67b2019-03-25 16:38:10 -07001046 mDesiredActiveConfig.event = Scheduler::ConfigEvent::None;
Ady Abrahamb838aed2019-02-12 15:30:16 -08001047 mDesiredActiveConfigChanged = false;
1048 ATRACE_INT("DesiredActiveConfigChanged", mDesiredActiveConfigChanged);
1049 return false;
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001050 }
Ady Abrahamb838aed2019-02-12 15:30:16 -08001051
Ady Abraham838de062019-02-04 10:24:03 -08001052 // Desired active config was set, it is different than the config currently in use, however
1053 // allowed configs might have change by the time we process the refresh.
1054 // Make sure the desired config is still allowed
1055 if (!isConfigAllowed(*display->getId(), desiredActiveConfig.configId)) {
1056 std::lock_guard<std::mutex> lock(mActiveConfigLock);
1057 mDesiredActiveConfig.configId = display->getActiveConfig();
1058 return false;
1059 }
Ady Abrahamb838aed2019-02-12 15:30:16 -08001060 mUpcomingActiveConfig = desiredActiveConfig;
1061 const auto displayId = display->getId();
1062 LOG_ALWAYS_FATAL_IF(!displayId);
1063
1064 ATRACE_INT("ActiveConfigModeHWC", mUpcomingActiveConfig.configId);
1065 getHwComposer().setActiveConfig(*displayId, mUpcomingActiveConfig.configId);
1066
1067 // we need to submit an empty frame to HWC to start the process
Ady Abrahamb838aed2019-02-12 15:30:16 -08001068 mCheckPendingFence = true;
1069
1070 return false;
Mathias Agopianc666cae2012-07-25 18:56:13 -07001071}
Dominik Laskowski075d3172018-05-24 15:50:06 -07001072
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001073status_t SurfaceFlinger::getDisplayColorModes(const sp<IBinder>& displayToken,
1074 Vector<ColorMode>* outColorModes) {
1075 if (!displayToken || !outColorModes) {
Michael Wright28f24d02016-07-12 13:30:53 -07001076 return BAD_VALUE;
1077 }
1078
Peiyong Lina52f0292018-03-14 17:26:31 -07001079 std::vector<ColorMode> modes;
Steven Thomas6d8110b2017-08-31 18:24:21 -07001080 {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001081 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
1082
1083 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1084 if (!displayId) {
1085 return NAME_NOT_FOUND;
1086 }
1087
Dominik Laskowski075d3172018-05-24 15:50:06 -07001088 modes = getHwComposer().getColorModes(*displayId);
Steven Thomas6d8110b2017-08-31 18:24:21 -07001089 }
Michael Wright28f24d02016-07-12 13:30:53 -07001090 outColorModes->clear();
1091 std::copy(modes.cbegin(), modes.cend(), std::back_inserter(*outColorModes));
1092
1093 return NO_ERROR;
1094}
1095
Daniel Solomon42d04562019-01-20 21:03:19 -08001096status_t SurfaceFlinger::getDisplayNativePrimaries(const sp<IBinder>& displayToken,
1097 ui::DisplayPrimaries &primaries) {
1098 if (!displayToken) {
1099 return BAD_VALUE;
1100 }
1101
1102 // Currently we only support this API for a single internal display.
1103 if (getInternalDisplayToken() != displayToken) {
1104 return BAD_VALUE;
1105 }
1106
1107 memcpy(&primaries, &mInternalDisplayPrimaries, sizeof(ui::DisplayPrimaries));
1108 return NO_ERROR;
1109}
1110
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001111ColorMode SurfaceFlinger::getActiveColorMode(const sp<IBinder>& displayToken) {
1112 if (const auto display = getDisplayDevice(displayToken)) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07001113 return display->getCompositionDisplay()->getState().colorMode;
Michael Wright28f24d02016-07-12 13:30:53 -07001114 }
Peiyong Lina52f0292018-03-14 17:26:31 -07001115 return static_cast<ColorMode>(BAD_VALUE);
Michael Wright28f24d02016-07-12 13:30:53 -07001116}
1117
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001118status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& displayToken, ColorMode mode) {
Dominik Laskowski8c001672018-05-30 16:52:06 -07001119 postMessageSync(new LambdaMessage([&] {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001120 Vector<ColorMode> modes;
1121 getDisplayColorModes(displayToken, &modes);
1122 bool exists = std::find(std::begin(modes), std::end(modes), mode) != std::end(modes);
1123 if (mode < ColorMode::NATIVE || !exists) {
1124 ALOGE("Attempt to set invalid active color mode %s (%d) for display token %p",
1125 decodeColorMode(mode).c_str(), mode, displayToken.get());
1126 return;
Michael Wright28f24d02016-07-12 13:30:53 -07001127 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001128 const auto display = getDisplayDevice(displayToken);
1129 if (!display) {
1130 ALOGE("Attempt to set active color mode %s (%d) for invalid display token %p",
1131 decodeColorMode(mode).c_str(), mode, displayToken.get());
1132 } else if (display->isVirtual()) {
1133 ALOGW("Attempt to set active color mode %s (%d) for virtual display",
1134 decodeColorMode(mode).c_str(), mode);
1135 } else {
Lloyd Pique32cbe282018-10-19 13:09:22 -07001136 display->getCompositionDisplay()->setColorMode(mode, Dataspace::UNKNOWN,
1137 RenderIntent::COLORIMETRIC);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001138 }
1139 }));
1140
Michael Wright28f24d02016-07-12 13:30:53 -07001141 return NO_ERROR;
1142}
Mathias Agopianc666cae2012-07-25 18:56:13 -07001143
Svetoslavd85084b2014-03-20 10:28:31 -07001144status_t SurfaceFlinger::clearAnimationFrameStats() {
1145 Mutex::Autolock _l(mStateLock);
1146 mAnimFrameTracker.clearStats();
1147 return NO_ERROR;
1148}
1149
1150status_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const {
1151 Mutex::Autolock _l(mStateLock);
1152 mAnimFrameTracker.getStats(outStats);
1153 return NO_ERROR;
1154}
1155
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001156status_t SurfaceFlinger::getHdrCapabilities(const sp<IBinder>& displayToken,
1157 HdrCapabilities* outCapabilities) const {
Dan Stozac4f471e2016-03-24 09:31:08 -07001158 Mutex::Autolock _l(mStateLock);
1159
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001160 const auto display = getDisplayDeviceLocked(displayToken);
1161 if (!display) {
1162 ALOGE("getHdrCapabilities: Invalid display token %p", displayToken.get());
Dan Stozac4f471e2016-03-24 09:31:08 -07001163 return BAD_VALUE;
1164 }
1165
Peiyong Linfb069302018-04-25 14:34:31 -07001166 // At this point the DisplayDeivce should already be set up,
1167 // meaning the luminance information is already queried from
1168 // hardware composer and stored properly.
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001169 const HdrCapabilities& capabilities = display->getHdrCapabilities();
Peiyong Linfb069302018-04-25 14:34:31 -07001170 *outCapabilities = HdrCapabilities(capabilities.getSupportedHdrTypes(),
1171 capabilities.getDesiredMaxLuminance(),
1172 capabilities.getDesiredMaxAverageLuminance(),
1173 capabilities.getDesiredMinLuminance());
Dan Stozac4f471e2016-03-24 09:31:08 -07001174
1175 return NO_ERROR;
1176}
1177
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001178status_t SurfaceFlinger::getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
1179 ui::PixelFormat* outFormat,
1180 ui::Dataspace* outDataspace,
1181 uint8_t* outComponentMask) const {
1182 if (!outFormat || !outDataspace || !outComponentMask) {
1183 return BAD_VALUE;
1184 }
Kevin DuBois74e53772018-11-19 10:52:38 -08001185 const auto display = getDisplayDevice(displayToken);
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001186 if (!display || !display->getId()) {
1187 ALOGE("getDisplayedContentSamplingAttributes: Bad display token: %p", display.get());
1188 return BAD_VALUE;
1189 }
1190 return getHwComposer().getDisplayedContentSamplingAttributes(*display->getId(), outFormat,
1191 outDataspace, outComponentMask);
1192}
1193
Kevin DuBois74e53772018-11-19 10:52:38 -08001194status_t SurfaceFlinger::setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken,
1195 bool enable, uint8_t componentMask,
1196 uint64_t maxFrames) const {
1197 const auto display = getDisplayDevice(displayToken);
1198 if (!display || !display->getId()) {
1199 ALOGE("setDisplayContentSamplingEnabled: Bad display token: %p", display.get());
1200 return BAD_VALUE;
1201 }
1202
1203 return getHwComposer().setDisplayContentSamplingEnabled(*display->getId(), enable,
1204 componentMask, maxFrames);
1205}
1206
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001207status_t SurfaceFlinger::getDisplayedContentSample(const sp<IBinder>& displayToken,
1208 uint64_t maxFrames, uint64_t timestamp,
1209 DisplayedFrameStats* outStats) const {
1210 const auto display = getDisplayDevice(displayToken);
1211 if (!display || !display->getId()) {
1212 ALOGE("getDisplayContentSample: Bad display token: %p", displayToken.get());
1213 return BAD_VALUE;
1214 }
1215
1216 return getHwComposer().getDisplayedContentSample(*display->getId(), maxFrames, timestamp,
1217 outStats);
1218}
1219
Peiyong Lin3c2791e2019-01-14 17:05:18 -08001220status_t SurfaceFlinger::getProtectedContentSupport(bool* outSupported) const {
1221 if (!outSupported) {
1222 return BAD_VALUE;
1223 }
1224 *outSupported = getRenderEngine().supportsProtectedContent();
1225 return NO_ERROR;
1226}
1227
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001228status_t SurfaceFlinger::isWideColorDisplay(const sp<IBinder>& displayToken,
1229 bool* outIsWideColorDisplay) const {
1230 if (!displayToken || !outIsWideColorDisplay) {
1231 return BAD_VALUE;
1232 }
1233 Mutex::Autolock _l(mStateLock);
1234 const auto display = getDisplayDeviceLocked(displayToken);
1235 if (!display) {
1236 return BAD_VALUE;
1237 }
1238 *outIsWideColorDisplay = display->hasWideColorGamut();
1239 return NO_ERROR;
1240}
1241
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001242status_t SurfaceFlinger::enableVSyncInjections(bool enable) {
Dominik Laskowski8c001672018-05-30 16:52:06 -07001243 postMessageSync(new LambdaMessage([&] {
Chia-I Wu90f669f2017-10-05 14:24:41 -07001244 Mutex::Autolock _l(mStateLock);
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001245
Chia-I Wu90f669f2017-10-05 14:24:41 -07001246 if (mInjectVSyncs == enable) {
1247 return;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001248 }
Chia-I Wu90f669f2017-10-05 14:24:41 -07001249
Ana Krulecc2870422019-01-29 19:00:58 -08001250 auto resyncCallback =
1251 mScheduler->makeResyncCallback(std::bind(&SurfaceFlinger::getVsyncPeriod, this));
Dominik Laskowskif654d572018-12-20 11:03:06 -08001252
Ady Abraham46e2f3e2019-03-18 16:40:15 -07001253 // TODO(b/128863962): Part of the Injector should be refactored, so that it
Ana Krulec98b5b242018-08-10 15:03:23 -07001254 // can be passed to Scheduler.
Chia-I Wu90f669f2017-10-05 14:24:41 -07001255 if (enable) {
1256 ALOGV("VSync Injections enabled");
1257 if (mVSyncInjector.get() == nullptr) {
Lloyd Piquee83f9312018-02-01 12:53:17 -08001258 mVSyncInjector = std::make_unique<InjectVSyncSource>();
Lloyd Pique24b0a482018-03-09 18:52:26 -08001259 mInjectorEventThread = std::make_unique<
Dominik Laskowskif654d572018-12-20 11:03:06 -08001260 impl::EventThread>(mVSyncInjector.get(),
Lloyd Pique24b0a482018-03-09 18:52:26 -08001261 impl::EventThread::InterceptVSyncsCallback(),
1262 "injEventThread");
Chia-I Wu90f669f2017-10-05 14:24:41 -07001263 }
Dominik Laskowskif654d572018-12-20 11:03:06 -08001264 mEventQueue->setEventThread(mInjectorEventThread.get(), std::move(resyncCallback));
Chia-I Wu90f669f2017-10-05 14:24:41 -07001265 } else {
1266 ALOGV("VSync Injections disabled");
Ana Krulecc2870422019-01-29 19:00:58 -08001267 mEventQueue->setEventThread(mScheduler->getEventThread(mSfConnectionHandle),
1268 std::move(resyncCallback));
Chia-I Wu90f669f2017-10-05 14:24:41 -07001269 }
1270
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001271 mInjectVSyncs = enable;
Dominik Laskowski8c001672018-05-30 16:52:06 -07001272 }));
1273
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001274 return NO_ERROR;
1275}
1276
1277status_t SurfaceFlinger::injectVSync(nsecs_t when) {
Chia-I Wu90f669f2017-10-05 14:24:41 -07001278 Mutex::Autolock _l(mStateLock);
1279
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001280 if (!mInjectVSyncs) {
1281 ALOGE("VSync Injections not enabled");
1282 return BAD_VALUE;
1283 }
1284 if (mInjectVSyncs && mInjectorEventThread.get() != nullptr) {
1285 ALOGV("Injecting VSync inside SurfaceFlinger");
1286 mVSyncInjector->onInjectSyncEvent(when);
1287 }
1288 return NO_ERROR;
1289}
1290
Lloyd Pique755e3192018-01-31 16:46:15 -08001291status_t SurfaceFlinger::getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const
1292 NO_THREAD_SAFETY_ANALYSIS {
Kalle Raitaa099a242017-01-11 11:17:29 -08001293 // Try to acquire a lock for 1s, fail gracefully
1294 const status_t err = mStateLock.timedLock(s2ns(1));
1295 const bool locked = (err == NO_ERROR);
1296 if (!locked) {
1297 ALOGE("LayerDebugInfo: SurfaceFlinger unresponsive (%s [%d]) - exit", strerror(-err), err);
1298 return TIMED_OUT;
1299 }
1300
1301 outLayers->clear();
1302 mCurrentState.traverseInZOrder([&](Layer* layer) {
1303 outLayers->push_back(layer->getLayerDebugInfo());
1304 });
1305
1306 mStateLock.unlock();
1307 return NO_ERROR;
1308}
1309
Peiyong Linc6780972018-10-28 15:24:08 -07001310status_t SurfaceFlinger::getCompositionPreference(
1311 Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
1312 Dataspace* outWideColorGamutDataspace,
1313 ui::PixelFormat* outWideColorGamutPixelFormat) const {
Peiyong Lin9d846a52018-11-05 13:18:20 -08001314 *outDataspace = mDefaultCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001315 *outPixelFormat = defaultCompositionPixelFormat;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001316 *outWideColorGamutDataspace = mWideColorGamutCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001317 *outWideColorGamutPixelFormat = wideColorGamutCompositionPixelFormat;
Peiyong Lin0256f722018-08-31 15:45:10 -07001318 return NO_ERROR;
1319}
1320
Dan Stozaec460082018-12-17 15:35:09 -08001321status_t SurfaceFlinger::addRegionSamplingListener(const Rect& samplingArea,
1322 const sp<IBinder>& stopLayerHandle,
1323 const sp<IRegionSamplingListener>& listener) {
tangrobinaf45f012019-02-26 18:10:10 +08001324 if (!listener || samplingArea == Rect::INVALID_RECT) {
Dan Stozaec460082018-12-17 15:35:09 -08001325 return BAD_VALUE;
1326 }
1327 mRegionSamplingThread->addListener(samplingArea, stopLayerHandle, listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001328 return NO_ERROR;
1329}
1330
Dan Stozaec460082018-12-17 15:35:09 -08001331status_t SurfaceFlinger::removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) {
tangrobinaf45f012019-02-26 18:10:10 +08001332 if (!listener) {
1333 return BAD_VALUE;
1334 }
Dan Stozaec460082018-12-17 15:35:09 -08001335 mRegionSamplingThread->removeListener(listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001336 return NO_ERROR;
1337}
Dan Gittik57e63c52019-01-18 16:37:54 +00001338
1339status_t SurfaceFlinger::getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
1340 bool* outSupport) const {
1341 if (!displayToken || !outSupport) {
1342 return BAD_VALUE;
1343 }
1344 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1345 if (!displayId) {
1346 return NAME_NOT_FOUND;
1347 }
1348 *outSupport =
1349 getHwComposer().hasDisplayCapability(displayId, HWC2::DisplayCapability::Brightness);
1350 return NO_ERROR;
1351}
1352
1353status_t SurfaceFlinger::setDisplayBrightness(const sp<IBinder>& displayToken,
1354 float brightness) const {
1355 if (!displayToken) {
1356 return BAD_VALUE;
1357 }
1358 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1359 if (!displayId) {
1360 return NAME_NOT_FOUND;
1361 }
1362 return getHwComposer().setDisplayBrightness(*displayId, brightness);
1363}
1364
Mathias Agopiand0566bc2011-11-17 17:49:17 -08001365// ----------------------------------------------------------------------------
1366
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -07001367sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection(
1368 ISurfaceComposer::VsyncSource vsyncSource) {
Ana Krulecc2870422019-01-29 19:00:58 -08001369 auto resyncCallback = mScheduler->makeResyncCallback([this] {
Dominik Laskowski83b88212018-12-11 13:34:06 -08001370 Mutex::Autolock lock(mStateLock);
1371 return getVsyncPeriod();
1372 });
Dominik Laskowskif654d572018-12-20 11:03:06 -08001373
Ana Krulecc2870422019-01-29 19:00:58 -08001374 const auto& handle =
1375 vsyncSource == eVsyncSourceSurfaceFlinger ? mSfConnectionHandle : mAppConnectionHandle;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001376
Ana Krulecc2870422019-01-29 19:00:58 -08001377 return mScheduler->createDisplayEventConnection(handle, std::move(resyncCallback));
Mathias Agopianbb641242010-05-18 17:06:55 -07001378}
1379
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001380// ----------------------------------------------------------------------------
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001381
1382void SurfaceFlinger::waitForEvent() {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001383 mEventQueue->waitMessage();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001384}
1385
1386void SurfaceFlinger::signalTransaction() {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001387 mEventQueue->invalidate();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001388}
1389
1390void SurfaceFlinger::signalLayerUpdate() {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001391 mEventQueue->invalidate();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001392}
1393
1394void SurfaceFlinger::signalRefresh() {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07001395 mRefreshPending = true;
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001396 mEventQueue->refresh();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001397}
1398
1399status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,
Dan Stozac7014012014-02-14 15:03:43 -08001400 nsecs_t reltime, uint32_t /* flags */) {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001401 return mEventQueue->postMessage(msg, reltime);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001402}
1403
1404status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
Dan Stozac7014012014-02-14 15:03:43 -08001405 nsecs_t reltime, uint32_t /* flags */) {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001406 status_t res = mEventQueue->postMessage(msg, reltime);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001407 if (res == NO_ERROR) {
1408 msg->wait();
1409 }
1410 return res;
1411}
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001412
Mathias Agopian4f4f0942013-08-19 17:26:18 -07001413void SurfaceFlinger::run() {
Mathias Agopian4f4f0942013-08-19 17:26:18 -07001414 do {
1415 waitForEvent();
1416 } while (true);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001417}
1418
Dominik Laskowski83b88212018-12-11 13:34:06 -08001419nsecs_t SurfaceFlinger::getVsyncPeriod() const {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001420 const auto displayId = getInternalDisplayIdLocked();
Dominik Laskowski83b88212018-12-11 13:34:06 -08001421 if (!displayId || !getHwComposer().isConnected(*displayId)) {
1422 return 0;
1423 }
1424
1425 const auto config = getHwComposer().getActiveConfig(*displayId);
1426 return config ? config->getVsyncPeriod() : 0;
1427}
1428
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001429void SurfaceFlinger::onVsyncReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId,
1430 int64_t timestamp) {
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001431 ATRACE_NAME("SF onVsync");
1432
Steven Thomas3cfac282017-02-06 12:29:30 -08001433 Mutex::Autolock lock(mStateLock);
Steven Thomasb02664d2017-07-26 18:48:28 -07001434 // Ignore any vsyncs from a previous hardware composer.
David Sodman105b7dc2017-11-04 20:28:14 -07001435 if (sequenceId != getBE().mComposerSequenceId) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001436 return;
1437 }
1438
Dominik Laskowski075d3172018-05-24 15:50:06 -07001439 if (!getHwComposer().onVsync(hwcDisplayId, timestamp)) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001440 return;
1441 }
1442
Dominik Laskowski075d3172018-05-24 15:50:06 -07001443 if (hwcDisplayId != getHwComposer().getInternalHwcDisplayId()) {
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001444 // For now, we don't do anything with external display vsyncs.
1445 return;
1446 }
1447
Ana Krulecc2870422019-01-29 19:00:58 -08001448 mScheduler->addResyncSample(timestamp);
Mathias Agopian148994e2012-09-19 17:31:36 -07001449}
1450
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001451void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
David Sodman99974d22017-11-28 12:04:33 -08001452 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
1453 *compositorTiming = getBE().mCompositorTiming;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001454}
1455
Ady Abraham838de062019-02-04 10:24:03 -08001456bool SurfaceFlinger::isConfigAllowed(const DisplayId& displayId, int32_t config) {
1457 std::lock_guard lock(mAllowedConfigsLock);
1458
1459 // if allowed configs are not set yet for this display, every config is considered allowed
1460 if (mAllowedConfigs.find(displayId) == mAllowedConfigs.end()) {
1461 return true;
1462 }
1463
1464 return mAllowedConfigs[displayId]->isConfigAllowed(config);
1465}
1466
Ana Krulec8d3e4f32019-03-05 10:40:33 -08001467void SurfaceFlinger::setRefreshRateTo(RefreshRateType refreshRate, Scheduler::ConfigEvent event) {
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001468 if (mBootStage != BootStage::FINISHED) {
Ana Krulec7d1d6832018-12-27 11:10:09 -08001469 return;
1470 }
Alec Mouri1c9e82b2019-03-07 12:24:05 -08001471 ATRACE_CALL();
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001472
Ana Krulec7d1d6832018-12-27 11:10:09 -08001473 // Don't do any updating if the current fps is the same as the new one.
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001474 const auto displayId = getInternalDisplayIdLocked();
1475 LOG_ALWAYS_FATAL_IF(!displayId);
Ady Abraham1902d072019-03-01 17:18:59 -08001476 const auto displayToken = getInternalDisplayTokenLocked();
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001477
Alec Mouri0a1cc962019-03-14 12:33:02 -07001478 const auto& refreshRateConfig = mRefreshRateConfigs[*displayId]->getRefreshRate(refreshRate);
1479 if (!refreshRateConfig) {
1480 ALOGV("Skipping refresh rate change request for unsupported rate.");
Ady Abraham1902d072019-03-01 17:18:59 -08001481 return;
Ana Krulec7d1d6832018-12-27 11:10:09 -08001482 }
Ady Abraham1902d072019-03-01 17:18:59 -08001483
Alec Mouri0a1cc962019-03-14 12:33:02 -07001484 const int desiredConfigId = refreshRateConfig->configId;
1485
Ady Abraham1902d072019-03-01 17:18:59 -08001486 if (!isConfigAllowed(*displayId, desiredConfigId)) {
1487 ALOGV("Skipping config %d as it is not part of allowed configs", desiredConfigId);
1488 return;
1489 }
1490
Alec Mouri0a1cc962019-03-14 12:33:02 -07001491 const auto display = getDisplayDeviceLocked(displayToken);
1492 if (desiredConfigId == display->getActiveConfig()) {
1493 return;
1494 }
1495
Alec Mouri1c9e82b2019-03-07 12:24:05 -08001496 mPhaseOffsets->setRefreshRateType(refreshRate);
Ady Abraham03b02dd2019-03-21 15:40:11 -07001497 setDesiredActiveConfig({refreshRate, desiredConfigId, getInternalDisplayTokenLocked(), event});
Ana Krulec7d1d6832018-12-27 11:10:09 -08001498}
1499
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001500void SurfaceFlinger::onHotplugReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId,
Lloyd Pique715a2c12017-12-14 17:18:08 -08001501 HWC2::Connection connection) {
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001502 ALOGV("%s(%d, %" PRIu64 ", %s)", __FUNCTION__, sequenceId, hwcDisplayId,
Lloyd Pique715a2c12017-12-14 17:18:08 -08001503 connection == HWC2::Connection::Connected ? "connected" : "disconnected");
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001504
Lloyd Piqueba04e622017-12-14 17:11:26 -08001505 // Ignore events that do not have the right sequenceId.
1506 if (sequenceId != getBE().mComposerSequenceId) {
1507 return;
1508 }
1509
Steven Thomasb02664d2017-07-26 18:48:28 -07001510 // Only lock if we're not on the main thread. This function is normally
1511 // called on a hwbinder thread, but for the primary display it's called on
1512 // the main thread with the state lock already held, so don't attempt to
1513 // acquire it here.
Lloyd Piqueba04e622017-12-14 17:11:26 -08001514 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
Steven Thomasb02664d2017-07-26 18:48:28 -07001515
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001516 mPendingHotplugEvents.emplace_back(HotplugEvent{hwcDisplayId, connection});
Mathias Agopian9e2463e2012-09-21 18:26:16 -07001517
Jiwen 'Steve' Caiccfd6822018-02-21 16:15:58 -08001518 if (std::this_thread::get_id() == mMainThreadId) {
1519 // Process all pending hot plug events immediately if we are on the main thread.
1520 processDisplayHotplugEventsLocked();
1521 }
1522
Lloyd Piqueba04e622017-12-14 17:11:26 -08001523 setTransactionFlags(eDisplayTransactionNeeded);
Mathias Agopian86303202012-07-24 22:46:10 -07001524}
1525
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001526void SurfaceFlinger::onRefreshReceived(int sequenceId, hwc2_display_t /*hwcDisplayId*/) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001527 Mutex::Autolock lock(mStateLock);
David Sodman105b7dc2017-11-04 20:28:14 -07001528 if (sequenceId != getBE().mComposerSequenceId) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001529 return;
Steven Thomas3cfac282017-02-06 12:29:30 -08001530 }
Ana Krulec7d1d6832018-12-27 11:10:09 -08001531 repaintEverythingForHWC();
Steven Thomas3cfac282017-02-06 12:29:30 -08001532}
1533
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001534void SurfaceFlinger::setPrimaryVsyncEnabled(bool enabled) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001535 ATRACE_CALL();
Steven Thomasb02664d2017-07-26 18:48:28 -07001536 Mutex::Autolock lock(mStateLock);
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001537 if (const auto displayId = getInternalDisplayIdLocked()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07001538 getHwComposer().setVsyncEnabled(*displayId,
1539 enabled ? HWC2::Vsync::Enable : HWC2::Vsync::Disable);
1540 }
Mathias Agopian86303202012-07-24 22:46:10 -07001541}
1542
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001543// Note: it is assumed the caller holds |mStateLock| when this is called
Steven Thomasb02664d2017-07-26 18:48:28 -07001544void SurfaceFlinger::resetDisplayState() {
Ana Krulecc2870422019-01-29 19:00:58 -08001545 mScheduler->disableHardwareVsync(true);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001546 // Clear the drawing state so that the logic inside of
1547 // handleTransactionLocked will fire. It will determine the delta between
1548 // mCurrentState and mDrawingState and re-apply all changes when we make the
1549 // transition.
1550 mDrawingState.displays.clear();
1551 mDisplays.clear();
1552}
1553
Steven Thomas050b2c82017-03-06 11:45:16 -08001554void SurfaceFlinger::updateVrFlinger() {
Alec Mourife3dc942019-02-12 14:19:18 -08001555 ATRACE_CALL();
Steven Thomas050b2c82017-03-06 11:45:16 -08001556 if (!mVrFlinger)
1557 return;
1558 bool vrFlingerRequestsDisplay = mVrFlingerRequestsDisplay;
Lloyd Pique441d5042018-10-18 16:49:51 -07001559 if (vrFlingerRequestsDisplay == getHwComposer().isUsingVrComposer()) {
Mark Urbanus209beca2017-02-23 11:16:04 -08001560 return;
1561 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001562
Lloyd Pique441d5042018-10-18 16:49:51 -07001563 if (vrFlingerRequestsDisplay && !getHwComposer().getComposer()->isRemote()) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001564 ALOGE("Vr flinger is only supported for remote hardware composer"
1565 " service connections. Ignoring request to transition to vr"
1566 " flinger.");
1567 mVrFlingerRequestsDisplay = false;
1568 return;
Mark Urbanus209beca2017-02-23 11:16:04 -08001569 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001570
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001571 Mutex::Autolock _l(mStateLock);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001572
Steven Thomas0123ac62018-07-12 11:32:34 -07001573 sp<DisplayDevice> display = getDefaultDisplayDeviceLocked();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07001574 LOG_ALWAYS_FATAL_IF(!display);
Lloyd Pique07e33212018-12-18 16:33:37 -08001575
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07001576 const int currentDisplayPowerMode = display->getPowerMode();
Lloyd Pique07e33212018-12-18 16:33:37 -08001577
1578 // Clear out all the output layers from the composition engine for all
1579 // displays before destroying the hardware composer interface. This ensures
1580 // any HWC layers are destroyed through that interface before it becomes
1581 // invalid.
1582 for (const auto& [token, displayDevice] : mDisplays) {
1583 displayDevice->getCompositionDisplay()->setOutputLayersOrderedByZ(
1584 compositionengine::Output::OutputLayers());
1585 }
1586
Steven Thomas0123ac62018-07-12 11:32:34 -07001587 // This DisplayDevice will no longer be relevant once resetDisplayState() is
1588 // called below. Clear the reference now so we don't accidentally use it
1589 // later.
1590 display.clear();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001591
Steven Thomasb02664d2017-07-26 18:48:28 -07001592 if (!vrFlingerRequestsDisplay) {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001593 mVrFlinger->SeizeDisplayOwnership();
Steven Thomasb02664d2017-07-26 18:48:28 -07001594 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001595
Steven Thomasb02664d2017-07-26 18:48:28 -07001596 resetDisplayState();
Lloyd Pique441d5042018-10-18 16:49:51 -07001597 // Delete the current instance before creating the new one
1598 mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
1599 mCompositionEngine->setHwComposer(getFactory().createHWComposer(
1600 vrFlingerRequestsDisplay ? "vr" : getBE().mHwcServiceName));
1601 getHwComposer().registerCallback(this, ++getBE().mComposerSequenceId);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001602
Lloyd Pique441d5042018-10-18 16:49:51 -07001603 LOG_ALWAYS_FATAL_IF(!getHwComposer().getComposer()->isRemote(),
David Sodman105b7dc2017-11-04 20:28:14 -07001604 "Switched to non-remote hardware composer");
Steven Thomasb02664d2017-07-26 18:48:28 -07001605
1606 if (vrFlingerRequestsDisplay) {
1607 mVrFlinger->GrantDisplayOwnership();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001608 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001609
1610 mVisibleRegionsDirty = true;
1611 invalidateHwcGeometry();
1612
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001613 // Re-enable default display.
Steven Thomas0123ac62018-07-12 11:32:34 -07001614 display = getDefaultDisplayDeviceLocked();
1615 LOG_ALWAYS_FATAL_IF(!display);
Dominik Laskowskie9774092018-12-11 10:04:24 -08001616 setPowerModeInternal(display, currentDisplayPowerMode);
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001617
Steven Thomasb02664d2017-07-26 18:48:28 -07001618 // Reset the timing values to account for the period of the swapped in HWC
Dominik Laskowski83b88212018-12-11 13:34:06 -08001619 const nsecs_t vsyncPeriod = getVsyncPeriod();
1620 mAnimFrameTracker.setDisplayRefreshPeriod(vsyncPeriod);
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001621
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001622 // The present fences returned from vr_hwc are not an accurate
1623 // representation of vsync times.
Ana Krulecc2870422019-01-29 19:00:58 -08001624 mScheduler->setIgnorePresentFences(getHwComposer().isUsingVrComposer() || !hasSyncFramework);
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001625
Steven Thomasb02664d2017-07-26 18:48:28 -07001626 // Use phase of 0 since phase is not known.
1627 // Use latency of 0, which will snap to the ideal latency.
Dominik Laskowski83b88212018-12-11 13:34:06 -08001628 DisplayStatInfo stats{0 /* vsyncTime */, vsyncPeriod};
Ana Krulece588e312018-09-18 12:32:24 -07001629 setCompositorTimingSnapped(stats, 0);
Stephen Kiazyk82386cd2017-04-14 13:43:29 -07001630
Ana Krulecc2870422019-01-29 19:00:58 -08001631 mScheduler->resyncToHardwareVsync(false, vsyncPeriod);
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001632
Lloyd Piquef1c675b2018-09-12 20:45:39 -07001633 mRepaintEverything = true;
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001634 setTransactionFlags(eDisplayTransactionNeeded);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001635}
1636
Mathias Agopian4fec8732012-06-29 14:12:52 -07001637void SurfaceFlinger::onMessageReceived(int32_t what) {
Jamie Gennis1c8e95c2012-02-23 19:27:23 -08001638 ATRACE_CALL();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001639 switch (what) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08001640 case MessageQueue::INVALIDATE: {
Alec Mouricc0fc602019-02-26 21:45:19 -08001641 bool frameMissed = mPreviousPresentFence != Fence::NO_FENCE &&
1642 (mPreviousPresentFence->getStatus() == Fence::Status::Unsignaled);
1643 bool hwcFrameMissed = mHadDeviceComposition && frameMissed;
1644 bool gpuFrameMissed = mHadClientComposition && frameMissed;
1645 ATRACE_INT("FrameMissed", static_cast<int>(frameMissed));
1646 ATRACE_INT("HwcFrameMissed", static_cast<int>(hwcFrameMissed));
1647 ATRACE_INT("GpuFrameMissed", static_cast<int>(gpuFrameMissed));
1648 if (frameMissed) {
1649 mFrameMissedCount++;
1650 mTimeStats->incrementMissedFrames();
1651 }
1652
Alec Mouri40189b02019-03-05 15:07:54 -08001653 if (hwcFrameMissed) {
1654 mHwcFrameMissedCount++;
1655 }
1656
1657 if (gpuFrameMissed) {
1658 mGpuFrameMissedCount++;
1659 }
1660
Ana Krulecfefd6ae2019-02-13 17:53:08 -08001661 if (mUseSmart90ForVideo) {
1662 // This call is made each time SF wakes up and creates a new frame. It is part
1663 // of video detection feature.
1664 mScheduler->updateFpsBasedOnNativeWindowApi();
1665 }
1666
Ady Abrahamb838aed2019-02-12 15:30:16 -08001667 if (performSetActiveConfig()) {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001668 break;
1669 }
1670
Alec Mourife3dc942019-02-12 14:19:18 -08001671 // For now, only propagate backpressure when missing a hwc frame.
1672 if (hwcFrameMissed) {
Yiwei Zhang621f9d42018-05-07 10:40:55 -07001673 if (mPropagateBackpressure) {
1674 signalLayerUpdate();
1675 break;
1676 }
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07001677 }
Dan Stoza50182882016-07-08 12:02:20 -07001678
Steven Thomas050b2c82017-03-06 11:45:16 -08001679 // Now that we're going to make it to the handleMessageTransaction()
1680 // call below it's safe to call updateVrFlinger(), which will
1681 // potentially trigger a display handoff.
1682 updateVrFlinger();
1683
Dan Stoza6b9454d2014-11-07 16:00:59 -08001684 bool refreshNeeded = handleMessageTransaction();
1685 refreshNeeded |= handleMessageInvalidate();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001686
1687 updateCursorAsync();
1688 updateInputFlinger();
1689
Dan Stoza58784442014-12-02 16:58:17 -08001690 refreshNeeded |= mRepaintEverything;
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08001691 if (refreshNeeded && CC_LIKELY(mBootStage != BootStage::BOOTLOADER)) {
Dan Stoza58784442014-12-02 16:58:17 -08001692 // Signal a refresh if a transaction modified the window state,
1693 // a new buffer was latched, or if HWC has requested a full
1694 // repaint
Dan Stoza6b9454d2014-11-07 16:00:59 -08001695 signalRefresh();
1696 }
1697 break;
1698 }
1699 case MessageQueue::REFRESH: {
1700 handleMessageRefresh();
1701 break;
1702 }
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001703 }
1704}
1705
Dan Stoza6b9454d2014-11-07 16:00:59 -08001706bool SurfaceFlinger::handleMessageTransaction() {
Alec Mourife3dc942019-02-12 14:19:18 -08001707 ATRACE_CALL();
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08001708 uint32_t transactionFlags = peekTransactionFlags();
Marissa Wall713b63f2018-10-17 15:42:43 -07001709
1710 // Apply any ready transactions in the queues if there are still transactions that have not been
1711 // applied, wake up during the next vsync period and check again
1712 bool transactionNeeded = false;
1713 if (!flushTransactionQueues()) {
1714 transactionNeeded = true;
1715 }
1716
Mathias Agopian4fec8732012-06-29 14:12:52 -07001717 if (transactionFlags) {
Mathias Agopian87baae12012-07-31 12:38:26 -07001718 handleTransaction(transactionFlags);
Mathias Agopian4fec8732012-06-29 14:12:52 -07001719 }
Marissa Wall713b63f2018-10-17 15:42:43 -07001720
1721 if (transactionNeeded) {
1722 setTransactionFlags(eTransactionNeeded);
1723 }
1724
1725 return transactionFlags;
Mathias Agopian4fec8732012-06-29 14:12:52 -07001726}
1727
Mathias Agopian4fec8732012-06-29 14:12:52 -07001728void SurfaceFlinger::handleMessageRefresh() {
Mathias Agopiancd60f992012-08-16 16:28:27 -07001729 ATRACE_CALL();
Dan Stoza14cd37c2015-07-09 12:43:33 -07001730
Dan Stoza2b6d38e2017-06-01 16:40:30 -07001731 mRefreshPending = false;
1732
Lloyd Piquef1c675b2018-09-12 20:45:39 -07001733 const bool repaintEverything = mRepaintEverything.exchange(false);
David Sodman2b406362017-12-15 13:33:47 -08001734 preComposition();
Lloyd Pique074e8122018-07-26 12:57:23 -07001735 rebuildLayerStacks();
David Sodman79bba0e2018-08-05 18:07:49 -07001736 calculateWorkingSet();
David Sodmanfa9b2af2017-12-24 13:28:59 -08001737 for (const auto& [token, display] : mDisplays) {
1738 beginFrame(display);
1739 prepareFrame(display);
1740 doDebugFlashRegions(display, repaintEverything);
1741 doComposition(display, repaintEverything);
1742 }
1743
Yiwei Zhang7124ad32018-02-21 13:02:45 -08001744 logLayerStats();
David Sodmanfa9b2af2017-12-24 13:28:59 -08001745
1746 postFrame();
David Sodman2b406362017-12-15 13:33:47 -08001747 postComposition();
Dan Stoza05dacfb2016-07-01 13:33:38 -07001748
Dan Stozabfbffeb2016-07-21 14:49:33 -07001749 mHadClientComposition = false;
Alec Mouricc0fc602019-02-26 21:45:19 -08001750 mHadDeviceComposition = false;
Lloyd Pique32cbe282018-10-19 13:09:22 -07001751 for (const auto& [token, displayDevice] : mDisplays) {
1752 auto display = displayDevice->getCompositionDisplay();
1753 const auto displayId = display->getId();
Lloyd Pique441d5042018-10-18 16:49:51 -07001754 mHadClientComposition =
Lloyd Pique32cbe282018-10-19 13:09:22 -07001755 mHadClientComposition || getHwComposer().hasClientComposition(displayId);
Alec Mouricc0fc602019-02-26 21:45:19 -08001756 mHadDeviceComposition =
1757 mHadDeviceComposition || getHwComposer().hasDeviceComposition(displayId);
Dan Stozabfbffeb2016-07-21 14:49:33 -07001758 }
David Sodmanfa9b2af2017-12-24 13:28:59 -08001759
Jorim Jaggi90535212018-05-23 23:44:06 +02001760 mVsyncModulator.onRefreshed(mHadClientComposition);
Dan Stoza14cd37c2015-07-09 12:43:33 -07001761
David Sodman7e4ae112018-02-09 15:02:28 -08001762 mLayersWithQueuedFrames.clear();
Mathias Agopiancd60f992012-08-16 16:28:27 -07001763}
Mathias Agopian4fec8732012-06-29 14:12:52 -07001764
David Sodmanfa9b2af2017-12-24 13:28:59 -08001765
1766bool SurfaceFlinger::handleMessageInvalidate() {
1767 ATRACE_CALL();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001768 bool refreshNeeded = handlePageFlip();
1769
Vishnu Nair4351ad52019-02-11 14:13:02 -08001770 if (mVisibleRegionsDirty) {
1771 computeLayerBounds();
Nataniel Borges2b796da2019-02-15 13:32:18 -08001772 if (mTracingEnabled) {
1773 mTracing.notify("visibleRegionsDirty");
1774 }
Vishnu Nair4351ad52019-02-11 14:13:02 -08001775 }
1776
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001777 for (auto& layer : mLayersPendingRefresh) {
1778 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08001779 visibleReg.set(layer->getScreenBounds());
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001780 invalidateLayerStack(layer, visibleReg);
1781 }
1782 mLayersPendingRefresh.clear();
1783 return refreshNeeded;
Mathias Agopian4fec8732012-06-29 14:12:52 -07001784}
1785
David Sodman79bba0e2018-08-05 18:07:49 -07001786void SurfaceFlinger::calculateWorkingSet() {
1787 ATRACE_CALL();
1788 ALOGV(__FUNCTION__);
1789
David Sodman79bba0e2018-08-05 18:07:49 -07001790 // build the h/w work list
1791 if (CC_UNLIKELY(mGeometryInvalid)) {
1792 mGeometryInvalid = false;
Lloyd Pique32cbe282018-10-19 13:09:22 -07001793 for (const auto& [token, displayDevice] : mDisplays) {
1794 auto display = displayDevice->getCompositionDisplay();
David Sodman79bba0e2018-08-05 18:07:49 -07001795
Lloyd Piquea83776c2019-01-29 18:42:32 -08001796 uint32_t zOrder = 0;
David Sodman79bba0e2018-08-05 18:07:49 -07001797
Lloyd Piquea83776c2019-01-29 18:42:32 -08001798 for (auto& layer : display->getOutputLayersOrderedByZ()) {
1799 auto& compositionState = layer->editState();
1800 compositionState.forceClientComposition = false;
1801 if (!compositionState.hwc || mDebugDisableHWC || mDebugRegion) {
1802 compositionState.forceClientComposition = true;
David Sodman79bba0e2018-08-05 18:07:49 -07001803 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07001804
Lloyd Piquea83776c2019-01-29 18:42:32 -08001805 // The output Z order is set here based on a simple counter.
1806 compositionState.z = zOrder++;
1807
1808 // Update the display independent composition state. This goes
1809 // to the general composition layer state structure.
1810 // TODO: Do this once per compositionengine::CompositionLayer.
1811 layer->getLayerFE().latchCompositionState(layer->getLayer().editState().frontEnd,
1812 true);
1813
1814 // Recalculate the geometry state of the output layer.
1815 layer->updateCompositionState(true);
1816
1817 // Write the updated geometry state to the HWC
1818 layer->writeStateToHWC(true);
David Sodman79bba0e2018-08-05 18:07:49 -07001819 }
1820 }
1821 }
1822
1823 // Set the per-frame data
Lloyd Pique32cbe282018-10-19 13:09:22 -07001824 for (const auto& [token, displayDevice] : mDisplays) {
1825 auto display = displayDevice->getCompositionDisplay();
David Sodman79bba0e2018-08-05 18:07:49 -07001826 const auto displayId = display->getId();
Dominik Laskowski075d3172018-05-24 15:50:06 -07001827 if (!displayId) {
David Sodman79bba0e2018-08-05 18:07:49 -07001828 continue;
1829 }
Lloyd Pique3d0c02e2018-10-19 18:38:12 -07001830 auto* profile = display->getDisplayColorProfile();
David Sodman79bba0e2018-08-05 18:07:49 -07001831
1832 if (mDrawingState.colorMatrixChanged) {
1833 display->setColorTransform(mDrawingState.colorMatrix);
David Sodman79bba0e2018-08-05 18:07:49 -07001834 }
Peiyong Linc502cb72019-03-01 15:00:23 -08001835 Dataspace targetDataspace = Dataspace::UNKNOWN;
1836 if (useColorManagement) {
1837 ColorMode colorMode;
1838 RenderIntent renderIntent;
1839 pickColorMode(displayDevice, &colorMode, &targetDataspace, &renderIntent);
1840 display->setColorMode(colorMode, targetDataspace, renderIntent);
1841 }
Lloyd Pique32cbe282018-10-19 13:09:22 -07001842 for (auto& layer : displayDevice->getVisibleLayersSortedByZ()) {
David Sodman79bba0e2018-08-05 18:07:49 -07001843 if (layer->isHdrY410()) {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001844 layer->forceClientComposition(displayDevice);
David Sodman79bba0e2018-08-05 18:07:49 -07001845 } else if ((layer->getDataSpace() == Dataspace::BT2020_PQ ||
1846 layer->getDataSpace() == Dataspace::BT2020_ITU_PQ) &&
Lloyd Pique3d0c02e2018-10-19 18:38:12 -07001847 !profile->hasHDR10Support()) {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001848 layer->forceClientComposition(displayDevice);
David Sodman79bba0e2018-08-05 18:07:49 -07001849 } else if ((layer->getDataSpace() == Dataspace::BT2020_HLG ||
1850 layer->getDataSpace() == Dataspace::BT2020_ITU_HLG) &&
Lloyd Pique3d0c02e2018-10-19 18:38:12 -07001851 !profile->hasHLGSupport()) {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001852 layer->forceClientComposition(displayDevice);
David Sodman79bba0e2018-08-05 18:07:49 -07001853 }
1854
Peiyong Lind3788632018-09-18 16:01:31 -07001855 // TODO(b/111562338) remove when composer 2.3 is shipped.
1856 if (layer->hasColorTransform()) {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001857 layer->forceClientComposition(displayDevice);
Peiyong Lind3788632018-09-18 16:01:31 -07001858 }
1859
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001860 if (layer->getRoundedCornerState().radius > 0.0f) {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001861 layer->forceClientComposition(displayDevice);
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001862 }
1863
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001864 if (layer->getForceClientComposition(displayDevice)) {
David Sodman79bba0e2018-08-05 18:07:49 -07001865 ALOGV("[%s] Requesting Client composition", layer->getName().string());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001866 layer->setCompositionType(displayDevice,
1867 Hwc2::IComposerClient::Composition::CLIENT);
David Sodman79bba0e2018-08-05 18:07:49 -07001868 continue;
1869 }
1870
Lloyd Pique32cbe282018-10-19 13:09:22 -07001871 const auto& displayState = display->getState();
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001872 layer->setPerFrameData(displayDevice, displayState.transform, displayState.viewport,
Peiyong Lin34ea5b92019-03-15 18:40:15 -07001873 displayDevice->getSupportedPerFrameMetadata(),
1874 isHdrColorMode(displayState.colorMode) ? Dataspace::UNKNOWN
1875 : targetDataspace);
David Sodman79bba0e2018-08-05 18:07:49 -07001876 }
1877 }
1878
1879 mDrawingState.colorMatrixChanged = false;
David Sodmanba340492018-08-05 21:51:33 -07001880
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001881 for (const auto& [token, displayDevice] : mDisplays) {
1882 auto display = displayDevice->getCompositionDisplay();
1883 for (auto& layer : displayDevice->getVisibleLayersSortedByZ()) {
Lloyd Pique0b785d82018-12-04 17:25:27 -08001884 auto& layerState = layer->getCompositionLayer()->editState().frontEnd;
1885 layerState.compositionType = static_cast<Hwc2::IComposerClient::Composition>(
1886 layer->getCompositionType(displayDevice));
David Sodmanba340492018-08-05 21:51:33 -07001887 }
1888 }
David Sodman79bba0e2018-08-05 18:07:49 -07001889}
1890
Lloyd Pique32cbe282018-10-19 13:09:22 -07001891void SurfaceFlinger::doDebugFlashRegions(const sp<DisplayDevice>& displayDevice,
1892 bool repaintEverything) {
1893 auto display = displayDevice->getCompositionDisplay();
1894 const auto& displayState = display->getState();
1895
Mathias Agopiancd60f992012-08-16 16:28:27 -07001896 // is debugging enabled
1897 if (CC_LIKELY(!mDebugRegion))
1898 return;
1899
Lloyd Pique32cbe282018-10-19 13:09:22 -07001900 if (displayState.isEnabled) {
David Sodmanfa9b2af2017-12-24 13:28:59 -08001901 // transform the dirty region into this screen's coordinate space
Alec Mourie7d1d4a2019-02-05 01:13:46 +00001902 const Region dirtyRegion = display->getDirtyRegion(repaintEverything);
David Sodmanfa9b2af2017-12-24 13:28:59 -08001903 if (!dirtyRegion.isEmpty()) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +00001904 base::unique_fd readyFence;
David Sodmanfa9b2af2017-12-24 13:28:59 -08001905 // redraw the whole screen
Alec Mourie7d1d4a2019-02-05 01:13:46 +00001906 doComposeSurfaces(displayDevice, dirtyRegion, &readyFence);
Mathias Agopiancd60f992012-08-16 16:28:27 -07001907
Alec Mourie7d1d4a2019-02-05 01:13:46 +00001908 display->getRenderSurface()->queueBuffer(std::move(readyFence));
Mathias Agopiancd60f992012-08-16 16:28:27 -07001909 }
1910 }
1911
Lloyd Pique32cbe282018-10-19 13:09:22 -07001912 postFramebuffer(displayDevice);
Mathias Agopiancd60f992012-08-16 16:28:27 -07001913
1914 if (mDebugRegion > 1) {
1915 usleep(mDebugRegion * 1000);
1916 }
Mathias Agopianbb53b0e2012-09-24 21:27:29 -07001917
Lloyd Pique32cbe282018-10-19 13:09:22 -07001918 prepareFrame(displayDevice);
Mathias Agopiancd60f992012-08-16 16:28:27 -07001919}
1920
Yiwei Zhang7124ad32018-02-21 13:02:45 -08001921void SurfaceFlinger::logLayerStats() {
1922 ATRACE_CALL();
1923 if (CC_UNLIKELY(mLayerStats.isEnabled())) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07001924 for (const auto& [token, display] : mDisplays) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001925 if (display->isPrimary()) {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001926 mLayerStats.logLayerStats(dumpVisibleLayersProtoInfo(display));
Dominik Laskowski63165dc2018-05-25 18:36:52 -07001927 return;
Yiwei Zhang7124ad32018-02-21 13:02:45 -08001928 }
1929 }
Dominik Laskowski63165dc2018-05-25 18:36:52 -07001930
1931 ALOGE("logLayerStats: no primary display");
Yiwei Zhang7124ad32018-02-21 13:02:45 -08001932 }
1933}
1934
David Sodman2b406362017-12-15 13:33:47 -08001935void SurfaceFlinger::preComposition()
Mathias Agopiancd60f992012-08-16 16:28:27 -07001936{
Dan Stoza9e56aa02015-11-02 13:00:03 -08001937 ATRACE_CALL();
1938 ALOGV("preComposition");
1939
David Sodman2b406362017-12-15 13:33:47 -08001940 mRefreshStartTime = systemTime(SYSTEM_TIME_MONOTONIC);
1941
Mathias Agopiancd60f992012-08-16 16:28:27 -07001942 bool needExtraInvalidate = false;
Robert Carr2047fae2016-11-28 14:09:09 -08001943 mDrawingState.traverseInZOrder([&](Layer* layer) {
David Sodman2b406362017-12-15 13:33:47 -08001944 if (layer->onPreComposition(mRefreshStartTime)) {
Mathias Agopiancd60f992012-08-16 16:28:27 -07001945 needExtraInvalidate = true;
1946 }
Robert Carr2047fae2016-11-28 14:09:09 -08001947 });
1948
Mathias Agopiancd60f992012-08-16 16:28:27 -07001949 if (needExtraInvalidate) {
1950 signalLayerUpdate();
1951 }
1952}
1953
Ana Krulece588e312018-09-18 12:32:24 -07001954void SurfaceFlinger::updateCompositorTiming(const DisplayStatInfo& stats, nsecs_t compositeTime,
1955 std::shared_ptr<FenceTime>& presentFenceTime) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001956 // Update queue of past composite+present times and determine the
1957 // most recently known composite to present latency.
David Sodman99974d22017-11-28 12:04:33 -08001958 getBE().mCompositePresentTimes.push({compositeTime, presentFenceTime});
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001959 nsecs_t compositeToPresentLatency = -1;
David Sodman99974d22017-11-28 12:04:33 -08001960 while (!getBE().mCompositePresentTimes.empty()) {
1961 SurfaceFlingerBE::CompositePresentTime& cpt = getBE().mCompositePresentTimes.front();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001962 // Cached values should have been updated before calling this method,
1963 // which helps avoid duplicate syscalls.
1964 nsecs_t displayTime = cpt.display->getCachedSignalTime();
1965 if (displayTime == Fence::SIGNAL_TIME_PENDING) {
1966 break;
1967 }
1968 compositeToPresentLatency = displayTime - cpt.composite;
David Sodman99974d22017-11-28 12:04:33 -08001969 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001970 }
1971
1972 // Don't let mCompositePresentTimes grow unbounded, just in case.
David Sodman99974d22017-11-28 12:04:33 -08001973 while (getBE().mCompositePresentTimes.size() > 16) {
1974 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001975 }
1976
Ana Krulece588e312018-09-18 12:32:24 -07001977 setCompositorTimingSnapped(stats, compositeToPresentLatency);
Brian Andersond0010582017-03-07 13:20:31 -08001978}
1979
Ana Krulece588e312018-09-18 12:32:24 -07001980void SurfaceFlinger::setCompositorTimingSnapped(const DisplayStatInfo& stats,
1981 nsecs_t compositeToPresentLatency) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001982 // Integer division and modulo round toward 0 not -inf, so we need to
1983 // treat negative and positive offsets differently.
Ana Krulec757f63a2019-01-25 10:46:18 -08001984 nsecs_t idealLatency = (mPhaseOffsets->getCurrentSfOffset() > 0)
1985 ? (stats.vsyncPeriod - (mPhaseOffsets->getCurrentSfOffset() % stats.vsyncPeriod))
1986 : ((-mPhaseOffsets->getCurrentSfOffset()) % stats.vsyncPeriod);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001987
Ana Krulec757f63a2019-01-25 10:46:18 -08001988 // Just in case mPhaseOffsets->getCurrentSfOffset() == -vsyncInterval.
Brian Andersond0010582017-03-07 13:20:31 -08001989 if (idealLatency <= 0) {
Ana Krulece588e312018-09-18 12:32:24 -07001990 idealLatency = stats.vsyncPeriod;
Brian Andersond0010582017-03-07 13:20:31 -08001991 }
1992
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001993 // Snap the latency to a value that removes scheduling jitter from the
1994 // composition and present times, which often have >1ms of jitter.
1995 // Reducing jitter is important if an app attempts to extrapolate
1996 // something (such as user input) to an accurate diasplay time.
Ana Krulec757f63a2019-01-25 10:46:18 -08001997 // Snapping also allows an app to precisely calculate mPhaseOffsets->getCurrentSfOffset()
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001998 // with (presentLatency % interval).
Ana Krulece588e312018-09-18 12:32:24 -07001999 nsecs_t bias = stats.vsyncPeriod / 2;
2000 int64_t extraVsyncs = (compositeToPresentLatency - idealLatency + bias) / stats.vsyncPeriod;
2001 nsecs_t snappedCompositeToPresentLatency =
2002 (extraVsyncs > 0) ? idealLatency + (extraVsyncs * stats.vsyncPeriod) : idealLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002003
David Sodman99974d22017-11-28 12:04:33 -08002004 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
Ana Krulece588e312018-09-18 12:32:24 -07002005 getBE().mCompositorTiming.deadline = stats.vsyncTime - idealLatency;
2006 getBE().mCompositorTiming.interval = stats.vsyncPeriod;
David Sodman99974d22017-11-28 12:04:33 -08002007 getBE().mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002008}
2009
David Sodman2b406362017-12-15 13:33:47 -08002010void SurfaceFlinger::postComposition()
Mathias Agopiancd60f992012-08-16 16:28:27 -07002011{
Dan Stoza9e56aa02015-11-02 13:00:03 -08002012 ATRACE_CALL();
2013 ALOGV("postComposition");
2014
Brian Anderson3546a3f2016-07-14 11:51:14 -07002015 // Release any buffers which were replaced this frame
Brian Andersonf6386862016-10-31 16:34:13 -07002016 nsecs_t dequeueReadyTime = systemTime();
Brian Anderson3546a3f2016-07-14 11:51:14 -07002017 for (auto& layer : mLayersWithQueuedFrames) {
Brian Andersonf6386862016-10-31 16:34:13 -07002018 layer->releasePendingBuffer(dequeueReadyTime);
Brian Anderson3546a3f2016-07-14 11:51:14 -07002019 }
2020
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07002021 // |mStateLock| not needed as we are on the main thread
Lloyd Pique32cbe282018-10-19 13:09:22 -07002022 const auto displayDevice = getDefaultDisplayDeviceLocked();
Brian Anderson3d4039d2016-09-23 16:31:30 -07002023
David Sodman73beded2017-11-15 11:56:06 -08002024 getBE().mGlCompositionDoneTimeline.updateSignalTimes();
Brian Anderson3d4039d2016-09-23 16:31:30 -07002025 std::shared_ptr<FenceTime> glCompositionDoneFenceTime;
Lloyd Pique32cbe282018-10-19 13:09:22 -07002026 if (displayDevice && getHwComposer().hasClientComposition(displayDevice->getId())) {
Brian Anderson3d4039d2016-09-23 16:31:30 -07002027 glCompositionDoneFenceTime =
Lloyd Pique31cb2942018-10-19 17:23:03 -07002028 std::make_shared<FenceTime>(displayDevice->getCompositionDisplay()
2029 ->getRenderSurface()
2030 ->getClientTargetAcquireFence());
David Sodman73beded2017-11-15 11:56:06 -08002031 getBE().mGlCompositionDoneTimeline.push(glCompositionDoneFenceTime);
Brian Anderson3d4039d2016-09-23 16:31:30 -07002032 } else {
2033 glCompositionDoneFenceTime = FenceTime::NO_FENCE;
2034 }
Brian Anderson3d4039d2016-09-23 16:31:30 -07002035
David Sodman73beded2017-11-15 11:56:06 -08002036 getBE().mDisplayTimeline.updateSignalTimes();
Lloyd Pique32cbe282018-10-19 13:09:22 -07002037 mPreviousPresentFence = displayDevice ? getHwComposer().getPresentFence(*displayDevice->getId())
2038 : Fence::NO_FENCE;
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07002039 auto presentFenceTime = std::make_shared<FenceTime>(mPreviousPresentFence);
David Sodman73beded2017-11-15 11:56:06 -08002040 getBE().mDisplayTimeline.push(presentFenceTime);
Brian Anderson3d4039d2016-09-23 16:31:30 -07002041
Ana Krulece588e312018-09-18 12:32:24 -07002042 DisplayStatInfo stats;
Ana Krulecc2870422019-01-29 19:00:58 -08002043 mScheduler->getDisplayStatInfo(&stats);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002044
David Sodman2b406362017-12-15 13:33:47 -08002045 // We use the mRefreshStartTime which might be sampled a little later than
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002046 // when we started doing work for this frame, but that should be okay
2047 // since updateCompositorTiming has snapping logic.
Ana Krulece588e312018-09-18 12:32:24 -07002048 updateCompositorTiming(stats, mRefreshStartTime, presentFenceTime);
Brian Andersond0010582017-03-07 13:20:31 -08002049 CompositorTiming compositorTiming;
2050 {
David Sodman99974d22017-11-28 12:04:33 -08002051 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
2052 compositorTiming = getBE().mCompositorTiming;
Brian Andersond0010582017-03-07 13:20:31 -08002053 }
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002054
Robert Carr2047fae2016-11-28 14:09:09 -08002055 mDrawingState.traverseInZOrder([&](Layer* layer) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07002056 bool frameLatched =
2057 layer->onPostComposition(displayDevice->getId(), glCompositionDoneFenceTime,
2058 presentFenceTime, compositorTiming);
Dan Stozae77c7662016-05-13 11:37:28 -07002059 if (frameLatched) {
Robert Carr2047fae2016-11-28 14:09:09 -08002060 recordBufferingStats(layer->getName().string(),
2061 layer->getOccupancyHistory(false));
Dan Stozae77c7662016-05-13 11:37:28 -07002062 }
Robert Carr2047fae2016-11-28 14:09:09 -08002063 });
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002064
Brian Andersonfbc80ae2017-05-26 16:23:54 -07002065 if (presentFenceTime->isValid()) {
Ana Krulecc2870422019-01-29 19:00:58 -08002066 mScheduler->addPresentFence(presentFenceTime);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07002067 }
2068
Fabien Sanglardcbf153b2017-03-10 17:57:12 -08002069 if (!hasSyncFramework) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07002070 if (displayDevice && getHwComposer().isConnected(*displayDevice->getId()) &&
2071 displayDevice->isPoweredOn()) {
Ana Krulecc2870422019-01-29 19:00:58 -08002072 mScheduler->enableHardwareVsync();
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07002073 }
2074 }
2075
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002076 if (mAnimCompositionPending) {
2077 mAnimCompositionPending = false;
2078
Brian Anderson4e606e32017-03-16 15:34:57 -07002079 if (presentFenceTime->isValid()) {
Brian Anderson3d4039d2016-09-23 16:31:30 -07002080 mAnimFrameTracker.setActualPresentFence(
Brian Anderson4e606e32017-03-16 15:34:57 -07002081 std::move(presentFenceTime));
Lloyd Pique32cbe282018-10-19 13:09:22 -07002082 } else if (displayDevice && getHwComposer().isConnected(*displayDevice->getId())) {
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002083 // The HWC doesn't support present fences, so use the refresh
2084 // timestamp instead.
Lloyd Pique32cbe282018-10-19 13:09:22 -07002085 const nsecs_t presentTime =
2086 getHwComposer().getRefreshTimestamp(*displayDevice->getId());
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002087 mAnimFrameTracker.setActualPresentTime(presentTime);
2088 }
2089 mAnimFrameTracker.advanceFrame();
2090 }
Dan Stozab90cf072015-03-05 11:05:59 -08002091
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002092 mTimeStats->incrementTotalFrames();
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07002093 if (mHadClientComposition) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002094 mTimeStats->incrementClientCompositionFrames();
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07002095 }
2096
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002097 mTimeStats->setPresentFenceGlobal(presentFenceTime);
Yiwei Zhangce6ebc02018-10-20 12:42:38 -07002098
Lloyd Pique32cbe282018-10-19 13:09:22 -07002099 if (displayDevice && getHwComposer().isConnected(*displayDevice->getId()) &&
2100 !displayDevice->isPoweredOn()) {
Dan Stozab90cf072015-03-05 11:05:59 -08002101 return;
2102 }
2103
2104 nsecs_t currentTime = systemTime();
2105 if (mHasPoweredOff) {
2106 mHasPoweredOff = false;
2107 } else {
David Sodman4a36e932017-11-07 14:29:47 -08002108 nsecs_t elapsedTime = currentTime - getBE().mLastSwapTime;
Ana Krulece588e312018-09-18 12:32:24 -07002109 size_t numPeriods = static_cast<size_t>(elapsedTime / stats.vsyncPeriod);
David Sodman4a36e932017-11-07 14:29:47 -08002110 if (numPeriods < SurfaceFlingerBE::NUM_BUCKETS - 1) {
2111 getBE().mFrameBuckets[numPeriods] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002112 } else {
David Sodman4a36e932017-11-07 14:29:47 -08002113 getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002114 }
David Sodman4a36e932017-11-07 14:29:47 -08002115 getBE().mTotalTime += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002116 }
David Sodman4a36e932017-11-07 14:29:47 -08002117 getBE().mLastSwapTime = currentTime;
Dan Stoza436ccf32018-06-21 12:10:12 -07002118
2119 {
2120 std::lock_guard lock(mTexturePoolMutex);
2121 const size_t refillCount = mTexturePoolSize - mTexturePool.size();
2122 if (refillCount > 0) {
2123 const size_t offset = mTexturePool.size();
2124 mTexturePool.resize(mTexturePoolSize);
2125 getRenderEngine().genTextures(refillCount, mTexturePool.data() + offset);
2126 ATRACE_INT("TexturePoolSize", mTexturePool.size());
2127 }
2128 }
Marissa Walle2ffb422018-10-12 11:33:52 -07002129
Marissa Wallfda30bb2018-10-12 11:34:28 -07002130 mTransactionCompletedThread.addPresentFence(mPreviousPresentFence);
Marissa Walle2ffb422018-10-12 11:33:52 -07002131 mTransactionCompletedThread.sendCallbacks();
Ady Abraham8164d482019-01-11 14:47:59 -08002132
Kevin DuBois413287f2019-02-25 08:46:47 -08002133 if (mLumaSampling && mRegionSamplingThread) {
2134 mRegionSamplingThread->notifyNewContent();
Dan Stozaec460082018-12-17 15:35:09 -08002135 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07002136}
2137
Vishnu Nair4351ad52019-02-11 14:13:02 -08002138void SurfaceFlinger::computeLayerBounds() {
2139 for (const auto& pair : mDisplays) {
2140 const auto& displayDevice = pair.second;
2141 const auto display = displayDevice->getCompositionDisplay();
2142 for (const auto& layer : mDrawingState.layersSortedByZ) {
2143 // only consider the layers on the given layer stack
2144 if (!display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
Vishnu Nair01ace762019-02-12 14:25:24 -08002145 continue;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002146 }
2147
2148 layer->computeBounds(displayDevice->getViewport().toFloatRect(), ui::Transform());
2149 }
2150 }
2151}
2152
Mathias Agopiancd60f992012-08-16 16:28:27 -07002153void SurfaceFlinger::rebuildLayerStacks() {
Dan Stoza9e56aa02015-11-02 13:00:03 -08002154 ATRACE_CALL();
2155 ALOGV("rebuildLayerStacks");
2156
Mathias Agopiancd60f992012-08-16 16:28:27 -07002157 // rebuild the visible layer list per screen
Jeff Sharkey76488112017-02-27 14:15:18 -07002158 if (CC_UNLIKELY(mVisibleRegionsDirty)) {
Siarhei Vishniakoufc2589e2017-09-21 15:35:13 -07002159 ATRACE_NAME("rebuildLayerStacks VR Dirty");
Jeff Sharkey76488112017-02-27 14:15:18 -07002160 mVisibleRegionsDirty = false;
2161 invalidateHwcGeometry();
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002162
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002163 for (const auto& pair : mDisplays) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07002164 const auto& displayDevice = pair.second;
2165 auto display = displayDevice->getCompositionDisplay();
2166 const auto& displayState = display->getState();
Jeff Sharkey76488112017-02-27 14:15:18 -07002167 Region opaqueRegion;
2168 Region dirtyRegion;
Lloyd Piquecc01a452018-12-04 17:24:00 -08002169 compositionengine::Output::OutputLayers layersSortedByZ;
2170 Vector<sp<Layer>> deprecated_layersSortedByZ;
Chia-I Wu83806892017-11-16 10:50:20 -08002171 Vector<sp<Layer>> layersNeedingFences;
Lloyd Pique32cbe282018-10-19 13:09:22 -07002172 const ui::Transform& tr = displayState.transform;
2173 const Rect bounds = displayState.bounds;
2174 if (displayState.isEnabled) {
2175 computeVisibleRegions(displayDevice, dirtyRegion, opaqueRegion);
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002176
Jeff Sharkey76488112017-02-27 14:15:18 -07002177 mDrawingState.traverseInZOrder([&](Layer* layer) {
Lloyd Piquecc01a452018-12-04 17:24:00 -08002178 auto compositionLayer = layer->getCompositionLayer();
2179 if (compositionLayer == nullptr) {
2180 return;
2181 }
2182
Lloyd Pique32cbe282018-10-19 13:09:22 -07002183 const auto displayId = displayDevice->getId();
Lloyd Piquecc01a452018-12-04 17:24:00 -08002184 sp<compositionengine::LayerFE> layerFE = compositionLayer->getLayerFE();
2185 LOG_ALWAYS_FATAL_IF(layerFE.get() == nullptr);
2186
Lloyd Pique07e33212018-12-18 16:33:37 -08002187 bool needsOutputLayer = false;
2188
Lloyd Piqueef36b002019-01-23 17:52:04 -08002189 if (display->belongsInOutput(layer->getLayerStack(),
2190 layer->getPrimaryDisplayOnly())) {
Jeff Sharkey76488112017-02-27 14:15:18 -07002191 Region drawRegion(tr.transform(
2192 layer->visibleNonTransparentRegion));
2193 drawRegion.andSelf(bounds);
2194 if (!drawRegion.isEmpty()) {
Lloyd Pique07e33212018-12-18 16:33:37 -08002195 needsOutputLayer = true;
Jeff Sharkey76488112017-02-27 14:15:18 -07002196 }
Chia-I Wu83806892017-11-16 10:50:20 -08002197 }
2198
Lloyd Pique07e33212018-12-18 16:33:37 -08002199 if (needsOutputLayer) {
2200 layersSortedByZ.emplace_back(
2201 display->getOrCreateOutputLayer(displayId, compositionLayer,
2202 layerFE));
2203 deprecated_layersSortedByZ.add(layer);
2204
2205 auto& outputLayerState = layersSortedByZ.back()->editState();
2206 outputLayerState.visibleRegion =
2207 tr.transform(layer->visibleRegion.intersect(displayState.viewport));
2208 } else if (displayId) {
2209 // For layers that are being removed from a HWC display,
2210 // and that have queued frames, add them to a a list of
2211 // released layers so we can properly set a fence.
2212 bool hasExistingOutputLayer =
2213 display->getOutputLayerForLayer(compositionLayer.get()) != nullptr;
2214 bool hasQueuedFrames = std::find(mLayersWithQueuedFrames.cbegin(),
2215 mLayersWithQueuedFrames.cend(),
2216 layer) != mLayersWithQueuedFrames.cend();
2217
2218 if (hasExistingOutputLayer && hasQueuedFrames) {
Chia-I Wu83806892017-11-16 10:50:20 -08002219 layersNeedingFences.add(layer);
2220 }
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002221 }
Jeff Sharkey76488112017-02-27 14:15:18 -07002222 });
2223 }
Lloyd Piquecc01a452018-12-04 17:24:00 -08002224
2225 display->setOutputLayersOrderedByZ(std::move(layersSortedByZ));
2226
2227 displayDevice->setVisibleLayersSortedByZ(deprecated_layersSortedByZ);
Lloyd Pique32cbe282018-10-19 13:09:22 -07002228 displayDevice->setLayersNeedingFences(layersNeedingFences);
2229
2230 Region undefinedRegion{bounds};
2231 undefinedRegion.subtractSelf(tr.transform(opaqueRegion));
2232
2233 display->editState().undefinedRegion = undefinedRegion;
2234 display->editState().dirtyRegion.orSelf(dirtyRegion);
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002235 }
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002236 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07002237}
Mathias Agopian3b1d2b62012-07-11 13:48:17 -07002238
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002239// Returns a data space that fits all visible layers. The returned data space
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002240// can only be one of
Chia-I Wu7a28ecb2018-05-04 10:38:39 -07002241// - Dataspace::SRGB (use legacy dataspace and let HWC saturate when colors are enhanced)
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002242// - Dataspace::DISPLAY_P3
Valerie Hau9758ae02018-10-09 16:05:09 -07002243// - Dataspace::DISPLAY_BT2020
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002244// The returned HDR data space is one of
2245// - Dataspace::UNKNOWN
2246// - Dataspace::BT2020_HLG
2247// - Dataspace::BT2020_PQ
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002248Dataspace SurfaceFlinger::getBestDataspace(const sp<const DisplayDevice>& display,
2249 Dataspace* outHdrDataSpace) const {
Peiyong Lin14724e62018-12-05 07:27:30 -08002250 Dataspace bestDataSpace = Dataspace::V0_SRGB;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002251 *outHdrDataSpace = Dataspace::UNKNOWN;
2252
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002253 for (const auto& layer : display->getVisibleLayersSortedByZ()) {
Chia-I Wu01591c92018-05-22 12:03:00 -07002254 switch (layer->getDataSpace()) {
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002255 case Dataspace::V0_SCRGB:
2256 case Dataspace::V0_SCRGB_LINEAR:
Valerie Hau9758ae02018-10-09 16:05:09 -07002257 case Dataspace::BT2020:
2258 case Dataspace::BT2020_ITU:
2259 case Dataspace::BT2020_LINEAR:
2260 case Dataspace::DISPLAY_BT2020:
2261 bestDataSpace = Dataspace::DISPLAY_BT2020;
2262 break;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002263 case Dataspace::DISPLAY_P3:
Chia-I Wube02ec02018-05-18 10:59:36 -07002264 bestDataSpace = Dataspace::DISPLAY_P3;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002265 break;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002266 case Dataspace::BT2020_PQ:
2267 case Dataspace::BT2020_ITU_PQ:
Peiyong Linf6eb7662019-02-05 15:39:15 -08002268 bestDataSpace = Dataspace::DISPLAY_P3;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002269 *outHdrDataSpace = Dataspace::BT2020_PQ;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002270 break;
Peiyong Linf59a7192018-04-25 11:19:31 -07002271 case Dataspace::BT2020_HLG:
2272 case Dataspace::BT2020_ITU_HLG:
Peiyong Linf6eb7662019-02-05 15:39:15 -08002273 bestDataSpace = Dataspace::DISPLAY_P3;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002274 // When there's mixed PQ content and HLG content, we set the HDR
2275 // data space to be BT2020_PQ and convert HLG to PQ.
2276 if (*outHdrDataSpace == Dataspace::UNKNOWN) {
2277 *outHdrDataSpace = Dataspace::BT2020_HLG;
Peiyong Linf59a7192018-04-25 11:19:31 -07002278 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002279 break;
2280 default:
2281 break;
2282 }
Romain Guy54f154a2017-10-24 21:40:32 +01002283 }
2284
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002285 return bestDataSpace;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06002286}
2287
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002288// Pick the ColorMode / Dataspace for the display device.
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002289void SurfaceFlinger::pickColorMode(const sp<DisplayDevice>& display, ColorMode* outMode,
2290 Dataspace* outDataSpace, RenderIntent* outRenderIntent) const {
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002291 if (mDisplayColorSetting == DisplayColorSetting::UNMANAGED) {
2292 *outMode = ColorMode::NATIVE;
2293 *outDataSpace = Dataspace::UNKNOWN;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002294 *outRenderIntent = RenderIntent::COLORIMETRIC;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002295 return;
Chia-I Wu5c6e4632018-01-11 08:54:38 -08002296 }
Romain Guy88d37dd2017-05-26 17:57:05 -07002297
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002298 Dataspace hdrDataSpace;
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002299 Dataspace bestDataSpace = getBestDataspace(display, &hdrDataSpace);
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002300
Lloyd Pique3d0c02e2018-10-19 18:38:12 -07002301 auto* profile = display->getCompositionDisplay()->getDisplayColorProfile();
2302
Peiyong Lina3ea5592019-02-10 14:45:00 -08002303 switch (mForceColorMode) {
2304 case ColorMode::SRGB:
2305 bestDataSpace = Dataspace::V0_SRGB;
2306 break;
2307 case ColorMode::DISPLAY_P3:
2308 bestDataSpace = Dataspace::DISPLAY_P3;
2309 break;
2310 default:
2311 break;
2312 }
2313
Peiyong Lindfde5112018-06-05 10:58:41 -07002314 // respect hdrDataSpace only when there is no legacy HDR support
Lloyd Pique3d0c02e2018-10-19 18:38:12 -07002315 const bool isHdr =
2316 hdrDataSpace != Dataspace::UNKNOWN && !profile->hasLegacyHdrSupport(hdrDataSpace);
Chia-I Wuc4b08bd2018-05-29 12:57:23 -07002317 if (isHdr) {
2318 bestDataSpace = hdrDataSpace;
2319 }
2320
Chia-I Wu0d711262018-05-21 15:19:35 -07002321 RenderIntent intent;
2322 switch (mDisplayColorSetting) {
2323 case DisplayColorSetting::MANAGED:
2324 case DisplayColorSetting::UNMANAGED:
Chia-I Wuc4b08bd2018-05-29 12:57:23 -07002325 intent = isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC;
Chia-I Wu0d711262018-05-21 15:19:35 -07002326 break;
2327 case DisplayColorSetting::ENHANCED:
Chia-I Wuc4b08bd2018-05-29 12:57:23 -07002328 intent = isHdr ? RenderIntent::TONE_MAP_ENHANCE : RenderIntent::ENHANCE;
Chia-I Wu0d711262018-05-21 15:19:35 -07002329 break;
2330 default: // vendor display color setting
2331 intent = static_cast<RenderIntent>(mDisplayColorSetting);
2332 break;
2333 }
Chia-I Wube02ec02018-05-18 10:59:36 -07002334
Lloyd Pique3d0c02e2018-10-19 18:38:12 -07002335 profile->getBestColorMode(bestDataSpace, intent, outDataSpace, outMode, outRenderIntent);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06002336}
2337
Lloyd Pique32cbe282018-10-19 13:09:22 -07002338void SurfaceFlinger::beginFrame(const sp<DisplayDevice>& displayDevice) {
2339 auto display = displayDevice->getCompositionDisplay();
2340 const auto& displayState = display->getState();
2341
Alec Mourie7d1d4a2019-02-05 01:13:46 +00002342 bool dirty = !display->getDirtyRegion(false).isEmpty();
Lloyd Pique32cbe282018-10-19 13:09:22 -07002343 bool empty = displayDevice->getVisibleLayersSortedByZ().size() == 0;
2344 bool wasEmpty = !displayState.lastCompositionHadVisibleLayers;
David Sodman2b406362017-12-15 13:33:47 -08002345
David Sodmanfa9b2af2017-12-24 13:28:59 -08002346 // If nothing has changed (!dirty), don't recompose.
2347 // If something changed, but we don't currently have any visible layers,
2348 // and didn't when we last did a composition, then skip it this time.
2349 // The second rule does two things:
2350 // - When all layers are removed from a display, we'll emit one black
2351 // frame, then nothing more until we get new layers.
2352 // - When a display is created with a private layer stack, we won't
2353 // emit any black frames until a layer is added to the layer stack.
2354 bool mustRecompose = dirty && !(empty && wasEmpty);
David Sodman2b406362017-12-15 13:33:47 -08002355
Dominik Laskowski075d3172018-05-24 15:50:06 -07002356 const char flagPrefix[] = {'-', '+'};
2357 static_cast<void>(flagPrefix);
Lloyd Pique32cbe282018-10-19 13:09:22 -07002358 ALOGV_IF(displayDevice->isVirtual(), "%s: %s composition for %s (%cdirty %cempty %cwasEmpty)",
2359 __FUNCTION__, mustRecompose ? "doing" : "skipping",
2360 displayDevice->getDebugName().c_str(), flagPrefix[dirty], flagPrefix[empty],
2361 flagPrefix[wasEmpty]);
David Sodman2b406362017-12-15 13:33:47 -08002362
Lloyd Pique31cb2942018-10-19 17:23:03 -07002363 display->getRenderSurface()->beginFrame(mustRecompose);
David Sodman2b406362017-12-15 13:33:47 -08002364
David Sodmanfa9b2af2017-12-24 13:28:59 -08002365 if (mustRecompose) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07002366 display->editState().lastCompositionHadVisibleLayers = !empty;
David Sodman2b406362017-12-15 13:33:47 -08002367 }
2368}
2369
Lloyd Pique32cbe282018-10-19 13:09:22 -07002370void SurfaceFlinger::prepareFrame(const sp<DisplayDevice>& displayDevice) {
2371 auto display = displayDevice->getCompositionDisplay();
2372 const auto& displayState = display->getState();
2373
2374 if (!displayState.isEnabled) {
David Sodmanfa9b2af2017-12-24 13:28:59 -08002375 return;
David Sodman2b406362017-12-15 13:33:47 -08002376 }
David Sodmanfa9b2af2017-12-24 13:28:59 -08002377
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08002378 status_t result = display->getRenderSurface()->prepareFrame();
Dominik Laskowski075d3172018-05-24 15:50:06 -07002379 ALOGE_IF(result != NO_ERROR, "prepareFrame failed for %s: %d (%s)",
Lloyd Pique32cbe282018-10-19 13:09:22 -07002380 displayDevice->getDebugName().c_str(), result, strerror(-result));
David Sodman2b406362017-12-15 13:33:47 -08002381}
Mathias Agopian52bbb1a2012-07-31 19:01:53 -07002382
Lloyd Pique32cbe282018-10-19 13:09:22 -07002383void SurfaceFlinger::doComposition(const sp<DisplayDevice>& displayDevice, bool repaintEverything) {
Mathias Agopiancd60f992012-08-16 16:28:27 -07002384 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08002385 ALOGV("doComposition");
2386
Lloyd Pique32cbe282018-10-19 13:09:22 -07002387 auto display = displayDevice->getCompositionDisplay();
2388 const auto& displayState = display->getState();
2389
2390 if (displayState.isEnabled) {
David Sodmanfa9b2af2017-12-24 13:28:59 -08002391 // transform the dirty region into this screen's coordinate space
Alec Mourie7d1d4a2019-02-05 01:13:46 +00002392 const Region dirtyRegion = display->getDirtyRegion(repaintEverything);
Mathias Agopian02b95102012-11-05 17:50:57 -08002393
David Sodmanfa9b2af2017-12-24 13:28:59 -08002394 // repaint the framebuffer (if needed)
Lloyd Pique32cbe282018-10-19 13:09:22 -07002395 doDisplayComposition(displayDevice, dirtyRegion);
Mathias Agopian02b95102012-11-05 17:50:57 -08002396
Lloyd Pique32cbe282018-10-19 13:09:22 -07002397 display->editState().dirtyRegion.clear();
Lloyd Pique31cb2942018-10-19 17:23:03 -07002398 display->getRenderSurface()->flip();
Mathias Agopian4fec8732012-06-29 14:12:52 -07002399 }
Lloyd Pique32cbe282018-10-19 13:09:22 -07002400 postFramebuffer(displayDevice);
Mathias Agopian4fec8732012-06-29 14:12:52 -07002401}
2402
David Sodmanfa9b2af2017-12-24 13:28:59 -08002403void SurfaceFlinger::postFrame()
2404{
2405 // |mStateLock| not needed as we are on the main thread
Dominik Laskowski075d3172018-05-24 15:50:06 -07002406 const auto display = getDefaultDisplayDeviceLocked();
2407 if (display && getHwComposer().isConnected(*display->getId())) {
2408 uint32_t flipCount = display->getPageFlipCount();
David Sodmanfa9b2af2017-12-24 13:28:59 -08002409 if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
2410 logFrameStats();
2411 }
2412 }
2413}
2414
Lloyd Pique32cbe282018-10-19 13:09:22 -07002415void SurfaceFlinger::postFramebuffer(const sp<DisplayDevice>& displayDevice) {
Mathias Agopian841cde52012-03-01 15:44:37 -08002416 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08002417 ALOGV("postFramebuffer");
Mathias Agopianb048cef2012-02-04 15:44:04 -08002418
Lloyd Pique32cbe282018-10-19 13:09:22 -07002419 auto display = displayDevice->getCompositionDisplay();
2420 const auto& displayState = display->getState();
2421 const auto displayId = display->getId();
2422
David Sodmanfa9b2af2017-12-24 13:28:59 -08002423 mPostFramebufferTime = systemTime();
Jesse Hallc5c5a142012-07-02 16:49:28 -07002424
Lloyd Pique32cbe282018-10-19 13:09:22 -07002425 if (displayState.isEnabled) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002426 if (displayId) {
2427 getHwComposer().presentAndGetReleaseFences(*displayId);
Mathias Agopian2a231842012-09-24 18:12:35 -07002428 }
Lloyd Pique31cb2942018-10-19 17:23:03 -07002429 display->getRenderSurface()->onPresentDisplayCompleted();
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002430 for (auto& layer : display->getOutputLayersOrderedByZ()) {
Chia-I Wu0f509fb2018-06-21 15:52:50 +08002431 sp<Fence> releaseFence = Fence::NO_FENCE;
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002432 bool usedClientComposition = true;
David Sodman15094112018-10-11 09:39:37 -07002433
Chia-I Wu7b549592017-11-15 09:14:57 -08002434 // The layer buffer from the previous frame (if any) is released
2435 // by HWC only when the release fence from this frame (if any) is
2436 // signaled. Always get the release fence from HWC first.
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002437 if (layer->getState().hwc) {
2438 const auto& hwcState = *layer->getState().hwc;
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08002439 releaseFence =
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002440 getHwComposer().getLayerReleaseFence(*displayId, hwcState.hwcLayer.get());
2441 usedClientComposition =
2442 hwcState.hwcCompositionType == Hwc2::IComposerClient::Composition::CLIENT;
Chia-I Wu0f509fb2018-06-21 15:52:50 +08002443 }
Chia-I Wu7b549592017-11-15 09:14:57 -08002444
2445 // If the layer was client composited in the previous frame, we
2446 // need to merge with the previous client target acquire fence.
2447 // Since we do not track that, always merge with the current
2448 // client target acquire fence when it is available, even though
2449 // this is suboptimal.
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002450 if (usedClientComposition) {
Lloyd Pique31cb2942018-10-19 17:23:03 -07002451 releaseFence =
2452 Fence::merge("LayerRelease", releaseFence,
2453 display->getRenderSurface()->getClientTargetAcquireFence());
Mathias Agopian52bbb1a2012-07-31 19:01:53 -07002454 }
Chia-I Wu7b549592017-11-15 09:14:57 -08002455
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002456 layer->getLayerFE().onLayerDisplayed(releaseFence);
Dan Stoza9e56aa02015-11-02 13:00:03 -08002457 }
Chia-I Wu83806892017-11-16 10:50:20 -08002458
2459 // We've got a list of layers needing fences, that are disjoint with
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002460 // display->getVisibleLayersSortedByZ. The best we can do is to
Chia-I Wu83806892017-11-16 10:50:20 -08002461 // supply them with the present fence.
Lloyd Pique32cbe282018-10-19 13:09:22 -07002462 if (!displayDevice->getLayersNeedingFences().isEmpty()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002463 sp<Fence> presentFence =
Lloyd Pique441d5042018-10-18 16:49:51 -07002464 displayId ? getHwComposer().getPresentFence(*displayId) : Fence::NO_FENCE;
Lloyd Pique32cbe282018-10-19 13:09:22 -07002465 for (auto& layer : displayDevice->getLayersNeedingFences()) {
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002466 layer->getCompositionLayer()->getLayerFE()->onLayerDisplayed(presentFence);
Chia-I Wu83806892017-11-16 10:50:20 -08002467 }
2468 }
2469
Dominik Laskowski075d3172018-05-24 15:50:06 -07002470 if (displayId) {
2471 getHwComposer().clearReleaseFences(*displayId);
Jesse Hallef194142012-06-14 14:45:17 -07002472 }
Jamie Gennise8696a42012-01-15 18:54:57 -08002473 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002474}
2475
Mathias Agopian87baae12012-07-31 12:38:26 -07002476void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002477{
Mathias Agopian841cde52012-03-01 15:44:37 -08002478 ATRACE_CALL();
2479
Mathias Agopian7cc6df52013-06-05 14:30:54 -07002480 // here we keep a copy of the drawing state (that is the state that's
2481 // going to be overwritten by handleTransactionLocked()) outside of
2482 // mStateLock so that the side-effects of the State assignment
2483 // don't happen with mStateLock held (which can cause deadlocks).
2484 State drawingState(mDrawingState);
2485
Mathias Agopianca4d3602011-05-19 15:38:14 -07002486 Mutex::Autolock _l(mStateLock);
2487 const nsecs_t now = systemTime();
2488 mDebugInTransaction = now;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002489
Mathias Agopianca4d3602011-05-19 15:38:14 -07002490 // Here we're guaranteed that some transaction flags are set
2491 // so we can call handleTransactionLocked() unconditionally.
2492 // We call getTransactionFlags(), which will also clear the flags,
2493 // with mStateLock held to guarantee that mCurrentState won't change
2494 // until the transaction is committed.
Mathias Agopian4da75192010-08-10 17:19:56 -07002495
Jorim Jaggif15c3be2018-04-12 12:56:58 +01002496 mVsyncModulator.onTransactionHandled();
Mathias Agopiane57f2922012-08-09 16:29:12 -07002497 transactionFlags = getTransactionFlags(eTransactionMask);
Mathias Agopian87baae12012-07-31 12:38:26 -07002498 handleTransactionLocked(transactionFlags);
Mathias Agopiandea20b12011-05-03 17:04:02 -07002499
Mathias Agopianca4d3602011-05-19 15:38:14 -07002500 mLastTransactionTime = systemTime() - now;
2501 mDebugInTransaction = 0;
2502 invalidateHwcGeometry();
2503 // here the transaction has been committed
Mathias Agopian3d579642009-06-04 18:46:21 -07002504}
2505
Lloyd Piqueba04e622017-12-14 17:11:26 -08002506void SurfaceFlinger::processDisplayHotplugEventsLocked() {
2507 for (const auto& event : mPendingHotplugEvents) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002508 const std::optional<DisplayIdentificationInfo> info =
2509 getHwComposer().onHotplug(event.hwcDisplayId, event.connection);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002510
Dominik Laskowski075d3172018-05-24 15:50:06 -07002511 if (!info) {
Lloyd Piqueba04e622017-12-14 17:11:26 -08002512 continue;
2513 }
2514
Lloyd Piqueba04e622017-12-14 17:11:26 -08002515 if (event.connection == HWC2::Connection::Connected) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002516 if (!mPhysicalDisplayTokens.count(info->id)) {
Dominik Laskowski34157762018-10-31 13:07:19 -07002517 ALOGV("Creating display %s", to_string(info->id).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07002518 mPhysicalDisplayTokens[info->id] = new BBinder();
2519 DisplayDeviceState state;
2520 state.displayId = info->id;
2521 state.isSecure = true; // All physical displays are currently considered secure.
2522 state.displayName = info->name;
2523 mCurrentState.displays.add(mPhysicalDisplayTokens[info->id], state);
2524 mInterceptor->saveDisplayCreation(state);
Arthur Hungf8b7d1f2019-03-22 16:10:56 +08002525 // TODO(b/123715322): Removes the per-display state that was added to the scheduler.
2526 mRefreshRateConfigs[info->id] = std::make_shared<scheduler::RefreshRateConfigs>(
2527 getHwComposer().getConfigs(info->id));
Steven Thomaseb6d2052018-03-20 15:40:48 -07002528 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08002529 } else {
Dominik Laskowski34157762018-10-31 13:07:19 -07002530 ALOGV("Removing display %s", to_string(info->id).c_str());
Lloyd Piqueba04e622017-12-14 17:11:26 -08002531
Dominik Laskowski075d3172018-05-24 15:50:06 -07002532 ssize_t index = mCurrentState.displays.indexOfKey(mPhysicalDisplayTokens[info->id]);
2533 if (index >= 0) {
2534 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
2535 mInterceptor->saveDisplayDeletion(state.sequenceId);
2536 mCurrentState.displays.removeItemsAt(index);
Lloyd Piquefcd86612017-12-14 17:15:36 -08002537 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07002538 mPhysicalDisplayTokens.erase(info->id);
Arthur Hungf8b7d1f2019-03-22 16:10:56 +08002539 mRefreshRateConfigs.erase(info->id);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002540 }
2541
2542 processDisplayChangesLocked();
2543 }
2544
2545 mPendingHotplugEvents.clear();
2546}
2547
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002548void SurfaceFlinger::dispatchDisplayHotplugEvent(PhysicalDisplayId displayId, bool connected) {
Ana Krulecc2870422019-01-29 19:00:58 -08002549 mScheduler->hotplugReceived(mAppConnectionHandle, displayId, connected);
2550 mScheduler->hotplugReceived(mSfConnectionHandle, displayId, connected);
Dominik Laskowski1eba0202019-01-24 09:14:40 -08002551}
2552
Lloyd Pique99d3da52018-01-22 17:48:03 -08002553sp<DisplayDevice> SurfaceFlinger::setupNewDisplayDeviceInternal(
Dominik Laskowski075d3172018-05-24 15:50:06 -07002554 const wp<IBinder>& displayToken, const std::optional<DisplayId>& displayId,
Lloyd Pique542307f2018-10-19 13:24:08 -07002555 const DisplayDeviceState& state, const sp<compositionengine::DisplaySurface>& dispSurface,
Dominik Laskowski075d3172018-05-24 15:50:06 -07002556 const sp<IGraphicBufferProducer>& producer) {
2557 DisplayDeviceCreationArgs creationArgs(this, displayToken, displayId);
Dominik Laskowskie9774092018-12-11 10:04:24 -08002558 creationArgs.sequenceId = state.sequenceId;
Dominik Laskowski075d3172018-05-24 15:50:06 -07002559 creationArgs.isVirtual = state.isVirtual();
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002560 creationArgs.isSecure = state.isSecure;
2561 creationArgs.displaySurface = dispSurface;
2562 creationArgs.hasWideColorGamut = false;
2563 creationArgs.supportedPerFrameMetadata = 0;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002564
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002565 const bool isInternalDisplay = displayId && displayId == getInternalDisplayIdLocked();
Dominik Laskowski075d3172018-05-24 15:50:06 -07002566 creationArgs.isPrimary = isInternalDisplay;
2567
2568 if (useColorManagement && displayId) {
2569 std::vector<ColorMode> modes = getHwComposer().getColorModes(*displayId);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002570 for (ColorMode colorMode : modes) {
Peiyong Linfca547f2018-07-09 13:03:33 -07002571 if (isWideColorMode(colorMode)) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002572 creationArgs.hasWideColorGamut = true;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002573 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002574
Dominik Laskowski7e045462018-05-30 13:02:02 -07002575 std::vector<RenderIntent> renderIntents =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002576 getHwComposer().getRenderIntents(*displayId, colorMode);
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002577 creationArgs.hwcColorModes.emplace(colorMode, renderIntents);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002578 }
tangrobin6753a022018-08-10 10:58:54 +08002579 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002580
Dominik Laskowski075d3172018-05-24 15:50:06 -07002581 if (displayId) {
2582 getHwComposer().getHdrCapabilities(*displayId, &creationArgs.hdrCapabilities);
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002583 creationArgs.supportedPerFrameMetadata =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002584 getHwComposer().getSupportedPerFrameMetadata(*displayId);
Chia-I Wu0f509fb2018-06-21 15:52:50 +08002585 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002586
Lloyd Pique90c115d2018-09-18 21:39:42 -07002587 auto nativeWindowSurface = getFactory().createNativeWindowSurface(producer);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002588 auto nativeWindow = nativeWindowSurface->getNativeWindow();
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002589 creationArgs.nativeWindow = nativeWindow;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002590
Lloyd Pique99d3da52018-01-22 17:48:03 -08002591 // Make sure that composition can never be stalled by a virtual display
2592 // consumer that isn't processing buffers fast enough. We have to do this
Alec Mouri0a9c7b82018-11-16 13:05:25 -08002593 // here, in case the display is composed entirely by HWC.
Dominik Laskowski281644e2018-04-19 15:47:35 -07002594 if (state.isVirtual()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002595 nativeWindow->setSwapInterval(nativeWindow.get(), 0);
2596 }
2597
Dominik Laskowski075d3172018-05-24 15:50:06 -07002598 creationArgs.displayInstallOrientation =
2599 isInternalDisplay ? primaryDisplayOrientation : DisplayState::eOrientationDefault;
Chia-I Wua02871c2018-08-27 14:38:23 -07002600
Lloyd Pique99d3da52018-01-22 17:48:03 -08002601 // virtual displays are always considered enabled
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002602 creationArgs.initialPowerMode = state.isVirtual() ? HWC_POWER_MODE_NORMAL : HWC_POWER_MODE_OFF;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002603
Lloyd Pique90c115d2018-09-18 21:39:42 -07002604 sp<DisplayDevice> display = getFactory().createDisplayDevice(std::move(creationArgs));
Lloyd Pique99d3da52018-01-22 17:48:03 -08002605
2606 if (maxFrameBufferAcquiredBuffers >= 3) {
2607 nativeWindowSurface->preallocateBuffers();
2608 }
2609
2610 ColorMode defaultColorMode = ColorMode::NATIVE;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002611 Dataspace defaultDataSpace = Dataspace::UNKNOWN;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002612 if (display->hasWideColorGamut()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002613 defaultColorMode = ColorMode::SRGB;
Peiyong Lin14724e62018-12-05 07:27:30 -08002614 defaultDataSpace = Dataspace::V0_SRGB;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002615 }
Lloyd Pique32cbe282018-10-19 13:09:22 -07002616 display->getCompositionDisplay()->setColorMode(defaultColorMode, defaultDataSpace,
2617 RenderIntent::COLORIMETRIC);
Dominik Laskowski075d3172018-05-24 15:50:06 -07002618 if (!state.isVirtual()) {
2619 LOG_ALWAYS_FATAL_IF(!displayId);
2620 display->setActiveConfig(getHwComposer().getActiveConfigIndex(*displayId));
Lloyd Pique3c085a02018-05-09 19:38:32 -07002621 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07002622
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002623 display->setLayerStack(state.layerStack);
2624 display->setProjection(state.orientation, state.viewport, state.frame);
2625 display->setDisplayName(state.displayName);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002626
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002627 return display;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002628}
2629
Lloyd Pique347200f2017-12-14 17:00:15 -08002630void SurfaceFlinger::processDisplayChangesLocked() {
2631 // here we take advantage of Vector's copy-on-write semantics to
2632 // improve performance by skipping the transaction entirely when
2633 // know that the lists are identical
2634 const KeyedVector<wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
2635 const KeyedVector<wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
2636 if (!curr.isIdenticalTo(draw)) {
2637 mVisibleRegionsDirty = true;
2638 const size_t cc = curr.size();
2639 size_t dc = draw.size();
2640
2641 // find the displays that were removed
2642 // (ie: in drawing state but not in current state)
2643 // also handle displays that changed
2644 // (ie: displays that are in both lists)
2645 for (size_t i = 0; i < dc;) {
2646 const ssize_t j = curr.indexOfKey(draw.keyAt(i));
2647 if (j < 0) {
2648 // in drawing state but not in current state
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002649 if (const auto display = getDisplayDeviceLocked(draw.keyAt(i))) {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002650 // Save display ID before disconnecting.
2651 const auto displayId = display->getId();
Lloyd Pique45a165a2018-10-19 11:54:47 -07002652 display->disconnect();
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002653
2654 if (!display->isVirtual()) {
2655 LOG_ALWAYS_FATAL_IF(!displayId);
2656 dispatchDisplayHotplugEvent(displayId->value, false);
2657 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002658 }
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002659
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002660 mDisplays.erase(draw.keyAt(i));
Lloyd Pique347200f2017-12-14 17:00:15 -08002661 } else {
2662 // this display is in both lists. see if something changed.
2663 const DisplayDeviceState& state(curr[j]);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002664 const wp<IBinder>& displayToken = curr.keyAt(j);
Lloyd Pique347200f2017-12-14 17:00:15 -08002665 const sp<IBinder> state_binder = IInterface::asBinder(state.surface);
2666 const sp<IBinder> draw_binder = IInterface::asBinder(draw[i].surface);
2667 if (state_binder != draw_binder) {
2668 // changing the surface is like destroying and
2669 // recreating the DisplayDevice, so we just remove it
2670 // from the drawing state, so that it get re-added
2671 // below.
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002672 if (const auto display = getDisplayDeviceLocked(displayToken)) {
Lloyd Pique45a165a2018-10-19 11:54:47 -07002673 display->disconnect();
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002674 }
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002675 mDisplays.erase(displayToken);
Lloyd Pique347200f2017-12-14 17:00:15 -08002676 mDrawingState.displays.removeItemsAt(i);
2677 dc--;
2678 // at this point we must loop to the next item
2679 continue;
2680 }
2681
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002682 if (const auto display = getDisplayDeviceLocked(displayToken)) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002683 if (state.layerStack != draw[i].layerStack) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002684 display->setLayerStack(state.layerStack);
Lloyd Pique347200f2017-12-14 17:00:15 -08002685 }
2686 if ((state.orientation != draw[i].orientation) ||
2687 (state.viewport != draw[i].viewport) || (state.frame != draw[i].frame)) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002688 display->setProjection(state.orientation, state.viewport, state.frame);
Lloyd Pique347200f2017-12-14 17:00:15 -08002689 }
2690 if (state.width != draw[i].width || state.height != draw[i].height) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002691 display->setDisplaySize(state.width, state.height);
Lloyd Pique347200f2017-12-14 17:00:15 -08002692 }
2693 }
2694 }
2695 ++i;
2696 }
2697
2698 // find displays that were added
2699 // (ie: in current state but not in drawing state)
2700 for (size_t i = 0; i < cc; i++) {
2701 if (draw.indexOfKey(curr.keyAt(i)) < 0) {
2702 const DisplayDeviceState& state(curr[i]);
2703
Lloyd Pique542307f2018-10-19 13:24:08 -07002704 sp<compositionengine::DisplaySurface> dispSurface;
Lloyd Pique347200f2017-12-14 17:00:15 -08002705 sp<IGraphicBufferProducer> producer;
2706 sp<IGraphicBufferProducer> bqProducer;
2707 sp<IGraphicBufferConsumer> bqConsumer;
Lloyd Pique90c115d2018-09-18 21:39:42 -07002708 getFactory().createBufferQueue(&bqProducer, &bqConsumer, false);
Lloyd Pique347200f2017-12-14 17:00:15 -08002709
Dominik Laskowski075d3172018-05-24 15:50:06 -07002710 std::optional<DisplayId> displayId;
Dominik Laskowski663bd282018-04-19 15:26:54 -07002711 if (state.isVirtual()) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002712 // Virtual displays without a surface are dormant:
2713 // they have external state (layer stack, projection,
2714 // etc.) but no internal state (i.e. a DisplayDevice).
2715 if (state.surface != nullptr) {
2716 // Allow VR composer to use virtual displays.
Dominik Laskowski075d3172018-05-24 15:50:06 -07002717 if (mUseHwcVirtualDisplays || getHwComposer().isUsingVrComposer()) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002718 int width = 0;
2719 int status = state.surface->query(NATIVE_WINDOW_WIDTH, &width);
2720 ALOGE_IF(status != NO_ERROR, "Unable to query width (%d)", status);
2721 int height = 0;
2722 status = state.surface->query(NATIVE_WINDOW_HEIGHT, &height);
2723 ALOGE_IF(status != NO_ERROR, "Unable to query height (%d)", status);
2724 int intFormat = 0;
2725 status = state.surface->query(NATIVE_WINDOW_FORMAT, &intFormat);
2726 ALOGE_IF(status != NO_ERROR, "Unable to query format (%d)", status);
Peiyong Lin34beb7a2018-03-28 11:57:12 -07002727 auto format = static_cast<ui::PixelFormat>(intFormat);
Lloyd Pique347200f2017-12-14 17:00:15 -08002728
Dominik Laskowski075d3172018-05-24 15:50:06 -07002729 displayId =
2730 getHwComposer().allocateVirtualDisplay(width, height, &format);
Lloyd Pique347200f2017-12-14 17:00:15 -08002731 }
2732
2733 // TODO: Plumb requested format back up to consumer
2734
2735 sp<VirtualDisplaySurface> vds =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002736 new VirtualDisplaySurface(getHwComposer(), displayId, state.surface,
Lloyd Pique347200f2017-12-14 17:00:15 -08002737 bqProducer, bqConsumer,
2738 state.displayName);
2739
2740 dispSurface = vds;
2741 producer = vds;
2742 }
2743 } else {
2744 ALOGE_IF(state.surface != nullptr,
2745 "adding a supported display, but rendering "
2746 "surface is provided (%p), ignoring it",
2747 state.surface.get());
2748
Dominik Laskowski075d3172018-05-24 15:50:06 -07002749 displayId = state.displayId;
2750 LOG_ALWAYS_FATAL_IF(!displayId);
2751 dispSurface = new FramebufferSurface(getHwComposer(), *displayId, bqConsumer);
Lloyd Pique347200f2017-12-14 17:00:15 -08002752 producer = bqProducer;
2753 }
2754
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002755 const wp<IBinder>& displayToken = curr.keyAt(i);
Lloyd Pique347200f2017-12-14 17:00:15 -08002756 if (dispSurface != nullptr) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002757 mDisplays.emplace(displayToken,
Dominik Laskowski7e045462018-05-30 13:02:02 -07002758 setupNewDisplayDeviceInternal(displayToken, displayId, state,
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002759 dispSurface, producer));
Dominik Laskowski663bd282018-04-19 15:26:54 -07002760 if (!state.isVirtual()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002761 LOG_ALWAYS_FATAL_IF(!displayId);
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002762 dispatchDisplayHotplugEvent(displayId->value, true);
Lloyd Pique347200f2017-12-14 17:00:15 -08002763 }
2764 }
2765 }
2766 }
2767 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08002768
2769 mDrawingState.displays = mCurrentState.displays;
Lloyd Pique347200f2017-12-14 17:00:15 -08002770}
2771
Mathias Agopian87baae12012-07-31 12:38:26 -07002772void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
Mathias Agopian3d579642009-06-04 18:46:21 -07002773{
Dan Stoza7dde5992015-05-22 09:51:44 -07002774 // Notify all layers of available frames
Robert Carr2047fae2016-11-28 14:09:09 -08002775 mCurrentState.traverseInZOrder([](Layer* layer) {
2776 layer->notifyAvailableFrames();
2777 });
Dan Stoza7dde5992015-05-22 09:51:44 -07002778
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002779 /*
2780 * Traversal of the children
2781 * (perform the transaction for each of them if needed)
2782 */
2783
Marissa Wall06255332019-03-27 13:48:27 -07002784 if ((transactionFlags & eTraversalNeeded) || mTraversalNeededMainThread) {
Robert Carr2047fae2016-11-28 14:09:09 -08002785 mCurrentState.traverseInZOrder([&](Layer* layer) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002786 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
Robert Carr2047fae2016-11-28 14:09:09 -08002787 if (!trFlags) return;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002788
2789 const uint32_t flags = layer->doTransaction(0);
2790 if (flags & Layer::eVisibleRegion)
2791 mVisibleRegionsDirty = true;
Robert Carr720e5062018-07-30 17:45:14 -07002792
2793 if (flags & Layer::eInputInfoChanged) {
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002794 mInputInfoChanged = true;
Robert Carr720e5062018-07-30 17:45:14 -07002795 }
Robert Carr2047fae2016-11-28 14:09:09 -08002796 });
Marissa Wall06255332019-03-27 13:48:27 -07002797 mTraversalNeededMainThread = false;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002798 }
2799
2800 /*
Mathias Agopian3559b072012-08-15 13:46:03 -07002801 * Perform display own transactions if needed
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002802 */
2803
Mathias Agopiane57f2922012-08-09 16:29:12 -07002804 if (transactionFlags & eDisplayTransactionNeeded) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002805 processDisplayChangesLocked();
Lloyd Piqueba04e622017-12-14 17:11:26 -08002806 processDisplayHotplugEventsLocked();
Mathias Agopian3559b072012-08-15 13:46:03 -07002807 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002808
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002809 if (transactionFlags & (eDisplayLayerStackChanged|eDisplayTransactionNeeded)) {
Mathias Agopian84300952012-11-21 16:02:13 -08002810 // The transform hint might have changed for some layers
2811 // (either because a display has changed, or because a layer
2812 // as changed).
2813 //
2814 // Walk through all the layers in currentLayers,
2815 // and update their transform hint.
2816 //
2817 // If a layer is visible only on a single display, then that
2818 // display is used to calculate the hint, otherwise we use the
2819 // default display.
2820 //
2821 // NOTE: we do this here, rather than in rebuildLayerStacks() so that
2822 // the hint is set before we acquire a buffer from the surface texture.
2823 //
2824 // NOTE: layer transactions have taken place already, so we use their
2825 // drawing state. However, SurfaceFlinger's own transaction has not
2826 // happened yet, so we must use the current state layer list
2827 // (soon to become the drawing state list).
2828 //
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002829 sp<const DisplayDevice> hintDisplay;
Mathias Agopian84300952012-11-21 16:02:13 -08002830 uint32_t currentlayerStack = 0;
Robert Carr2047fae2016-11-28 14:09:09 -08002831 bool first = true;
2832 mCurrentState.traverseInZOrder([&](Layer* layer) {
Mathias Agopian84300952012-11-21 16:02:13 -08002833 // NOTE: we rely on the fact that layers are sorted by
2834 // layerStack first (so we don't have to traverse the list
2835 // of displays for every layer).
Robert Carr1f0a16a2016-10-24 16:27:39 -07002836 uint32_t layerStack = layer->getLayerStack();
Robert Carr2047fae2016-11-28 14:09:09 -08002837 if (first || currentlayerStack != layerStack) {
Mathias Agopian84300952012-11-21 16:02:13 -08002838 currentlayerStack = layerStack;
2839 // figure out if this layerstack is mirrored
2840 // (more than one display) if so, pick the default display,
2841 // if not, pick the only display it's on.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002842 hintDisplay = nullptr;
2843 for (const auto& [token, display] : mDisplays) {
Lloyd Piqueef36b002019-01-23 17:52:04 -08002844 if (display->getCompositionDisplay()
2845 ->belongsInOutput(layer->getLayerStack(),
2846 layer->getPrimaryDisplayOnly())) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002847 if (hintDisplay) {
2848 hintDisplay = nullptr;
Mathias Agopian84300952012-11-21 16:02:13 -08002849 break;
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002850 } else {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002851 hintDisplay = display;
Mathias Agopian84300952012-11-21 16:02:13 -08002852 }
2853 }
2854 }
2855 }
Chet Haase91d25932013-04-11 15:24:55 -07002856
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002857 if (!hintDisplay) {
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002858 // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
2859 // redraw after transform hint changes. See bug 8508397.
Robert Carr56a0b9a2017-12-04 16:06:13 -08002860
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002861 // could be null when this layer is using a layerStack
2862 // that is not visible on any display. Also can occur at
2863 // screen off/on times.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002864 hintDisplay = getDefaultDisplayDeviceLocked();
Mathias Agopian84300952012-11-21 16:02:13 -08002865 }
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002866
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002867 // could be null if there is no display available at all to get
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002868 // the transform hint from.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002869 if (hintDisplay) {
2870 layer->updateTransformHint(hintDisplay);
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08002871 }
Robert Carr2047fae2016-11-28 14:09:09 -08002872
2873 first = false;
2874 });
Mathias Agopian84300952012-11-21 16:02:13 -08002875 }
2876
2877
Mathias Agopian3559b072012-08-15 13:46:03 -07002878 /*
2879 * Perform our own transaction if needed
2880 */
Robert Carr1f0a16a2016-10-24 16:27:39 -07002881
2882 if (mLayersAdded) {
2883 mLayersAdded = false;
2884 // Layers have been added.
Mathias Agopian3559b072012-08-15 13:46:03 -07002885 mVisibleRegionsDirty = true;
2886 }
2887
2888 // some layers might have been removed, so
2889 // we need to update the regions they're exposing.
2890 if (mLayersRemoved) {
2891 mLayersRemoved = false;
2892 mVisibleRegionsDirty = true;
Robert Carr2047fae2016-11-28 14:09:09 -08002893 mDrawingState.traverseInZOrder([&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07002894 if (mLayersPendingRemoval.indexOf(layer) >= 0) {
Mathias Agopian3559b072012-08-15 13:46:03 -07002895 // this layer is not visible anymore
Robert Carr1f0a16a2016-10-24 16:27:39 -07002896 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002897 visibleReg.set(layer->getScreenBounds());
Chia-I Wuab0c3192017-08-01 11:29:00 -07002898 invalidateLayerStack(layer, visibleReg);
Mathias Agopian0aa758d2009-04-22 15:23:34 -07002899 }
Robert Carr2047fae2016-11-28 14:09:09 -08002900 });
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002901 }
2902
Vishnu Nairec0ab382019-02-13 15:32:56 -08002903 commitInputWindowCommands();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002904 commitTransaction();
Riley Andrews03414a12014-07-01 14:22:59 -07002905}
2906
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002907void SurfaceFlinger::updateInputFlinger() {
Robert Carr720e5062018-07-30 17:45:14 -07002908 ATRACE_CALL();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002909 if (!mInputFlinger) {
Vishnu Nairde19f852018-12-18 16:11:53 -08002910 return;
2911 }
2912
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002913 if (mVisibleRegionsDirty || mInputInfoChanged) {
2914 mInputInfoChanged = false;
2915 updateInputWindowInfo();
chaviw95ef3c42019-02-14 10:55:09 -08002916 } else if (mInputWindowCommands.syncInputWindows) {
2917 // If the caller requested to sync input windows, but there are no
2918 // changes to input windows, notify immediately.
2919 setInputWindowsFinished();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002920 }
2921
2922 executeInputWindowCommands();
2923}
2924
2925void SurfaceFlinger::updateInputWindowInfo() {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002926 std::vector<InputWindowInfo> inputHandles;
Robert Carr720e5062018-07-30 17:45:14 -07002927
2928 mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
2929 if (layer->hasInput()) {
Vishnu Nair51625fa2018-12-06 13:54:33 -08002930 // When calculating the screen bounds we ignore the transparent region since it may
2931 // result in an unwanted offset.
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002932 inputHandles.push_back(layer->fillInputInfo());
Robert Carr720e5062018-07-30 17:45:14 -07002933 }
2934 });
chaviw291d88a2019-02-14 10:33:58 -08002935
2936 mInputFlinger->setInputWindows(inputHandles,
2937 mInputWindowCommands.syncInputWindows ? mSetInputWindowsListener
2938 : nullptr);
Robert Carr720e5062018-07-30 17:45:14 -07002939}
2940
Vishnu Nairec0ab382019-02-13 15:32:56 -08002941void SurfaceFlinger::commitInputWindowCommands() {
2942 mInputWindowCommands.merge(mPendingInputWindowCommands);
2943 mPendingInputWindowCommands.clear();
2944}
2945
chaviwfbe5d9c2018-12-26 12:23:37 -08002946void SurfaceFlinger::executeInputWindowCommands() {
chaviwfbe5d9c2018-12-26 12:23:37 -08002947 for (const auto& transferTouchFocusCommand : mInputWindowCommands.transferTouchFocusCommands) {
2948 if (transferTouchFocusCommand.fromToken != nullptr &&
2949 transferTouchFocusCommand.toToken != nullptr &&
2950 transferTouchFocusCommand.fromToken != transferTouchFocusCommand.toToken) {
2951 mInputFlinger->transferTouchFocus(transferTouchFocusCommand.fromToken,
2952 transferTouchFocusCommand.toToken);
2953 }
2954 }
2955
2956 mInputWindowCommands.clear();
2957}
2958
Riley Andrews03414a12014-07-01 14:22:59 -07002959void SurfaceFlinger::updateCursorAsync()
2960{
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002961 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002962 if (!display->getId()) {
Riley Andrews03414a12014-07-01 14:22:59 -07002963 continue;
2964 }
Dan Stoza9e56aa02015-11-02 13:00:03 -08002965
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002966 for (auto& layer : display->getVisibleLayersSortedByZ()) {
2967 layer->updateCursorPosition(display);
Riley Andrews03414a12014-07-01 14:22:59 -07002968 }
2969 }
Mathias Agopian4fec8732012-06-29 14:12:52 -07002970}
2971
chaviw61626f22018-11-15 16:26:27 -08002972void SurfaceFlinger::latchAndReleaseBuffer(const sp<Layer>& layer) {
2973 if (layer->hasReadyFrame()) {
Robert Carra0629232019-02-07 15:28:54 -08002974 bool ignored = false;
Alec Mouri56e538f2019-01-14 15:22:01 -08002975 layer->latchBuffer(ignored, systemTime());
chaviw61626f22018-11-15 16:26:27 -08002976 }
2977 layer->releasePendingBuffer(systemTime());
2978}
2979
Mathias Agopian4fec8732012-06-29 14:12:52 -07002980void SurfaceFlinger::commitTransaction()
2981{
Steve Pfetsch598f6d52016-10-25 21:47:58 +00002982 if (!mLayersPendingRemoval.isEmpty()) {
Mathias Agopian4fec8732012-06-29 14:12:52 -07002983 // Notify removed layers now that they can't be drawn from
Robert Carr1f0a16a2016-10-24 16:27:39 -07002984 for (const auto& l : mLayersPendingRemoval) {
2985 recordBufferingStats(l->getName().string(),
2986 l->getOccupancyHistory(true));
Robert Carr2e102c92018-10-23 12:11:15 -07002987
Lloyd Pique07e33212018-12-18 16:33:37 -08002988 // Ensure any buffers set to display on any children are released.
Robert Carr2e102c92018-10-23 12:11:15 -07002989 if (l->isRemovedFromCurrentState()) {
Robert Carr6fb1a7e2018-12-11 12:07:25 -08002990 latchAndReleaseBuffer(l);
Robert Carr2e102c92018-10-23 12:11:15 -07002991 }
Mathias Agopian4fec8732012-06-29 14:12:52 -07002992 }
2993 mLayersPendingRemoval.clear();
2994 }
2995
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002996 // If this transaction is part of a window animation then the next frame
2997 // we composite should be considered an animation as well.
2998 mAnimCompositionPending = mAnimTransactionPending;
2999
Nataniel Borges2b796da2019-02-15 13:32:18 -08003000 withTracingLock([&]() {
3001 mDrawingState = mCurrentState;
3002 // clear the "changed" flags in current state
3003 mCurrentState.colorMatrixChanged = false;
Chia-I Wu28f320b2018-05-03 11:02:56 -07003004
Nataniel Borges2b796da2019-02-15 13:32:18 -08003005 mDrawingState.traverseInZOrder([](Layer* layer) { layer->commitChildList(); });
Robert Carr1f0a16a2016-10-24 16:27:39 -07003006 });
Nataniel Borges2b796da2019-02-15 13:32:18 -08003007
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003008 mTransactionPending = false;
3009 mAnimTransactionPending = false;
Mathias Agopian4fec8732012-06-29 14:12:52 -07003010 mTransactionCV.broadcast();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003011}
3012
Nataniel Borges2b796da2019-02-15 13:32:18 -08003013void SurfaceFlinger::withTracingLock(std::function<void()> lockedOperation) {
3014 if (mTracingEnabledChanged) {
3015 mTracingEnabled = mTracing.isEnabled();
3016 mTracingEnabledChanged = false;
3017 }
3018
3019 // Synchronize with Tracing thread
3020 std::unique_lock<std::mutex> lock;
3021 if (mTracingEnabled) {
3022 lock = std::unique_lock<std::mutex>(mDrawingStateLock);
3023 }
3024
3025 lockedOperation();
3026
3027 // Synchronize with Tracing thread
3028 if (mTracingEnabled) {
3029 lock.unlock();
3030 }
3031}
3032
Lloyd Pique32cbe282018-10-19 13:09:22 -07003033void SurfaceFlinger::computeVisibleRegions(const sp<const DisplayDevice>& displayDevice,
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003034 Region& outDirtyRegion, Region& outOpaqueRegion) {
Mathias Agopian841cde52012-03-01 15:44:37 -08003035 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08003036 ALOGV("computeVisibleRegions");
Mathias Agopian841cde52012-03-01 15:44:37 -08003037
Lloyd Pique32cbe282018-10-19 13:09:22 -07003038 auto display = displayDevice->getCompositionDisplay();
3039
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003040 Region aboveOpaqueLayers;
3041 Region aboveCoveredLayers;
3042 Region dirty;
3043
Mathias Agopian87baae12012-07-31 12:38:26 -07003044 outDirtyRegion.clear();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003045
Robert Carr2047fae2016-11-28 14:09:09 -08003046 mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08003047 // start with the whole surface at its current location
3048 const Layer::State& s(layer->getDrawingState());
3049
Jesse Hall01e29052013-02-19 16:13:35 -08003050 // only consider the layers on the given layer stack
Lloyd Piqueef36b002019-01-23 17:52:04 -08003051 if (!display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
Robert Carr2047fae2016-11-28 14:09:09 -08003052 return;
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003053 }
Mathias Agopian87baae12012-07-31 12:38:26 -07003054
Mathias Agopianab028732010-03-16 16:41:46 -07003055 /*
3056 * opaqueRegion: area of a surface that is fully opaque.
3057 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003058 Region opaqueRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07003059
3060 /*
3061 * visibleRegion: area of a surface that is visible on screen
3062 * and not fully transparent. This is essentially the layer's
3063 * footprint minus the opaque regions above it.
3064 * Areas covered by a translucent surface are considered visible.
3065 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003066 Region visibleRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07003067
3068 /*
3069 * coveredRegion: area of a surface that is covered by all
3070 * visible regions above it (which includes the translucent areas).
3071 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003072 Region coveredRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07003073
Jesse Halla8026d22012-09-25 13:25:04 -07003074 /*
3075 * transparentRegion: area of a surface that is hinted to be completely
3076 * transparent. This is only used to tell when the layer has no visible
3077 * non-transparent regions and can be removed from the layer list. It
3078 * does not affect the visibleRegion of this layer or any layers
3079 * beneath it. The hint may not be correct if apps don't respect the
3080 * SurfaceView restrictions (which, sadly, some don't).
3081 */
3082 Region transparentRegion;
3083
Mathias Agopianab028732010-03-16 16:41:46 -07003084
3085 // handle hidden surfaces by setting the visible region to empty
Mathias Agopianda27af92012-09-13 18:17:13 -07003086 if (CC_LIKELY(layer->isVisible())) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08003087 const bool translucent = !layer->isOpaque(s);
Vishnu Nair4351ad52019-02-11 14:13:02 -08003088 Rect bounds(layer->getScreenBounds());
Robert Carr720e5062018-07-30 17:45:14 -07003089
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003090 visibleRegion.set(bounds);
Peiyong Linefefaac2018-08-17 12:27:51 -07003091 ui::Transform tr = layer->getTransform();
Mathias Agopianab028732010-03-16 16:41:46 -07003092 if (!visibleRegion.isEmpty()) {
3093 // Remove the transparent area from the visible region
3094 if (translucent) {
Dan Stoza22f7fc42016-05-10 16:19:53 -07003095 if (tr.preserveRects()) {
3096 // transform the transparent region
Lloyd Pique0449b0f2018-12-20 16:23:45 -08003097 transparentRegion = tr.transform(layer->getActiveTransparentRegion(s));
Mathias Agopian4fec8732012-06-29 14:12:52 -07003098 } else {
Dan Stoza22f7fc42016-05-10 16:19:53 -07003099 // transformation too complex, can't do the
3100 // transparent region optimization.
3101 transparentRegion.clear();
Mathias Agopian4fec8732012-06-29 14:12:52 -07003102 }
Mathias Agopianab028732010-03-16 16:41:46 -07003103 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003104
Mathias Agopianab028732010-03-16 16:41:46 -07003105 // compute the opaque region
Robert Carr1f0a16a2016-10-24 16:27:39 -07003106 const int32_t layerOrientation = tr.getOrientation();
Jorim Jaggi039bbb82017-09-06 18:12:05 +02003107 if (layer->getAlpha() == 1.0f && !translucent &&
Lucas Dupin1b6531c2018-07-05 17:18:21 -07003108 layer->getRoundedCornerState().radius == 0.0f &&
Peiyong Linefefaac2018-08-17 12:27:51 -07003109 ((layerOrientation & ui::Transform::ROT_INVALID) == false)) {
Mathias Agopianab028732010-03-16 16:41:46 -07003110 // the opaque region is the layer's footprint
3111 opaqueRegion = visibleRegion;
3112 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003113 }
3114 }
3115
Robert Carre5f4f692018-01-12 13:12:28 -08003116 if (visibleRegion.isEmpty()) {
3117 layer->clearVisibilityRegions();
3118 return;
3119 }
3120
Mathias Agopianab028732010-03-16 16:41:46 -07003121 // Clip the covered region to the visible region
3122 coveredRegion = aboveCoveredLayers.intersect(visibleRegion);
3123
3124 // Update aboveCoveredLayers for next (lower) layer
3125 aboveCoveredLayers.orSelf(visibleRegion);
3126
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003127 // subtract the opaque region covered by the layers above us
3128 visibleRegion.subtractSelf(aboveOpaqueLayers);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003129
3130 // compute this layer's dirty region
3131 if (layer->contentDirty) {
3132 // we need to invalidate the whole region
3133 dirty = visibleRegion;
3134 // as well, as the old visible region
Mathias Agopian4fec8732012-06-29 14:12:52 -07003135 dirty.orSelf(layer->visibleRegion);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003136 layer->contentDirty = false;
3137 } else {
Mathias Agopiana8d44f72009-06-28 02:54:16 -07003138 /* compute the exposed region:
Mathias Agopianab028732010-03-16 16:41:46 -07003139 * the exposed region consists of two components:
3140 * 1) what's VISIBLE now and was COVERED before
3141 * 2) what's EXPOSED now less what was EXPOSED before
3142 *
3143 * note that (1) is conservative, we start with the whole
3144 * visible region but only keep what used to be covered by
3145 * something -- which mean it may have been exposed.
3146 *
3147 * (2) handles areas that were not covered by anything but got
3148 * exposed because of a resize.
Mathias Agopiana8d44f72009-06-28 02:54:16 -07003149 */
Mathias Agopianab028732010-03-16 16:41:46 -07003150 const Region newExposed = visibleRegion - coveredRegion;
Mathias Agopian4fec8732012-06-29 14:12:52 -07003151 const Region oldVisibleRegion = layer->visibleRegion;
3152 const Region oldCoveredRegion = layer->coveredRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07003153 const Region oldExposed = oldVisibleRegion - oldCoveredRegion;
3154 dirty = (visibleRegion&oldCoveredRegion) | (newExposed-oldExposed);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003155 }
3156 dirty.subtractSelf(aboveOpaqueLayers);
3157
3158 // accumulate to the screen dirty region
Mathias Agopian87baae12012-07-31 12:38:26 -07003159 outDirtyRegion.orSelf(dirty);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003160
Mathias Agopianab028732010-03-16 16:41:46 -07003161 // Update aboveOpaqueLayers for next (lower) layer
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003162 aboveOpaqueLayers.orSelf(opaqueRegion);
Andreas Huber8b42e8a2010-08-16 08:49:37 -07003163
Jesse Halla8026d22012-09-25 13:25:04 -07003164 // Store the visible region in screen space
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003165 layer->setVisibleRegion(visibleRegion);
3166 layer->setCoveredRegion(coveredRegion);
Jesse Halla8026d22012-09-25 13:25:04 -07003167 layer->setVisibleNonTransparentRegion(
3168 visibleRegion.subtract(transparentRegion));
Robert Carr2047fae2016-11-28 14:09:09 -08003169 });
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003170
Mathias Agopian87baae12012-07-31 12:38:26 -07003171 outOpaqueRegion = aboveOpaqueLayers;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003172}
3173
Chia-I Wuab0c3192017-08-01 11:29:00 -07003174void SurfaceFlinger::invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003175 for (const auto& [token, displayDevice] : mDisplays) {
3176 auto display = displayDevice->getCompositionDisplay();
Lloyd Piqueef36b002019-01-23 17:52:04 -08003177 if (display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003178 display->editState().dirtyRegion.orSelf(dirty);
Mathias Agopian92a979a2012-08-02 18:32:23 -07003179 }
3180 }
Mathias Agopian87baae12012-07-31 12:38:26 -07003181}
3182
Dan Stoza6b9454d2014-11-07 16:00:59 -08003183bool SurfaceFlinger::handlePageFlip()
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003184{
Dan Stoza9e56aa02015-11-02 13:00:03 -08003185 ALOGV("handlePageFlip");
3186
Brian Andersond6927fb2016-07-23 23:37:30 -07003187 nsecs_t latchTime = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003188
Mathias Agopian4fec8732012-06-29 14:12:52 -07003189 bool visibleRegions = false;
Dan Stoza6b9454d2014-11-07 16:00:59 -08003190 bool frameQueued = false;
Mike Stroyan0cd76192017-04-20 12:10:48 -06003191 bool newDataLatched = false;
Eric Penner51c59cd2014-07-28 19:51:58 -07003192
3193 // Store the set of layers that need updates. This set must not change as
3194 // buffers are being latched, as this could result in a deadlock.
3195 // Example: Two producers share the same command stream and:
3196 // 1.) Layer 0 is latched
3197 // 2.) Layer 0 gets a new frame
3198 // 2.) Layer 1 gets a new frame
3199 // 3.) Layer 1 is latched.
3200 // Display is now waiting on Layer 1's frame, which is behind layer 0's
3201 // second frame. But layer 0's second frame could be waiting on display.
Robert Carr2047fae2016-11-28 14:09:09 -08003202 mDrawingState.traverseInZOrder([&](Layer* layer) {
Marissa Wallfd668622018-05-10 10:21:13 -07003203 if (layer->hasReadyFrame()) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08003204 frameQueued = true;
Ady Abrahamc3e21312019-02-07 14:30:23 -08003205 nsecs_t expectedPresentTime;
Ana Krulecc2870422019-01-29 19:00:58 -08003206 expectedPresentTime = mScheduler->expectedPresentTime();
Ana Krulec010d2192018-10-08 06:29:54 -07003207 if (layer->shouldPresentNow(expectedPresentTime)) {
Robert Carr2047fae2016-11-28 14:09:09 -08003208 mLayersWithQueuedFrames.push_back(layer);
Dan Stozaee44edd2015-03-23 15:50:23 -07003209 } else {
3210 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08003211 }
Dan Stozaee44edd2015-03-23 15:50:23 -07003212 } else {
3213 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08003214 }
Robert Carr2047fae2016-11-28 14:09:09 -08003215 });
3216
Lloyd Piquef2c79392018-12-20 16:23:33 -08003217 if (!mLayersWithQueuedFrames.empty()) {
3218 // mStateLock is needed for latchBuffer as LayerRejecter::reject()
3219 // writes to Layer current state. See also b/119481871
3220 Mutex::Autolock lock(mStateLock);
3221
3222 for (auto& layer : mLayersWithQueuedFrames) {
Alec Mouri56e538f2019-01-14 15:22:01 -08003223 if (layer->latchBuffer(visibleRegions, latchTime)) {
Vishnu Nair6194e2e2019-02-06 12:58:39 -08003224 mLayersPendingRefresh.push_back(layer);
3225 }
Lloyd Piquef2c79392018-12-20 16:23:33 -08003226 layer->useSurfaceDamage();
Lloyd Piquef2c79392018-12-20 16:23:33 -08003227 if (layer->isBufferLatched()) {
3228 newDataLatched = true;
3229 }
Mike Stroyan0cd76192017-04-20 12:10:48 -06003230 }
Mathias Agopian4fec8732012-06-29 14:12:52 -07003231 }
Mathias Agopian4da75192010-08-10 17:19:56 -07003232
Mathias Agopian3b1d2b62012-07-11 13:48:17 -07003233 mVisibleRegionsDirty |= visibleRegions;
Dan Stoza6b9454d2014-11-07 16:00:59 -08003234
3235 // If we will need to wake up at some time in the future to deal with a
3236 // queued frame that shouldn't be displayed during this vsync period, wake
3237 // up during the next vsync period to check again.
Chia-I Wua36bf922017-06-30 12:51:05 -07003238 if (frameQueued && (mLayersWithQueuedFrames.empty() || !newDataLatched)) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08003239 signalLayerUpdate();
3240 }
3241
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08003242 // enter boot animation on first buffer latch
3243 if (CC_UNLIKELY(mBootStage == BootStage::BOOTLOADER && newDataLatched)) {
3244 ALOGI("Enter boot animation");
3245 mBootStage = BootStage::BOOTANIMATION;
3246 }
3247
Dan Stoza6b9454d2014-11-07 16:00:59 -08003248 // Only continue with the refresh if there is actually new work to do
Mike Stroyan0cd76192017-04-20 12:10:48 -06003249 return !mLayersWithQueuedFrames.empty() && newDataLatched;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003250}
3251
Mathias Agopianad456f92011-01-13 17:53:01 -08003252void SurfaceFlinger::invalidateHwcGeometry()
3253{
Dan Stoza9e56aa02015-11-02 13:00:03 -08003254 mGeometryInvalid = true;
Mathias Agopianad456f92011-01-13 17:53:01 -08003255}
3256
Lloyd Pique32cbe282018-10-19 13:09:22 -07003257void SurfaceFlinger::doDisplayComposition(const sp<DisplayDevice>& displayDevice,
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003258 const Region& inDirtyRegion) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003259 auto display = displayDevice->getCompositionDisplay();
Dan Stoza71433162014-02-04 16:22:36 -08003260 // We only need to actually compose the display if:
3261 // 1) It is being handled by hardware composer, which may need this to
3262 // keep its virtual display state machine in sync, or
3263 // 2) There is work to be done (the dirty region isn't empty)
Lloyd Pique32cbe282018-10-19 13:09:22 -07003264 if (!displayDevice->getId() && inDirtyRegion.isEmpty()) {
Dan Stoza9e56aa02015-11-02 13:00:03 -08003265 ALOGV("Skipping display composition");
Dan Stoza71433162014-02-04 16:22:36 -08003266 return;
3267 }
3268
Dan Stoza9e56aa02015-11-02 13:00:03 -08003269 ALOGV("doDisplayComposition");
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003270 base::unique_fd readyFence;
3271 if (!doComposeSurfaces(displayDevice, Region::INVALID_REGION, &readyFence)) return;
Mathias Agopianda27af92012-09-13 18:17:13 -07003272
3273 // swap buffers (presentation)
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003274 display->getRenderSurface()->queueBuffer(std::move(readyFence));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003275}
3276
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003277bool SurfaceFlinger::doComposeSurfaces(const sp<DisplayDevice>& displayDevice,
3278 const Region& debugRegion, base::unique_fd* readyFence) {
Alec Mouri820c7402019-01-23 13:02:39 -08003279 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08003280 ALOGV("doComposeSurfaces");
Mathias Agopiancd20eb02011-09-22 20:57:04 -07003281
Lloyd Pique32cbe282018-10-19 13:09:22 -07003282 auto display = displayDevice->getCompositionDisplay();
3283 const auto& displayState = display->getState();
Dominik Laskowski7e045462018-05-30 13:02:02 -07003284 const auto displayId = display->getId();
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08003285 auto& renderEngine = getRenderEngine();
3286 const bool supportProtectedContent =
3287 mDebugEnableProtectedContent && renderEngine.supportsProtectedContent();
Lloyd Pique32cbe282018-10-19 13:09:22 -07003288
3289 const Region bounds(displayState.bounds);
3290 const DisplayRenderArea renderArea(displayDevice);
Lloyd Pique441d5042018-10-18 16:49:51 -07003291 const bool hasClientComposition = getHwComposer().hasClientComposition(displayId);
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08003292 ATRACE_INT("hasClientComposition", hasClientComposition);
Dan Stoza9f26a9c2016-06-22 14:51:09 -07003293
Peiyong Lind3788632018-09-18 16:01:31 -07003294 mat4 colorMatrix;
Chia-I Wu8e50e692018-05-04 10:12:37 -07003295 bool applyColorMatrix = false;
Dan Stoza9f26a9c2016-06-22 14:51:09 -07003296
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003297 renderengine::DisplaySettings clientCompositionDisplay;
3298 std::vector<renderengine::LayerSettings> clientCompositionLayers;
3299 sp<GraphicBuffer> buf;
Alec Mouri6338c9d2019-02-07 16:57:51 -08003300 base::unique_fd fd;
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003301
Dan Stoza9e56aa02015-11-02 13:00:03 -08003302 if (hasClientComposition) {
3303 ALOGV("hasClientComposition");
3304
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08003305 if (displayDevice->isPrimary() && supportProtectedContent) {
3306 bool needsProtected = false;
3307 for (auto& layer : displayDevice->getVisibleLayersSortedByZ()) {
3308 // If the layer is a protected layer, mark protected context is needed.
3309 if (layer->isProtected()) {
3310 needsProtected = true;
3311 break;
3312 }
3313 }
3314 if (needsProtected != renderEngine.isProtected() &&
3315 renderEngine.useProtectedContext(needsProtected)) {
3316 display->getRenderSurface()->setProtected(needsProtected);
3317 }
3318 }
3319
Alec Mouri6338c9d2019-02-07 16:57:51 -08003320 buf = display->getRenderSurface()->dequeueBuffer(&fd);
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08003321
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003322 if (buf == nullptr) {
3323 ALOGW("Dequeuing buffer for display [%s] failed, bailing out of "
3324 "client composition for this frame",
Lloyd Pique32cbe282018-10-19 13:09:22 -07003325 displayDevice->getDisplayName().c_str());
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003326 return false;
3327 }
3328
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003329 clientCompositionDisplay.physicalDisplay = displayState.scissor;
3330 clientCompositionDisplay.clip = displayState.scissor;
3331 const ui::Transform& displayTransform = displayState.transform;
Lloyd Pique7e06e7f2019-03-15 18:36:44 -07003332 clientCompositionDisplay.globalTransform = displayTransform.asMatrix4();
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003333
Lloyd Pique3d0c02e2018-10-19 18:38:12 -07003334 const auto* profile = display->getDisplayColorProfile();
Peiyong Lin34beb7a2018-03-28 11:57:12 -07003335 Dataspace outputDataspace = Dataspace::UNKNOWN;
Lloyd Pique3d0c02e2018-10-19 18:38:12 -07003336 if (profile->hasWideColorGamut()) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003337 outputDataspace = displayState.dataspace;
Chia-I Wu69bf10f2018-02-20 13:04:50 -08003338 }
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003339 clientCompositionDisplay.outputDataspace = outputDataspace;
3340 clientCompositionDisplay.maxLuminance =
3341 profile->getHdrCapabilities().getDesiredMaxLuminance();
Chia-I Wu69bf10f2018-02-20 13:04:50 -08003342
Lloyd Pique441d5042018-10-18 16:49:51 -07003343 const bool hasDeviceComposition = getHwComposer().hasDeviceComposition(displayId);
Peiyong Lined531a32018-10-26 18:27:56 -07003344 const bool skipClientColorTransform =
Lloyd Pique441d5042018-10-18 16:49:51 -07003345 getHwComposer()
3346 .hasDisplayCapability(displayId,
3347 HWC2::DisplayCapability::SkipClientColorTransform);
Chia-I Wu8e50e692018-05-04 10:12:37 -07003348
Peiyong Lind3788632018-09-18 16:01:31 -07003349 // Compute the global color transform matrix.
Chia-I Wu8e50e692018-05-04 10:12:37 -07003350 applyColorMatrix = !hasDeviceComposition && !skipClientColorTransform;
3351 if (applyColorMatrix) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003352 clientCompositionDisplay.colorTransform = colorMatrix;
Mathias Agopianf45c5102012-10-24 16:29:17 -07003353 }
Mathias Agopian85d751c2012-08-29 16:59:24 -07003354 }
Mathias Agopian4b2ba532012-03-29 12:23:51 -07003355
Mathias Agopian85d751c2012-08-29 16:59:24 -07003356 /*
3357 * and then, render the layers targeted at the framebuffer
3358 */
Mathias Agopian4b2ba532012-03-29 12:23:51 -07003359
Dan Stoza9e56aa02015-11-02 13:00:03 -08003360 ALOGV("Rendering client layers");
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003361 bool firstLayer = true;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003362 Region clearRegion = Region::INVALID_REGION;
Lloyd Pique32cbe282018-10-19 13:09:22 -07003363 for (auto& layer : displayDevice->getVisibleLayersSortedByZ()) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003364 const Region viewportRegion(displayState.viewport);
3365 const Region clip(viewportRegion.intersect(layer->visibleRegion));
David Sodmanc1498e62018-09-12 14:36:26 -07003366 ALOGV("Layer: %s", layer->getName().string());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08003367 ALOGV(" Composition type: %s", toString(layer->getCompositionType(displayDevice)).c_str());
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003368 if (!clip.isEmpty()) {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08003369 switch (layer->getCompositionType(displayDevice)) {
3370 case Hwc2::IComposerClient::Composition::CURSOR:
3371 case Hwc2::IComposerClient::Composition::DEVICE:
3372 case Hwc2::IComposerClient::Composition::SIDEBAND:
3373 case Hwc2::IComposerClient::Composition::SOLID_COLOR: {
Dominik Laskowski075d3172018-05-24 15:50:06 -07003374 LOG_ALWAYS_FATAL_IF(!displayId);
Lloyd Pique0449b0f2018-12-20 16:23:45 -08003375 const Layer::State& state(layer->getDrawingState());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08003376 if (layer->getClearClientTarget(displayDevice) && !firstLayer &&
Lloyd Pique0449b0f2018-12-20 16:23:45 -08003377 layer->isOpaque(state) && (layer->getAlpha() == 1.0f) &&
Lucas Dupin1b6531c2018-07-05 17:18:21 -07003378 layer->getRoundedCornerState().radius == 0.0f && hasClientComposition) {
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003379 // never clear the very first layer since we're
3380 // guaranteed the FB is already cleared
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003381 renderengine::LayerSettings layerSettings;
3382 Region dummyRegion;
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08003383 bool prepared =
3384 layer->prepareClientLayer(renderArea, clip, dummyRegion,
3385 supportProtectedContent, layerSettings);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003386
3387 if (prepared) {
3388 layerSettings.source.buffer.buffer = nullptr;
3389 layerSettings.source.solidColor = half3(0.0, 0.0, 0.0);
3390 layerSettings.alpha = half(0.0);
3391 layerSettings.disableBlending = true;
3392 clientCompositionLayers.push_back(layerSettings);
3393 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07003394 }
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003395 break;
Mathias Agopiancd60f992012-08-16 16:28:27 -07003396 }
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08003397 case Hwc2::IComposerClient::Composition::CLIENT: {
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003398 renderengine::LayerSettings layerSettings;
3399 bool prepared =
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08003400 layer->prepareClientLayer(renderArea, clip, clearRegion,
3401 supportProtectedContent, layerSettings);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003402 if (prepared) {
3403 clientCompositionLayers.push_back(layerSettings);
Peiyong Lind3788632018-09-18 16:01:31 -07003404 }
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003405 break;
3406 }
3407 default:
3408 break;
Mathias Agopian85d751c2012-08-29 16:59:24 -07003409 }
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003410 } else {
3411 ALOGV(" Skipping for empty clip");
Mathias Agopian85d751c2012-08-29 16:59:24 -07003412 }
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003413 firstLayer = false;
Mathias Agopian4b2ba532012-03-29 12:23:51 -07003414 }
Mathias Agopianf45c5102012-10-24 16:29:17 -07003415
Alec Mouri820c7402019-01-23 13:02:39 -08003416 // Perform some cleanup steps if we used client composition.
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003417 if (hasClientComposition) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003418 clientCompositionDisplay.clearRegion = clearRegion;
Peiyong Lin74ca2f42019-01-14 19:36:57 -08003419
3420 // We boost GPU frequency here because there will be color spaces conversion
3421 // and it's expensive. We boost the GPU frequency so that GPU composition can
3422 // finish in time. We must reset GPU frequency afterwards, because high frequency
3423 // consumes extra battery.
3424 const bool expensiveRenderingExpected =
3425 clientCompositionDisplay.outputDataspace == Dataspace::DISPLAY_P3;
3426 if (expensiveRenderingExpected && displayId) {
3427 mPowerAdvisor.setExpensiveRenderingExpected(*displayId, true);
3428 }
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003429 if (!debugRegion.isEmpty()) {
3430 Region::const_iterator it = debugRegion.begin();
3431 Region::const_iterator end = debugRegion.end();
3432 while (it != end) {
3433 const Rect& rect = *it++;
3434 renderengine::LayerSettings layerSettings;
3435 layerSettings.source.buffer.buffer = nullptr;
3436 layerSettings.source.solidColor = half3(1.0, 0.0, 1.0);
3437 layerSettings.geometry.boundaries = rect.toFloatRect();
3438 layerSettings.alpha = half(1.0);
3439 clientCompositionLayers.push_back(layerSettings);
3440 }
3441 }
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08003442 renderEngine.drawLayers(clientCompositionDisplay, clientCompositionLayers,
Alec Mourife0d72b2019-03-21 14:05:56 -07003443 buf->getNativeBuffer(), /*useFramebufferCache=*/true, std::move(fd),
3444 readyFence);
Peiyong Lin74ca2f42019-01-14 19:36:57 -08003445 if (expensiveRenderingExpected && displayId) {
3446 mPowerAdvisor.setExpensiveRenderingExpected(*displayId, false);
3447 }
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003448 }
Michael Lentine3f121fc2014-10-01 11:17:28 -07003449 return true;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003450}
3451
Chia-I Wu28e3a252018-09-07 12:05:02 -07003452void SurfaceFlinger::drawWormhole(const Region& region) const {
Lloyd Pique144e1162017-12-20 16:44:52 -08003453 auto& engine(getRenderEngine());
Chia-I Wu28e3a252018-09-07 12:05:02 -07003454 engine.fillRegionWithColor(region, 0, 0, 0, 0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003455}
3456
Dan Stoza7d89d062015-04-30 13:29:25 -07003457status_t SurfaceFlinger::addClientLayer(const sp<Client>& client,
Mathias Agopianac9fa422013-02-11 16:40:36 -08003458 const sp<IBinder>& handle,
Mathias Agopian67106042013-03-14 19:18:13 -07003459 const sp<IGraphicBufferProducer>& gbc,
Robert Carr1f0a16a2016-10-24 16:27:39 -07003460 const sp<Layer>& lbc,
Robert Carrb89ea9d2018-12-10 13:01:14 -08003461 const sp<Layer>& parent,
3462 bool addToCurrentState)
Mathias Agopian96f08192010-06-02 23:28:45 -07003463{
Dan Stoza7d89d062015-04-30 13:29:25 -07003464 // add this layer to the current state list
3465 {
3466 Mutex::Autolock _l(mStateLock);
Robert Carr1f0a16a2016-10-24 16:27:39 -07003467 if (mNumLayers >= MAX_LAYERS) {
Courtney Goeltzenleuchterab702f52017-04-19 15:14:02 -06003468 ALOGE("AddClientLayer failed, mNumLayers (%zu) >= MAX_LAYERS (%zu)", mNumLayers,
3469 MAX_LAYERS);
Dan Stoza7d89d062015-04-30 13:29:25 -07003470 return NO_MEMORY;
3471 }
Robert Carrb89ea9d2018-12-10 13:01:14 -08003472 if (parent == nullptr && addToCurrentState) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003473 mCurrentState.layersSortedByZ.add(lbc);
chaviwac841852019-01-16 16:04:43 -08003474 } else if (parent == nullptr) {
3475 lbc->onRemovedFromCurrentState();
3476 } else if (parent->isRemovedFromCurrentState()) {
3477 parent->addChild(lbc);
3478 lbc->onRemovedFromCurrentState();
Robert Carrb89ea9d2018-12-10 13:01:14 -08003479 } else {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003480 parent->addChild(lbc);
3481 }
Chia-I Wu98f1c102017-05-30 14:54:08 -07003482
Yiwei Zhang243b3782018-05-15 17:40:04 -07003483 if (gbc != nullptr) {
3484 mGraphicBufferProducerList.insert(IInterface::asBinder(gbc).get());
3485 LOG_ALWAYS_FATAL_IF(mGraphicBufferProducerList.size() >
3486 mMaxGraphicBufferProducerListSize,
3487 "Suspected IGBP leak: %zu IGBPs (%zu max), %zu Layers",
3488 mGraphicBufferProducerList.size(),
3489 mMaxGraphicBufferProducerListSize, mNumLayers);
3490 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07003491 mLayersAdded = true;
Dan Stoza7d89d062015-04-30 13:29:25 -07003492 }
3493
Mathias Agopian96f08192010-06-02 23:28:45 -07003494 // attach this layer to the client
Mathias Agopianac9fa422013-02-11 16:40:36 -08003495 client->attachLayer(handle, lbc);
Mathias Agopian4f113742011-05-03 16:21:41 -07003496
Dan Stoza7d89d062015-04-30 13:29:25 -07003497 return NO_ERROR;
Mathias Agopian96f08192010-06-02 23:28:45 -07003498}
3499
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08003500uint32_t SurfaceFlinger::peekTransactionFlags() {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003501 return mTransactionFlags;
Mathias Agopiandea20b12011-05-03 17:04:02 -07003502}
3503
Mathias Agopian3f844832013-08-07 21:24:32 -07003504uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003505 return mTransactionFlags.fetch_and(~flags) & flags;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003506}
3507
Mathias Agopian3f844832013-08-07 21:24:32 -07003508uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) {
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003509 return setTransactionFlags(flags, Scheduler::TransactionStart::NORMAL);
Dan Stoza84d619e2018-03-28 17:07:36 -07003510}
3511
3512uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags,
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003513 Scheduler::TransactionStart transactionStart) {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003514 uint32_t old = mTransactionFlags.fetch_or(flags);
Dan Stoza84d619e2018-03-28 17:07:36 -07003515 mVsyncModulator.setTransactionStart(transactionStart);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003516 if ((old & flags)==0) { // wake the server up
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08003517 signalTransaction();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003518 }
3519 return old;
3520}
3521
Marissa Wall713b63f2018-10-17 15:42:43 -07003522bool SurfaceFlinger::flushTransactionQueues() {
3523 Mutex::Autolock _l(mStateLock);
3524 auto it = mTransactionQueues.begin();
3525 while (it != mTransactionQueues.end()) {
3526 auto& [applyToken, transactionQueue] = *it;
3527
3528 while (!transactionQueue.empty()) {
Marissa Wall78b72202019-03-15 14:58:34 -07003529 const auto&
Marissa Wall3dad52d2019-03-22 14:03:19 -07003530 [states, displays, flags, desiredPresentTime, uncacheBuffer, listenerCallbacks,
3531 postTime, privileged] = transactionQueue.front();
Marissa Wall17b4e452018-12-26 16:32:34 -08003532 if (!transactionIsReadyToBeApplied(desiredPresentTime, states)) {
Marissa Wall713b63f2018-10-17 15:42:43 -07003533 break;
3534 }
Valerie Haubc6ddb12019-03-08 11:10:15 -08003535 applyTransactionState(states, displays, flags, mPendingInputWindowCommands,
Marissa Wall3dad52d2019-03-22 14:03:19 -07003536 desiredPresentTime, uncacheBuffer, listenerCallbacks, postTime,
3537 privileged, /*isMainThread*/ true);
Marissa Wall713b63f2018-10-17 15:42:43 -07003538 transactionQueue.pop();
3539 }
3540
3541 it = (transactionQueue.empty()) ? mTransactionQueues.erase(it) : std::next(it, 1);
3542 }
3543 return mTransactionQueues.empty();
3544}
3545
chaviwca27f252018-02-06 16:46:39 -08003546bool SurfaceFlinger::containsAnyInvalidClientState(const Vector<ComposerState>& states) {
3547 for (const ComposerState& state : states) {
3548 // Here we need to check that the interface we're given is indeed
3549 // one of our own. A malicious client could give us a nullptr
3550 // IInterface, or one of its own or even one of our own but a
3551 // different type. All these situations would cause us to crash.
3552 if (state.client == nullptr) {
3553 return true;
3554 }
3555
3556 sp<IBinder> binder = IInterface::asBinder(state.client);
3557 if (binder == nullptr) {
3558 return true;
3559 }
3560
3561 if (binder->queryLocalInterface(ISurfaceComposerClient::descriptor) == nullptr) {
3562 return true;
3563 }
3564 }
3565 return false;
3566}
3567
Marissa Wall17b4e452018-12-26 16:32:34 -08003568bool SurfaceFlinger::transactionIsReadyToBeApplied(int64_t desiredPresentTime,
3569 const Vector<ComposerState>& states) {
Ana Krulecc2870422019-01-29 19:00:58 -08003570 nsecs_t expectedPresentTime = mScheduler->expectedPresentTime();
Marissa Wall17b4e452018-12-26 16:32:34 -08003571 // Do not present if the desiredPresentTime has not passed unless it is more than one second
3572 // in the future. We ignore timestamps more than 1 second in the future for stability reasons.
3573 if (desiredPresentTime >= 0 && desiredPresentTime >= expectedPresentTime &&
3574 desiredPresentTime < expectedPresentTime + s2ns(1)) {
3575 return false;
3576 }
3577
Marissa Wall713b63f2018-10-17 15:42:43 -07003578 for (const ComposerState& state : states) {
3579 const layer_state_t& s = state.state;
3580 if (!(s.what & layer_state_t::eAcquireFenceChanged)) {
3581 continue;
3582 }
3583 if (s.acquireFence && s.acquireFence->getStatus() == Fence::Status::Unsignaled) {
Marissa Wall17b4e452018-12-26 16:32:34 -08003584 return false;
Marissa Wall713b63f2018-10-17 15:42:43 -07003585 }
3586 }
Marissa Wall17b4e452018-12-26 16:32:34 -08003587 return true;
Marissa Wall713b63f2018-10-17 15:42:43 -07003588}
3589
3590void SurfaceFlinger::setTransactionState(const Vector<ComposerState>& states,
3591 const Vector<DisplayState>& displays, uint32_t flags,
chaviw273171b2018-12-26 11:46:30 -08003592 const sp<IBinder>& applyToken,
Marissa Wall17b4e452018-12-26 16:32:34 -08003593 const InputWindowCommands& inputWindowCommands,
Marissa Wall78b72202019-03-15 14:58:34 -07003594 int64_t desiredPresentTime,
Marissa Wall3dad52d2019-03-22 14:03:19 -07003595 const cached_buffer_t& uncacheBuffer,
3596 const std::vector<ListenerCallbacks>& listenerCallbacks) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003597 ATRACE_CALL();
Robert Carr14167e02019-02-13 13:50:55 -08003598
Valerie Haubc6ddb12019-03-08 11:10:15 -08003599 const int64_t postTime = systemTime();
3600
Robert Carr14167e02019-02-13 13:50:55 -08003601 bool privileged = callingThreadHasUnscopedSurfaceFlingerAccess();
3602
Mathias Agopian698c0872011-06-28 19:09:31 -07003603 Mutex::Autolock _l(mStateLock);
Mathias Agopiane57f2922012-08-09 16:29:12 -07003604
chaviwca27f252018-02-06 16:46:39 -08003605 if (containsAnyInvalidClientState(states)) {
3606 return;
3607 }
3608
Marissa Wall713b63f2018-10-17 15:42:43 -07003609 // If its TransactionQueue already has a pending TransactionState or if it is pending
3610 if (mTransactionQueues.find(applyToken) != mTransactionQueues.end() ||
Marissa Wall17b4e452018-12-26 16:32:34 -08003611 !transactionIsReadyToBeApplied(desiredPresentTime, states)) {
Robert Carr14167e02019-02-13 13:50:55 -08003612 mTransactionQueues[applyToken].emplace(states, displays, flags, desiredPresentTime,
Marissa Wall3dad52d2019-03-22 14:03:19 -07003613 uncacheBuffer, listenerCallbacks, postTime,
3614 privileged);
Marissa Wall713b63f2018-10-17 15:42:43 -07003615 setTransactionFlags(eTransactionNeeded);
3616 return;
3617 }
3618
Valerie Haubc6ddb12019-03-08 11:10:15 -08003619 applyTransactionState(states, displays, flags, inputWindowCommands, desiredPresentTime,
Marissa Wall3dad52d2019-03-22 14:03:19 -07003620 uncacheBuffer, listenerCallbacks, postTime, privileged);
Marissa Wall713b63f2018-10-17 15:42:43 -07003621}
3622
3623void SurfaceFlinger::applyTransactionState(const Vector<ComposerState>& states,
chaviw273171b2018-12-26 11:46:30 -08003624 const Vector<DisplayState>& displays, uint32_t flags,
Robert Carr14167e02019-02-13 13:50:55 -08003625 const InputWindowCommands& inputWindowCommands,
Marissa Wall78b72202019-03-15 14:58:34 -07003626 const int64_t desiredPresentTime,
3627 const cached_buffer_t& uncacheBuffer,
Marissa Wall3dad52d2019-03-22 14:03:19 -07003628 const std::vector<ListenerCallbacks>& listenerCallbacks,
Marissa Wall78b72202019-03-15 14:58:34 -07003629 const int64_t postTime, bool privileged,
3630 bool isMainThread) {
Marissa Wall713b63f2018-10-17 15:42:43 -07003631 uint32_t transactionFlags = 0;
3632
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003633 if (flags & eAnimation) {
3634 // For window updates that are part of an animation we must wait for
3635 // previous animation "frames" to be handled.
3636 while (mAnimTransactionPending) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003637 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003638 if (CC_UNLIKELY(err != NO_ERROR)) {
3639 // just in case something goes wrong in SF, return to the
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003640 // caller after a few seconds.
3641 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out "
3642 "waiting for previous animation frame");
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003643 mAnimTransactionPending = false;
3644 break;
3645 }
3646 }
3647 }
3648
chaviwca27f252018-02-06 16:46:39 -08003649 for (const DisplayState& display : displays) {
3650 transactionFlags |= setDisplayStateLocked(display);
Jamie Gennisb8d69a52011-10-10 15:48:06 -07003651 }
3652
Marissa Walld600d572019-03-26 15:38:50 -07003653 // In case the client has sent a Transaction that should receive callbacks but without any
3654 // SurfaceControls that should be included in the callback, send the listener and callbackIds
3655 // to the callback thread so it can send an empty callback
3656 if (!listenerCallbacks.empty()) {
3657 mTransactionCompletedThread.run();
3658 }
3659 for (const auto& [listener, callbackIds] : listenerCallbacks) {
3660 mTransactionCompletedThread.addCallback(listener, callbackIds);
3661 }
3662
Marissa Walle2ffb422018-10-12 11:33:52 -07003663 uint32_t clientStateFlags = 0;
chaviwca27f252018-02-06 16:46:39 -08003664 for (const ComposerState& state : states) {
Marissa Wall3dad52d2019-03-22 14:03:19 -07003665 clientStateFlags |= setClientStateLocked(state, desiredPresentTime, listenerCallbacks,
3666 postTime, privileged);
3667 }
3668
Marissa Walle2ffb422018-10-12 11:33:52 -07003669 // If the state doesn't require a traversal and there are callbacks, send them now
3670 if (!(clientStateFlags & eTraversalNeeded)) {
3671 mTransactionCompletedThread.sendCallbacks();
3672 }
3673 transactionFlags |= clientStateFlags;
chaviwca27f252018-02-06 16:46:39 -08003674
chaviw273171b2018-12-26 11:46:30 -08003675 transactionFlags |= addInputWindowCommands(inputWindowCommands);
3676
Marissa Wall78b72202019-03-15 14:58:34 -07003677 if (uncacheBuffer.token) {
3678 BufferStateLayerCache::getInstance().erase(uncacheBuffer.token, uncacheBuffer.cacheId);
3679 }
3680
Jorim Jaggibdcf09c2017-08-08 15:22:08 +02003681 // If a synchronous transaction is explicitly requested without any changes, force a transaction
3682 // anyway. This can be used as a flush mechanism for previous async transactions.
3683 // Empty animation transaction can be used to simulate back-pressure, so also force a
3684 // transaction for empty animation transactions.
3685 if (transactionFlags == 0 &&
3686 ((flags & eSynchronous) || (flags & eAnimation))) {
Robert Carr2a7dbb42016-05-24 11:41:28 -07003687 transactionFlags = eTransactionNeeded;
3688 }
3689
Marissa Wall06255332019-03-27 13:48:27 -07003690 // If we are on the main thread, we are about to preform a traversal. Clear the traversal bit
3691 // so we don't have to wake up again next frame to preform an uneeded traversal.
3692 if (isMainThread && (transactionFlags & eTraversalNeeded)) {
3693 transactionFlags = transactionFlags & (~eTraversalNeeded);
3694 mTraversalNeededMainThread = true;
3695 }
3696
Mathias Agopian386aa982011-11-07 21:58:03 -08003697 if (transactionFlags) {
Lloyd Pique4dccc412018-01-22 17:21:36 -08003698 if (mInterceptor->isEnabled()) {
3699 mInterceptor->saveTransaction(states, mCurrentState.displays, displays, flags);
Irvelffc9efc2016-07-27 15:16:37 -07003700 }
Irvel468051e2016-06-13 16:44:44 -07003701
Mathias Agopian386aa982011-11-07 21:58:03 -08003702 // this triggers the transaction
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003703 const auto start = (flags & eEarlyWakeup) ? Scheduler::TransactionStart::EARLY
3704 : Scheduler::TransactionStart::NORMAL;
Dan Stoza84d619e2018-03-28 17:07:36 -07003705 setTransactionFlags(transactionFlags, start);
Mathias Agopian386aa982011-11-07 21:58:03 -08003706
3707 // if this is a synchronous transaction, wait for it to take effect
3708 // before returning.
3709 if (flags & eSynchronous) {
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003710 mTransactionPending = true;
Mathias Agopian386aa982011-11-07 21:58:03 -08003711 }
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003712 if (flags & eAnimation) {
3713 mAnimTransactionPending = true;
3714 }
chaviw95ef3c42019-02-14 10:55:09 -08003715
3716 mPendingSyncInputWindows = mPendingInputWindowCommands.syncInputWindows;
Valerie Hau0779ded2019-03-19 12:43:04 -07003717
3718 // applyTransactionState can be called by either the main SF thread or by
3719 // another process through setTransactionState. While a given process may wish
3720 // to wait on synchronous transactions, the main SF thread should never
3721 // be blocked. Therefore, we only wait if isMainThread is false.
3722 while (!isMainThread && (mTransactionPending || mPendingSyncInputWindows)) {
Mathias Agopian386aa982011-11-07 21:58:03 -08003723 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
3724 if (CC_UNLIKELY(err != NO_ERROR)) {
3725 // just in case something goes wrong in SF, return to the
3726 // called after a few seconds.
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003727 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");
3728 mTransactionPending = false;
chaviw95ef3c42019-02-14 10:55:09 -08003729 mPendingSyncInputWindows = false;
Mathias Agopian386aa982011-11-07 21:58:03 -08003730 break;
3731 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -07003732 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003733 }
3734}
3735
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003736uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s) {
3737 const ssize_t index = mCurrentState.displays.indexOfKey(s.token);
3738 if (index < 0) return 0;
Jesse Hall9a143922012-10-04 16:29:19 -07003739
Mathias Agopiane57f2922012-08-09 16:29:12 -07003740 uint32_t flags = 0;
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003741 DisplayDeviceState& state = mCurrentState.displays.editValueAt(index);
3742
3743 const uint32_t what = s.what;
3744 if (what & DisplayState::eSurfaceChanged) {
3745 if (IInterface::asBinder(state.surface) != IInterface::asBinder(s.surface)) {
3746 state.surface = s.surface;
3747 flags |= eDisplayTransactionNeeded;
Michael Lentine47e45402014-07-18 15:34:25 -07003748 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07003749 }
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003750 if (what & DisplayState::eLayerStackChanged) {
3751 if (state.layerStack != s.layerStack) {
3752 state.layerStack = s.layerStack;
3753 flags |= eDisplayTransactionNeeded;
3754 }
3755 }
3756 if (what & DisplayState::eDisplayProjectionChanged) {
3757 if (state.orientation != s.orientation) {
3758 state.orientation = s.orientation;
3759 flags |= eDisplayTransactionNeeded;
3760 }
3761 if (state.frame != s.frame) {
3762 state.frame = s.frame;
3763 flags |= eDisplayTransactionNeeded;
3764 }
3765 if (state.viewport != s.viewport) {
3766 state.viewport = s.viewport;
3767 flags |= eDisplayTransactionNeeded;
3768 }
3769 }
3770 if (what & DisplayState::eDisplaySizeChanged) {
3771 if (state.width != s.width) {
3772 state.width = s.width;
3773 flags |= eDisplayTransactionNeeded;
3774 }
3775 if (state.height != s.height) {
3776 state.height = s.height;
3777 flags |= eDisplayTransactionNeeded;
3778 }
3779 }
3780
Mathias Agopiane57f2922012-08-09 16:29:12 -07003781 return flags;
3782}
3783
Robert Carr14167e02019-02-13 13:50:55 -08003784bool SurfaceFlinger::callingThreadHasUnscopedSurfaceFlingerAccess() {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003785 IPCThreadState* ipc = IPCThreadState::self();
3786 const int pid = ipc->getCallingPid();
3787 const int uid = ipc->getCallingUid();
Robert Carrd4ae7f32018-06-07 16:10:57 -07003788 if ((uid != AID_GRAPHICS && uid != AID_SYSTEM) &&
Ana Krulec13be8ad2018-08-21 02:43:56 +00003789 !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003790 return false;
3791 }
3792 return true;
3793}
3794
Marissa Wall3dad52d2019-03-22 14:03:19 -07003795uint32_t SurfaceFlinger::setClientStateLocked(
3796 const ComposerState& composerState, int64_t desiredPresentTime,
3797 const std::vector<ListenerCallbacks>& listenerCallbacks, int64_t postTime,
3798 bool privileged) {
chaviwca27f252018-02-06 16:46:39 -08003799 const layer_state_t& s = composerState.state;
3800 sp<Client> client(static_cast<Client*>(composerState.client.get()));
3801
Mathias Agopian13127d82013-03-05 17:47:11 -08003802 sp<Layer> layer(client->getLayerUser(s.surface));
chaviw8b3871a2017-11-01 17:41:01 -07003803 if (layer == nullptr) {
3804 return 0;
3805 }
3806
chaviw8b3871a2017-11-01 17:41:01 -07003807 uint32_t flags = 0;
3808
Garfield Tan8a3083e2018-12-03 13:21:07 -08003809 const uint64_t what = s.what;
chaviw8b3871a2017-11-01 17:41:01 -07003810 bool geometryAppliesWithResize =
3811 what & layer_state_t::eGeometryAppliesWithResize;
Jorim Jaggidba32732018-05-28 17:43:52 +02003812
3813 // If we are deferring transaction, make sure to push the pending state, as otherwise the
3814 // pending state will also be deferred.
Marissa Wallf58c14b2018-07-24 10:50:43 -07003815 if (what & layer_state_t::eDeferTransaction_legacy) {
Jorim Jaggidba32732018-05-28 17:43:52 +02003816 layer->pushPendingState();
3817 }
3818
chaviw8b3871a2017-11-01 17:41:01 -07003819 if (what & layer_state_t::ePositionChanged) {
3820 if (layer->setPosition(s.x, s.y, !geometryAppliesWithResize)) {
3821 flags |= eTraversalNeeded;
Mathias Agopiane57f2922012-08-09 16:29:12 -07003822 }
chaviw8b3871a2017-11-01 17:41:01 -07003823 }
3824 if (what & layer_state_t::eLayerChanged) {
3825 // NOTE: index needs to be calculated before we update the state
3826 const auto& p = layer->getParent();
3827 if (p == nullptr) {
chaviw64f7b422017-07-12 10:31:58 -07003828 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
chaviw8b3871a2017-11-01 17:41:01 -07003829 if (layer->setLayer(s.z) && idx >= 0) {
Mathias Agopiane57f2922012-08-09 16:29:12 -07003830 mCurrentState.layersSortedByZ.removeAt(idx);
3831 mCurrentState.layersSortedByZ.add(layer);
3832 // we need traversal (state changed)
3833 // AND transaction (list changed)
3834 flags |= eTransactionNeeded|eTraversalNeeded;
3835 }
chaviw8b3871a2017-11-01 17:41:01 -07003836 } else {
3837 if (p->setChildLayer(layer, s.z)) {
chaviw06178942017-07-27 10:25:59 -07003838 flags |= eTransactionNeeded|eTraversalNeeded;
3839 }
3840 }
chaviw8b3871a2017-11-01 17:41:01 -07003841 }
3842 if (what & layer_state_t::eRelativeLayerChanged) {
Robert Carr503c7042017-09-27 15:06:08 -07003843 // NOTE: index needs to be calculated before we update the state
3844 const auto& p = layer->getParent();
3845 if (p == nullptr) {
3846 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
3847 if (layer->setRelativeLayer(s.relativeLayerHandle, s.z) && idx >= 0) {
3848 mCurrentState.layersSortedByZ.removeAt(idx);
3849 mCurrentState.layersSortedByZ.add(layer);
3850 // we need traversal (state changed)
3851 // AND transaction (list changed)
3852 flags |= eTransactionNeeded|eTraversalNeeded;
3853 }
3854 } else {
3855 if (p->setChildRelativeLayer(layer, s.relativeLayerHandle, s.z)) {
3856 flags |= eTransactionNeeded|eTraversalNeeded;
3857 }
chaviw8b3871a2017-11-01 17:41:01 -07003858 }
3859 }
3860 if (what & layer_state_t::eSizeChanged) {
3861 if (layer->setSize(s.w, s.h)) {
3862 flags |= eTraversalNeeded;
3863 }
3864 }
3865 if (what & layer_state_t::eAlphaChanged) {
3866 if (layer->setAlpha(s.alpha))
3867 flags |= eTraversalNeeded;
3868 }
3869 if (what & layer_state_t::eColorChanged) {
3870 if (layer->setColor(s.color))
3871 flags |= eTraversalNeeded;
3872 }
Peiyong Lind3788632018-09-18 16:01:31 -07003873 if (what & layer_state_t::eColorTransformChanged) {
3874 if (layer->setColorTransform(s.colorTransform)) {
3875 flags |= eTraversalNeeded;
3876 }
3877 }
Valerie Haudd0b7572019-01-29 14:59:27 -08003878 if (what & layer_state_t::eBackgroundColorChanged) {
3879 if (layer->setBackgroundColor(s.color, s.bgColorAlpha, s.bgColorDataspace)) {
3880 flags |= eTraversalNeeded;
3881 }
3882 }
chaviw8b3871a2017-11-01 17:41:01 -07003883 if (what & layer_state_t::eMatrixChanged) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003884 // TODO: b/109894387
3885 //
3886 // SurfaceFlinger's renderer is not prepared to handle cropping in the face of arbitrary
3887 // rotation. To see the problem observe that if we have a square parent, and a child
3888 // of the same size, then we rotate the child 45 degrees around it's center, the child
3889 // must now be cropped to a non rectangular 8 sided region.
3890 //
3891 // Of course we can fix this in the future. For now, we are lucky, SurfaceControl is
3892 // private API, and the WindowManager only uses rotation in one case, which is on a top
3893 // level layer in which cropping is not an issue.
3894 //
3895 // However given that abuse of rotation matrices could lead to surfaces extending outside
3896 // of cropped areas, we need to prevent non-root clients without permission ACCESS_SURFACE_FLINGER
3897 // (a.k.a. everyone except WindowManager and tests) from setting non rectangle preserving
3898 // transformations.
Robert Carr14167e02019-02-13 13:50:55 -08003899 if (layer->setMatrix(s.matrix, privileged))
chaviw8b3871a2017-11-01 17:41:01 -07003900 flags |= eTraversalNeeded;
3901 }
3902 if (what & layer_state_t::eTransparentRegionChanged) {
3903 if (layer->setTransparentRegionHint(s.transparentRegion))
3904 flags |= eTraversalNeeded;
3905 }
3906 if (what & layer_state_t::eFlagsChanged) {
3907 if (layer->setFlags(s.flags, s.mask))
3908 flags |= eTraversalNeeded;
3909 }
Marissa Wallf58c14b2018-07-24 10:50:43 -07003910 if (what & layer_state_t::eCropChanged_legacy) {
3911 if (layer->setCrop_legacy(s.crop_legacy, !geometryAppliesWithResize))
chaviw8b3871a2017-11-01 17:41:01 -07003912 flags |= eTraversalNeeded;
3913 }
Lucas Dupin1b6531c2018-07-05 17:18:21 -07003914 if (what & layer_state_t::eCornerRadiusChanged) {
3915 if (layer->setCornerRadius(s.cornerRadius))
3916 flags |= eTraversalNeeded;
3917 }
chaviw8b3871a2017-11-01 17:41:01 -07003918 if (what & layer_state_t::eLayerStackChanged) {
3919 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
3920 // We only allow setting layer stacks for top level layers,
3921 // everything else inherits layer stack from its parent.
3922 if (layer->hasParent()) {
3923 ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
3924 layer->getName().string());
3925 } else if (idx < 0) {
3926 ALOGE("Attempt to set layer stack on layer without parent (%s) that "
3927 "that also does not appear in the top level layer list. Something"
3928 " has gone wrong.", layer->getName().string());
3929 } else if (layer->setLayerStack(s.layerStack)) {
3930 mCurrentState.layersSortedByZ.removeAt(idx);
3931 mCurrentState.layersSortedByZ.add(layer);
3932 // we need traversal (state changed)
3933 // AND transaction (list changed)
Lloyd Piqued432a7c2018-03-23 16:05:31 -07003934 flags |= eTransactionNeeded|eTraversalNeeded|eDisplayLayerStackChanged;
chaviw8b3871a2017-11-01 17:41:01 -07003935 }
3936 }
Marissa Wallf58c14b2018-07-24 10:50:43 -07003937 if (what & layer_state_t::eDeferTransaction_legacy) {
3938 if (s.barrierHandle_legacy != nullptr) {
3939 layer->deferTransactionUntil_legacy(s.barrierHandle_legacy, s.frameNumber_legacy);
3940 } else if (s.barrierGbp_legacy != nullptr) {
3941 const sp<IGraphicBufferProducer>& gbp = s.barrierGbp_legacy;
chaviw8b3871a2017-11-01 17:41:01 -07003942 if (authenticateSurfaceTextureLocked(gbp)) {
3943 const auto& otherLayer =
3944 (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
Marissa Wallf58c14b2018-07-24 10:50:43 -07003945 layer->deferTransactionUntil_legacy(otherLayer, s.frameNumber_legacy);
chaviw8b3871a2017-11-01 17:41:01 -07003946 } else {
3947 ALOGE("Attempt to defer transaction to to an"
3948 " unrecognized GraphicBufferProducer");
Robert Carr1db73f62016-12-21 12:58:51 -08003949 }
3950 }
chaviw8b3871a2017-11-01 17:41:01 -07003951 // We don't trigger a traversal here because if no other state is
3952 // changed, we don't want this to cause any more work
3953 }
3954 if (what & layer_state_t::eReparent) {
chaviw8ea97bb2017-11-29 10:05:15 -08003955 bool hadParent = layer->hasParent();
chaviw8b3871a2017-11-01 17:41:01 -07003956 if (layer->reparent(s.parentHandleForChild)) {
chaviw8ea97bb2017-11-29 10:05:15 -08003957 if (!hadParent) {
3958 mCurrentState.layersSortedByZ.remove(layer);
3959 }
chaviw8b3871a2017-11-01 17:41:01 -07003960 flags |= eTransactionNeeded|eTraversalNeeded;
Robert Carr9524cb32017-02-13 11:32:32 -08003961 }
chaviw8b3871a2017-11-01 17:41:01 -07003962 }
3963 if (what & layer_state_t::eReparentChildren) {
3964 if (layer->reparentChildren(s.reparentHandle)) {
3965 flags |= eTransactionNeeded|eTraversalNeeded;
Robert Carrc3574f72016-03-24 12:19:32 -07003966 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07003967 }
chaviw8b3871a2017-11-01 17:41:01 -07003968 if (what & layer_state_t::eDetachChildren) {
3969 layer->detachChildren();
3970 }
3971 if (what & layer_state_t::eOverrideScalingModeChanged) {
3972 layer->setOverrideScalingMode(s.overrideScalingMode);
3973 // We don't trigger a traversal here because if no other state is
3974 // changed, we don't want this to cause any more work
3975 }
Marissa Wall61c58622018-07-18 10:12:20 -07003976 if (what & layer_state_t::eTransformChanged) {
3977 if (layer->setTransform(s.transform)) flags |= eTraversalNeeded;
3978 }
3979 if (what & layer_state_t::eTransformToDisplayInverseChanged) {
3980 if (layer->setTransformToDisplayInverse(s.transformToDisplayInverse))
3981 flags |= eTraversalNeeded;
3982 }
3983 if (what & layer_state_t::eCropChanged) {
3984 if (layer->setCrop(s.crop)) flags |= eTraversalNeeded;
3985 }
Marissa Wall861616d2018-10-22 12:52:23 -07003986 if (what & layer_state_t::eFrameChanged) {
3987 if (layer->setFrame(s.frame)) flags |= eTraversalNeeded;
3988 }
Marissa Wall61c58622018-07-18 10:12:20 -07003989 if (what & layer_state_t::eAcquireFenceChanged) {
3990 if (layer->setAcquireFence(s.acquireFence)) flags |= eTraversalNeeded;
3991 }
3992 if (what & layer_state_t::eDataspaceChanged) {
3993 if (layer->setDataspace(s.dataspace)) flags |= eTraversalNeeded;
3994 }
3995 if (what & layer_state_t::eHdrMetadataChanged) {
3996 if (layer->setHdrMetadata(s.hdrMetadata)) flags |= eTraversalNeeded;
3997 }
3998 if (what & layer_state_t::eSurfaceDamageRegionChanged) {
3999 if (layer->setSurfaceDamageRegion(s.surfaceDamageRegion)) flags |= eTraversalNeeded;
4000 }
4001 if (what & layer_state_t::eApiChanged) {
4002 if (layer->setApi(s.api)) flags |= eTraversalNeeded;
4003 }
4004 if (what & layer_state_t::eSidebandStreamChanged) {
4005 if (layer->setSidebandStream(s.sidebandStream)) flags |= eTraversalNeeded;
4006 }
Robert Carr720e5062018-07-30 17:45:14 -07004007 if (what & layer_state_t::eInputInfoChanged) {
Vishnu Nairce5d0cc2019-02-28 14:38:41 -08004008 if (privileged) {
Robert Carr11ac2012019-01-22 09:05:25 -08004009 layer->setInputInfo(s.inputInfo);
4010 flags |= eTraversalNeeded;
4011 } else {
4012 ALOGE("Attempt to update InputWindowInfo without permission ACCESS_SURFACE_FLINGER");
4013 }
Robert Carr720e5062018-07-30 17:45:14 -07004014 }
Evan Rosky1f6d6d52018-12-06 10:47:26 -08004015 if (what & layer_state_t::eMetadataChanged) {
4016 if (layer->setMetadata(s.metadata)) flags |= eTraversalNeeded;
4017 }
Peiyong Linc502cb72019-03-01 15:00:23 -08004018 if (what & layer_state_t::eColorSpaceAgnosticChanged) {
4019 if (layer->setColorSpaceAgnostic(s.colorSpaceAgnostic)) {
4020 flags |= eTraversalNeeded;
4021 }
4022 }
Marissa Walle2ffb422018-10-12 11:33:52 -07004023 std::vector<sp<CallbackHandle>> callbackHandles;
Marissa Wall3dad52d2019-03-22 14:03:19 -07004024 if ((what & layer_state_t::eHasListenerCallbacksChanged) && (!listenerCallbacks.empty())) {
Marissa Wall3dad52d2019-03-22 14:03:19 -07004025 for (const auto& [listener, callbackIds] : listenerCallbacks) {
Marissa Walle2ffb422018-10-12 11:33:52 -07004026 callbackHandles.emplace_back(new CallbackHandle(listener, callbackIds, s.surface));
4027 }
4028 }
Marissa Wall78b72202019-03-15 14:58:34 -07004029 bool bufferChanged = what & layer_state_t::eBufferChanged;
4030 bool cacheIdChanged = what & layer_state_t::eCachedBufferChanged;
4031 sp<GraphicBuffer> buffer;
4032 if (bufferChanged && cacheIdChanged) {
4033 BufferStateLayerCache::getInstance().add(s.cachedBuffer.token, s.cachedBuffer.cacheId,
Marissa Wall73411622019-01-25 10:45:41 -08004034 s.buffer);
Marissa Wall78b72202019-03-15 14:58:34 -07004035 buffer = s.buffer;
4036 } else if (cacheIdChanged) {
4037 buffer = BufferStateLayerCache::getInstance().get(s.cachedBuffer.token,
4038 s.cachedBuffer.cacheId);
4039 } else if (bufferChanged) {
4040 buffer = s.buffer;
Marissa Wall73411622019-01-25 10:45:41 -08004041 }
Marissa Wall78b72202019-03-15 14:58:34 -07004042 if (buffer) {
Valerie Haubc6ddb12019-03-08 11:10:15 -08004043 if (layer->setBuffer(buffer)) {
4044 flags |= eTraversalNeeded;
4045 layer->setPostTime(postTime);
4046 layer->setDesiredPresentTime(desiredPresentTime);
4047 }
Marissa Wallebc2c052019-01-16 19:16:55 -08004048 }
Marissa Walle2ffb422018-10-12 11:33:52 -07004049 if (layer->setTransactionCompletedListeners(callbackHandles)) flags |= eTraversalNeeded;
4050 // Do not put anything that updates layer state or modifies flags after
4051 // setTransactionCompletedListener
Mathias Agopiane57f2922012-08-09 16:29:12 -07004052 return flags;
4053}
4054
chaviw273171b2018-12-26 11:46:30 -08004055uint32_t SurfaceFlinger::addInputWindowCommands(const InputWindowCommands& inputWindowCommands) {
4056 uint32_t flags = 0;
4057 if (!inputWindowCommands.transferTouchFocusCommands.empty()) {
4058 flags |= eTraversalNeeded;
4059 }
4060
chaviwa911b102019-02-14 10:18:33 -08004061 if (inputWindowCommands.syncInputWindows) {
4062 flags |= eTraversalNeeded;
4063 }
4064
Vishnu Nairec0ab382019-02-13 15:32:56 -08004065 mPendingInputWindowCommands.merge(inputWindowCommands);
chaviw273171b2018-12-26 11:46:30 -08004066 return flags;
4067}
4068
Evan Rosky1f6d6d52018-12-06 10:47:26 -08004069status_t SurfaceFlinger::createLayer(const String8& name, const sp<Client>& client, uint32_t w,
4070 uint32_t h, PixelFormat format, uint32_t flags,
4071 LayerMetadata metadata, sp<IBinder>* handle,
4072 sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent) {
Mathias Agopian6e2d6482009-07-09 18:16:43 -07004073 if (int32_t(w|h) < 0) {
Mathias Agopian921e6ac2012-07-23 23:11:29 -07004074 ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
Mathias Agopian6e2d6482009-07-09 18:16:43 -07004075 int(w), int(h));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004076 return BAD_VALUE;
Mathias Agopian6e2d6482009-07-09 18:16:43 -07004077 }
Andreas Huber8b42e8a2010-08-16 08:49:37 -07004078
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004079 status_t result = NO_ERROR;
4080
4081 sp<Layer> layer;
4082
Cody Northropbc755282017-03-31 12:00:08 -06004083 String8 uniqueName = getUniqueLayerName(name);
4084
Evan Roskya1f1e152019-01-24 16:17:46 -08004085 bool primaryDisplayOnly = false;
4086
4087 // window type is WINDOW_TYPE_DONT_SCREENSHOT from SurfaceControl.java
4088 // TODO b/64227542
4089 if (metadata.has(METADATA_WINDOW_TYPE)) {
4090 int32_t windowType = metadata.getInt32(METADATA_WINDOW_TYPE, 0);
4091 if (windowType == 441731) {
4092 metadata.setInt32(METADATA_WINDOW_TYPE, 2024); // TYPE_NAVIGATION_BAR_PANEL
4093 primaryDisplayOnly = true;
4094 }
4095 }
4096
Mathias Agopian3165cc22012-08-08 19:42:09 -07004097 switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
Marissa Wall61c58622018-07-18 10:12:20 -07004098 case ISurfaceComposerClient::eFXSurfaceBufferQueue:
Evan Roskya1f1e152019-01-24 16:17:46 -08004099 result = createBufferQueueLayer(client, uniqueName, w, h, flags, std::move(metadata),
4100 format, handle, gbp, &layer);
David Sodman0c69cad2017-08-21 12:12:51 -07004101
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004102 break;
Marissa Wall61c58622018-07-18 10:12:20 -07004103 case ISurfaceComposerClient::eFXSurfaceBufferState:
Evan Roskya1f1e152019-01-24 16:17:46 -08004104 result = createBufferStateLayer(client, uniqueName, w, h, flags, std::move(metadata),
4105 handle, &layer);
Marissa Wall61c58622018-07-18 10:12:20 -07004106 break;
chaviw13fdc492017-06-27 12:40:18 -07004107 case ISurfaceComposerClient::eFXSurfaceColor:
Vishnu Nair88a11f22018-11-28 18:30:57 -08004108 // check if buffer size is set for color layer.
4109 if (w > 0 || h > 0) {
4110 ALOGE("createLayer() failed, w or h cannot be set for color layer (w=%d, h=%d)",
4111 int(w), int(h));
4112 return BAD_VALUE;
4113 }
4114
Evan Roskya1f1e152019-01-24 16:17:46 -08004115 result = createColorLayer(client, uniqueName, w, h, flags, std::move(metadata), handle,
4116 &layer);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004117 break;
Robert Carr6b3f6c52018-08-13 13:05:17 -07004118 case ISurfaceComposerClient::eFXSurfaceContainer:
Vishnu Nair88a11f22018-11-28 18:30:57 -08004119 // check if buffer size is set for container layer.
4120 if (w > 0 || h > 0) {
4121 ALOGE("createLayer() failed, w or h cannot be set for container layer (w=%d, h=%d)",
4122 int(w), int(h));
4123 return BAD_VALUE;
4124 }
Evan Roskya1f1e152019-01-24 16:17:46 -08004125 result = createContainerLayer(client, uniqueName, w, h, flags, std::move(metadata),
4126 handle, &layer);
Robert Carr6b3f6c52018-08-13 13:05:17 -07004127 break;
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004128 default:
4129 result = BAD_VALUE;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004130 break;
4131 }
4132
Dan Stoza7d89d062015-04-30 13:29:25 -07004133 if (result != NO_ERROR) {
4134 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004135 }
Dan Stoza7d89d062015-04-30 13:29:25 -07004136
Evan Roskya1f1e152019-01-24 16:17:46 -08004137 if (primaryDisplayOnly) {
4138 layer->setPrimaryDisplayOnly();
Chia-I Wuab0c3192017-08-01 11:29:00 -07004139 }
4140
Robert Carrb89ea9d2018-12-10 13:01:14 -08004141 bool addToCurrentState = callingThreadHasUnscopedSurfaceFlingerAccess();
4142 result = addClientLayer(client, *handle, *gbp, layer, *parent,
4143 addToCurrentState);
Dan Stoza7d89d062015-04-30 13:29:25 -07004144 if (result != NO_ERROR) {
4145 return result;
4146 }
Lloyd Pique4dccc412018-01-22 17:21:36 -08004147 mInterceptor->saveSurfaceCreation(layer);
Dan Stoza7d89d062015-04-30 13:29:25 -07004148
4149 setTransactionFlags(eTransactionNeeded);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004150 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004151}
4152
Cody Northropbc755282017-03-31 12:00:08 -06004153String8 SurfaceFlinger::getUniqueLayerName(const String8& name)
4154{
4155 bool matchFound = true;
4156 uint32_t dupeCounter = 0;
4157
4158 // Tack on our counter whether there is a hit or not, so everyone gets a tag
4159 String8 uniqueName = name + "#" + String8(std::to_string(dupeCounter).c_str());
4160
Dan Stoza436ccf32018-06-21 12:10:12 -07004161 // Grab the state lock since we're accessing mCurrentState
4162 Mutex::Autolock lock(mStateLock);
4163
Cody Northropbc755282017-03-31 12:00:08 -06004164 // Loop over layers until we're sure there is no matching name
4165 while (matchFound) {
4166 matchFound = false;
Dan Stoza436ccf32018-06-21 12:10:12 -07004167 mCurrentState.traverseInZOrder([&](Layer* layer) {
Cody Northropbc755282017-03-31 12:00:08 -06004168 if (layer->getName() == uniqueName) {
4169 matchFound = true;
4170 uniqueName = name + "#" + String8(std::to_string(++dupeCounter).c_str());
4171 }
4172 });
4173 }
4174
Marissa Wallf1de4bd2018-05-22 13:05:01 -07004175 ALOGV_IF(dupeCounter > 0, "duplicate layer name: changing %s to %s", name.c_str(),
4176 uniqueName.c_str());
Cody Northropbc755282017-03-31 12:00:08 -06004177
4178 return uniqueName;
4179}
4180
Marissa Wallfd668622018-05-10 10:21:13 -07004181status_t SurfaceFlinger::createBufferQueueLayer(const sp<Client>& client, const String8& name,
4182 uint32_t w, uint32_t h, uint32_t flags,
Evan Roskya1f1e152019-01-24 16:17:46 -08004183 LayerMetadata metadata, PixelFormat& format,
4184 sp<IBinder>* handle,
Marissa Wallfd668622018-05-10 10:21:13 -07004185 sp<IGraphicBufferProducer>* gbp,
4186 sp<Layer>* outLayer) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004187 // initialize the surfaces
Mathias Agopian92a979a2012-08-02 18:32:23 -07004188 switch (format) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004189 case PIXEL_FORMAT_TRANSPARENT:
4190 case PIXEL_FORMAT_TRANSLUCENT:
4191 format = PIXEL_FORMAT_RGBA_8888;
4192 break;
4193 case PIXEL_FORMAT_OPAQUE:
Mathias Agopian8f105402010-04-05 18:01:24 -07004194 format = PIXEL_FORMAT_RGBX_8888;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004195 break;
4196 }
4197
Evan Roskya1f1e152019-01-24 16:17:46 -08004198 sp<BufferQueueLayer> layer = getFactory().createBufferQueueLayer(
4199 LayerCreationArgs(this, client, name, w, h, flags, std::move(metadata)));
Marissa Wallfd668622018-05-10 10:21:13 -07004200 status_t err = layer->setDefaultBufferProperties(w, h, format);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004201 if (err == NO_ERROR) {
David Sodman0c69cad2017-08-21 12:12:51 -07004202 *handle = layer->getHandle();
4203 *gbp = layer->getProducer();
4204 *outLayer = layer;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004205 }
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004206
Marissa Wallfd668622018-05-10 10:21:13 -07004207 ALOGE_IF(err, "createBufferQueueLayer() failed (%s)", strerror(-err));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004208 return err;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004209}
4210
Marissa Wall61c58622018-07-18 10:12:20 -07004211status_t SurfaceFlinger::createBufferStateLayer(const sp<Client>& client, const String8& name,
4212 uint32_t w, uint32_t h, uint32_t flags,
Evan Roskya1f1e152019-01-24 16:17:46 -08004213 LayerMetadata metadata, sp<IBinder>* handle,
4214 sp<Layer>* outLayer) {
4215 sp<BufferStateLayer> layer = getFactory().createBufferStateLayer(
4216 LayerCreationArgs(this, client, name, w, h, flags, std::move(metadata)));
Marissa Wall61c58622018-07-18 10:12:20 -07004217 *handle = layer->getHandle();
4218 *outLayer = layer;
4219
4220 return NO_ERROR;
4221}
4222
Evan Roskya1f1e152019-01-24 16:17:46 -08004223status_t SurfaceFlinger::createColorLayer(const sp<Client>& client, const String8& name, uint32_t w,
4224 uint32_t h, uint32_t flags, LayerMetadata metadata,
4225 sp<IBinder>* handle, sp<Layer>* outLayer) {
4226 *outLayer = getFactory().createColorLayer(
4227 LayerCreationArgs(this, client, name, w, h, flags, std::move(metadata)));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004228 *handle = (*outLayer)->getHandle();
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004229 return NO_ERROR;
Mathias Agopian118d0242011-10-13 16:02:48 -07004230}
4231
Evan Roskya1f1e152019-01-24 16:17:46 -08004232status_t SurfaceFlinger::createContainerLayer(const sp<Client>& client, const String8& name,
4233 uint32_t w, uint32_t h, uint32_t flags,
4234 LayerMetadata metadata, sp<IBinder>* handle,
4235 sp<Layer>* outLayer) {
4236 *outLayer = getFactory().createContainerLayer(
4237 LayerCreationArgs(this, client, name, w, h, flags, std::move(metadata)));
Robert Carr6b3f6c52018-08-13 13:05:17 -07004238 *handle = (*outLayer)->getHandle();
4239 return NO_ERROR;
4240}
4241
4242
Robert Carr6fb1a7e2018-12-11 12:07:25 -08004243void SurfaceFlinger::markLayerPendingRemovalLocked(const sp<Layer>& layer) {
Robert Carr2e102c92018-10-23 12:11:15 -07004244 mLayersPendingRemoval.add(layer);
4245 mLayersRemoved = true;
4246 setTransactionFlags(eTransactionNeeded);
4247}
4248
Robert Carr695d5282018-12-18 15:27:58 -08004249void SurfaceFlinger::onHandleDestroyed(sp<Layer>& layer)
Rob Carr4bba3702018-10-08 21:53:30 +00004250{
Robert Carr2e102c92018-10-23 12:11:15 -07004251 Mutex::Autolock lock(mStateLock);
Robert Carr6fb1a7e2018-12-11 12:07:25 -08004252 // If a layer has a parent, we allow it to out-live it's handle
4253 // with the idea that the parent holds a reference and will eventually
4254 // be cleaned up. However no one cleans up the top-level so we do so
4255 // here.
4256 if (layer->getParent() == nullptr) {
4257 mCurrentState.layersSortedByZ.remove(layer);
4258 }
4259 markLayerPendingRemovalLocked(layer);
Robert Carr695d5282018-12-18 15:27:58 -08004260 layer.clear();
Rob Carr4bba3702018-10-08 21:53:30 +00004261}
4262
Mathias Agopianb60314a2012-04-10 22:09:54 -07004263// ---------------------------------------------------------------------------
4264
Andy McFadden13a082e2012-08-24 10:16:42 -07004265void SurfaceFlinger::onInitializeDisplays() {
Dominik Laskowski83b88212018-12-11 13:34:06 -08004266 const auto display = getDefaultDisplayDeviceLocked();
4267 if (!display) return;
4268
4269 const sp<IBinder> token = display->getDisplayToken().promote();
4270 LOG_ALWAYS_FATAL_IF(token == nullptr);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004271
Jesse Hall01e29052013-02-19 16:13:35 -08004272 // reset screen orientation and use primary layer stack
Andy McFadden13a082e2012-08-24 10:16:42 -07004273 Vector<ComposerState> state;
4274 Vector<DisplayState> displays;
4275 DisplayState d;
Jesse Hall01e29052013-02-19 16:13:35 -08004276 d.what = DisplayState::eDisplayProjectionChanged |
4277 DisplayState::eLayerStackChanged;
Dominik Laskowski83b88212018-12-11 13:34:06 -08004278 d.token = token;
Jesse Hall01e29052013-02-19 16:13:35 -08004279 d.layerStack = 0;
Andy McFadden13a082e2012-08-24 10:16:42 -07004280 d.orientation = DisplayState::eOrientationDefault;
Jeff Brown4c05dd12012-09-09 00:07:17 -07004281 d.frame.makeInvalid();
4282 d.viewport.makeInvalid();
Michael Lentine47e45402014-07-18 15:34:25 -07004283 d.width = 0;
4284 d.height = 0;
Andy McFadden13a082e2012-08-24 10:16:42 -07004285 displays.add(d);
Marissa Wall3dad52d2019-03-22 14:03:19 -07004286 setTransactionState(state, displays, 0, nullptr, mPendingInputWindowCommands, -1, {}, {});
Jamie Gennis6547ff42013-07-16 20:12:42 -07004287
Dominik Laskowskie9774092018-12-11 10:04:24 -08004288 setPowerModeInternal(display, HWC_POWER_MODE_NORMAL);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004289
Dominik Laskowski83b88212018-12-11 13:34:06 -08004290 const nsecs_t vsyncPeriod = getVsyncPeriod();
4291 mAnimFrameTracker.setDisplayRefreshPeriod(vsyncPeriod);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08004292
Brian Andersond0010582017-03-07 13:20:31 -08004293 // Use phase of 0 since phase is not known.
4294 // Use latency of 0, which will snap to the ideal latency.
Dominik Laskowski83b88212018-12-11 13:34:06 -08004295 DisplayStatInfo stats{0 /* vsyncTime */, vsyncPeriod};
Ana Krulece588e312018-09-18 12:32:24 -07004296 setCompositorTimingSnapped(stats, 0);
Andy McFadden13a082e2012-08-24 10:16:42 -07004297}
4298
4299void SurfaceFlinger::initializeDisplays() {
Dominik Laskowski8c001672018-05-30 16:52:06 -07004300 // Async since we may be called from the main thread.
Dominik Laskowski83b88212018-12-11 13:34:06 -08004301 postMessageAsync(
4302 new LambdaMessage([this]() NO_THREAD_SAFETY_ANALYSIS { onInitializeDisplays(); }));
Andy McFadden13a082e2012-08-24 10:16:42 -07004303}
4304
Dominik Laskowskie9774092018-12-11 10:04:24 -08004305void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& display, int mode) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004306 if (display->isVirtual()) {
4307 ALOGE("%s: Invalid operation on virtual display", __FUNCTION__);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004308 return;
4309 }
4310
Dominik Laskowski075d3172018-05-24 15:50:06 -07004311 const auto displayId = display->getId();
4312 LOG_ALWAYS_FATAL_IF(!displayId);
4313
Dominik Laskowski34157762018-10-31 13:07:19 -07004314 ALOGD("Setting power mode %d on display %s", mode, to_string(*displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004315
4316 int currentMode = display->getPowerMode();
4317 if (mode == currentMode) {
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004318 return;
4319 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004320
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004321 display->setPowerMode(mode);
4322
Lloyd Pique4dccc412018-01-22 17:21:36 -08004323 if (mInterceptor->isEnabled()) {
Dominik Laskowskie9774092018-12-11 10:04:24 -08004324 mInterceptor->savePowerModeUpdate(display->getSequenceId(), mode);
Irvelffc9efc2016-07-27 15:16:37 -07004325 }
4326
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004327 if (currentMode == HWC_POWER_MODE_OFF) {
Tim Murrayf9d4e442016-08-02 15:43:59 -07004328 // Turn on the display
Dominik Laskowski075d3172018-05-24 15:50:06 -07004329 getHwComposer().setPowerMode(*displayId, mode);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004330 if (display->isPrimary() && mode != HWC_POWER_MODE_DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08004331 mScheduler->onScreenAcquired(mAppConnectionHandle);
4332 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004333 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004334
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004335 mVisibleRegionsDirty = true;
Dan Stozab90cf072015-03-05 11:05:59 -08004336 mHasPoweredOff = true;
Dan Stozac7a25ad2018-04-12 11:45:09 -07004337 repaintEverything();
Tim Murrayf9d4e442016-08-02 15:43:59 -07004338
4339 struct sched_param param = {0};
4340 param.sched_priority = 1;
4341 if (sched_setscheduler(0, SCHED_FIFO, &param) != 0) {
4342 ALOGW("Couldn't set SCHED_FIFO on display on");
4343 }
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004344 } else if (mode == HWC_POWER_MODE_OFF) {
Tim Murrayf9d4e442016-08-02 15:43:59 -07004345 // Turn off the display
4346 struct sched_param param = {0};
4347 if (sched_setscheduler(0, SCHED_OTHER, &param) != 0) {
4348 ALOGW("Couldn't set SCHED_OTHER on display off");
4349 }
4350
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004351 if (display->isPrimary() && currentMode != HWC_POWER_MODE_DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08004352 mScheduler->disableHardwareVsync(true);
4353 mScheduler->onScreenReleased(mAppConnectionHandle);
Mathias Agopiancde87a32012-09-13 14:09:01 -07004354 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004355
Dominik Laskowski075d3172018-05-24 15:50:06 -07004356 getHwComposer().setPowerMode(*displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004357 mVisibleRegionsDirty = true;
4358 // from this point on, SF will stop drawing on this display
Matthew Bouyack38d49612017-05-12 12:49:32 -07004359 } else if (mode == HWC_POWER_MODE_DOZE ||
4360 mode == HWC_POWER_MODE_NORMAL) {
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004361 // Update display while dozing
Dominik Laskowski075d3172018-05-24 15:50:06 -07004362 getHwComposer().setPowerMode(*displayId, mode);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004363 if (display->isPrimary() && currentMode == HWC_POWER_MODE_DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08004364 mScheduler->onScreenAcquired(mAppConnectionHandle);
4365 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004366 }
4367 } else if (mode == HWC_POWER_MODE_DOZE_SUSPEND) {
4368 // Leave display going to doze
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004369 if (display->isPrimary()) {
Ana Krulecc2870422019-01-29 19:00:58 -08004370 mScheduler->disableHardwareVsync(true);
4371 mScheduler->onScreenReleased(mAppConnectionHandle);
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004372 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07004373 getHwComposer().setPowerMode(*displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004374 } else {
Matthew Bouyack38d49612017-05-12 12:49:32 -07004375 ALOGE("Attempting to set unknown power mode: %d\n", mode);
Dominik Laskowski075d3172018-05-24 15:50:06 -07004376 getHwComposer().setPowerMode(*displayId, mode);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004377 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004378
Yiwei Zhang3a226d22018-10-16 09:23:03 -07004379 if (display->isPrimary()) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08004380 mTimeStats->setPowerMode(mode);
Ana Krulecc2870422019-01-29 19:00:58 -08004381 if (mRefreshRateStats) {
Ana Krulecb43429d2019-01-09 14:28:51 -08004382 // Update refresh rate stats.
4383 mRefreshRateStats->setPowerMode(mode);
4384 }
Yiwei Zhang3a226d22018-10-16 09:23:03 -07004385 }
4386
Dominik Laskowski34157762018-10-31 13:07:19 -07004387 ALOGD("Finished setting power mode %d on display %s", mode, to_string(*displayId).c_str());
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004388}
4389
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004390void SurfaceFlinger::setPowerMode(const sp<IBinder>& displayToken, int mode) {
Dominik Laskowski83b88212018-12-11 13:34:06 -08004391 postMessageSync(new LambdaMessage([&]() NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004392 const auto display = getDisplayDevice(displayToken);
4393 if (!display) {
4394 ALOGE("Attempt to set power mode %d for invalid display token %p", mode,
4395 displayToken.get());
4396 } else if (display->isVirtual()) {
4397 ALOGW("Attempt to set power mode %d for virtual display", mode);
4398 } else {
Dominik Laskowskie9774092018-12-11 10:04:24 -08004399 setPowerModeInternal(display, mode);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004400 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004401 }));
Mathias Agopianb60314a2012-04-10 22:09:54 -07004402}
4403
4404// ---------------------------------------------------------------------------
4405
Dominik Laskowskic2867142019-01-21 11:33:38 -08004406status_t SurfaceFlinger::doDump(int fd, const DumpArgs& args,
4407 bool asProto) NO_THREAD_SAFETY_ANALYSIS {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004408 std::string result;
Mathias Agopian99b49842011-06-27 16:05:52 -07004409
Mathias Agopianbd115332013-04-18 16:41:04 -07004410 IPCThreadState* ipc = IPCThreadState::self();
4411 const int pid = ipc->getCallingPid();
4412 const int uid = ipc->getCallingUid();
Vishnu Nair6a408532017-10-24 09:11:27 -07004413
Mathias Agopianbd115332013-04-18 16:41:04 -07004414 if ((uid != AID_SHELL) &&
4415 !PermissionCache::checkPermission(sDump, pid, uid)) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004416 StringAppendF(&result, "Permission Denial: can't dump SurfaceFlinger from pid=%d, uid=%d\n",
4417 pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004418 } else {
Jesse Hallfcd15b42014-12-23 13:57:23 -08004419 // Try to get the main lock, but give up after one second
Mathias Agopian9795c422009-08-26 16:36:26 -07004420 // (this would indicate SF is stuck, but we want to be able to
4421 // print something in dumpsys).
Jesse Hallfcd15b42014-12-23 13:57:23 -08004422 status_t err = mStateLock.timedLock(s2ns(1));
4423 bool locked = (err == NO_ERROR);
Mathias Agopian9795c422009-08-26 16:36:26 -07004424 if (!locked) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004425 StringAppendF(&result,
4426 "SurfaceFlinger appears to be unresponsive (%s [%d]), dumping anyways "
4427 "(no locks held)\n",
4428 strerror(-err), err);
Mathias Agopian9795c422009-08-26 16:36:26 -07004429 }
4430
Dominik Laskowskic2867142019-01-21 11:33:38 -08004431 using namespace std::string_literals;
chaviwa3d7bd32017-11-03 09:41:53 -07004432
Dominik Laskowskic2867142019-01-21 11:33:38 -08004433 static const std::unordered_map<std::string, Dumper> dumpers = {
4434 {"--clear-layer-stats"s, dumper([this](std::string&) { mLayerStats.clear(); })},
4435 {"--disable-layer-stats"s, dumper([this](std::string&) { mLayerStats.disable(); })},
4436 {"--display-id"s, dumper(&SurfaceFlinger::dumpDisplayIdentificationData)},
Ady Abraham3aff9172019-02-07 19:10:26 -08004437 {"--dispsync"s, dumper([this](std::string& s) {
Ady Abraham3aff9172019-02-07 19:10:26 -08004438 mScheduler->dumpPrimaryDispSync(s);
Ady Abraham3aff9172019-02-07 19:10:26 -08004439 })},
Dominik Laskowskic2867142019-01-21 11:33:38 -08004440 {"--dump-layer-stats"s, dumper([this](std::string& s) { mLayerStats.dump(s); })},
4441 {"--enable-layer-stats"s, dumper([this](std::string&) { mLayerStats.enable(); })},
Dominik Laskowskic2867142019-01-21 11:33:38 -08004442 {"--frame-events"s, dumper(&SurfaceFlinger::dumpFrameEventsLocked)},
4443 {"--latency"s, argsDumper(&SurfaceFlinger::dumpStatsLocked)},
4444 {"--latency-clear"s, argsDumper(&SurfaceFlinger::clearStatsLocked)},
4445 {"--list"s, dumper(&SurfaceFlinger::listLayersLocked)},
4446 {"--static-screen"s, dumper(&SurfaceFlinger::dumpStaticScreenStats)},
4447 {"--timestats"s, protoDumper(&SurfaceFlinger::dumpTimeStats)},
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004448 {"--vsync"s, dumper(&SurfaceFlinger::dumpVSync)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08004449 {"--wide-color"s, dumper(&SurfaceFlinger::dumpWideColorInfo)},
4450 };
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004451
Dominik Laskowskic2867142019-01-21 11:33:38 -08004452 const auto flag = args.empty() ? ""s : std::string(String8(args[0]));
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004453
Dominik Laskowskic2867142019-01-21 11:33:38 -08004454 if (const auto it = dumpers.find(flag); it != dumpers.end()) {
4455 (it->second)(args, asProto, result);
4456 } else {
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07004457 if (asProto) {
4458 LayersProto layersProto = dumpProtoInfo(LayerVector::StateSet::Current);
4459 result.append(layersProto.SerializeAsString().c_str(), layersProto.ByteSize());
4460 } else {
Dominik Laskowskic2867142019-01-21 11:33:38 -08004461 dumpAllLocked(args, result);
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07004462 }
Mathias Agopian48b888a2011-01-19 16:15:53 -08004463 }
4464
Mathias Agopian9795c422009-08-26 16:36:26 -07004465 if (locked) {
4466 mStateLock.unlock();
4467 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004468 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08004469 write(fd, result.c_str(), result.size());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004470 return NO_ERROR;
4471}
4472
Nataniel Borges8e7dc722019-02-28 15:10:28 -08004473status_t SurfaceFlinger::dumpCritical(int fd, const DumpArgs&, bool asProto) {
4474 if (asProto && mTracing.isEnabled()) {
4475 mTracing.writeToFileAsync();
4476 }
4477
4478 return doDump(fd, DumpArgs(), asProto);
4479}
4480
Dominik Laskowskic2867142019-01-21 11:33:38 -08004481void SurfaceFlinger::listLayersLocked(std::string& result) const {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004482 mCurrentState.traverseInZOrder(
4483 [&](Layer* layer) { StringAppendF(&result, "%s\n", layer->getName().string()); });
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004484}
4485
Dominik Laskowskic2867142019-01-21 11:33:38 -08004486void SurfaceFlinger::dumpStatsLocked(const DumpArgs& args, std::string& result) const {
Dominik Laskowski83b88212018-12-11 13:34:06 -08004487 StringAppendF(&result, "%" PRId64 "\n", getVsyncPeriod());
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004488
Dominik Laskowskic2867142019-01-21 11:33:38 -08004489 if (args.size() > 1) {
4490 const auto name = String8(args[1]);
Robert Carr2047fae2016-11-28 14:09:09 -08004491 mCurrentState.traverseInZOrder([&](Layer* layer) {
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004492 if (name == layer->getName()) {
Svetoslavd85084b2014-03-20 10:28:31 -07004493 layer->dumpFrameStats(result);
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004494 }
Robert Carr2047fae2016-11-28 14:09:09 -08004495 });
Dominik Laskowskic2867142019-01-21 11:33:38 -08004496 } else {
4497 mAnimFrameTracker.dumpStats(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004498 }
4499}
4500
Dominik Laskowskic2867142019-01-21 11:33:38 -08004501void SurfaceFlinger::clearStatsLocked(const DumpArgs& args, std::string&) {
Robert Carr2047fae2016-11-28 14:09:09 -08004502 mCurrentState.traverseInZOrder([&](Layer* layer) {
Dominik Laskowskic2867142019-01-21 11:33:38 -08004503 if (args.size() < 2 || String8(args[1]) == layer->getName()) {
Svetoslavd85084b2014-03-20 10:28:31 -07004504 layer->clearFrameStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004505 }
Robert Carr2047fae2016-11-28 14:09:09 -08004506 });
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004507
Svetoslavd85084b2014-03-20 10:28:31 -07004508 mAnimFrameTracker.clearStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004509}
4510
Dominik Laskowskic2867142019-01-21 11:33:38 -08004511void SurfaceFlinger::dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const {
4512 mTimeStats->parseArgs(asProto, args, result);
4513}
4514
Jamie Gennis6547ff42013-07-16 20:12:42 -07004515// This should only be called from the main thread. Otherwise it would need
4516// the lock and should use mCurrentState rather than mDrawingState.
4517void SurfaceFlinger::logFrameStats() {
Robert Carr2047fae2016-11-28 14:09:09 -08004518 mDrawingState.traverseInZOrder([&](Layer* layer) {
Jamie Gennis6547ff42013-07-16 20:12:42 -07004519 layer->logFrameStats();
Robert Carr2047fae2016-11-28 14:09:09 -08004520 });
Jamie Gennis6547ff42013-07-16 20:12:42 -07004521
4522 mAnimFrameTracker.logAndResetStats(String8("<win-anim>"));
4523}
4524
Yiwei Zhang5434a782018-12-05 18:06:32 -08004525void SurfaceFlinger::appendSfConfigString(std::string& result) const {
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004526 result.append(" [sf");
Fabien Sanglardc93afd52017-03-13 13:02:42 -07004527
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004528 if (isLayerTripleBufferingDisabled())
4529 result.append(" DISABLE_TRIPLE_BUFFERING");
Fabien Sanglardc45a7d92017-03-14 13:24:22 -07004530
Yiwei Zhang5434a782018-12-05 18:06:32 -08004531 StringAppendF(&result, " PRESENT_TIME_OFFSET=%" PRId64, dispSyncPresentTimeOffset);
4532 StringAppendF(&result, " FORCE_HWC_FOR_RBG_TO_YUV=%d", useHwcForRgbToYuv);
4533 StringAppendF(&result, " MAX_VIRT_DISPLAY_DIM=%" PRIu64, maxVirtualDisplaySize);
4534 StringAppendF(&result, " RUNNING_WITHOUT_SYNC_FRAMEWORK=%d", !hasSyncFramework);
4535 StringAppendF(&result, " NUM_FRAMEBUFFER_SURFACE_BUFFERS=%" PRId64,
4536 maxFrameBufferAcquiredBuffers);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004537 result.append("]");
Andy McFadden4803b742012-09-24 19:07:20 -07004538}
4539
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004540void SurfaceFlinger::dumpVSync(std::string& result) const {
Ana Krulec757f63a2019-01-25 10:46:18 -08004541 mPhaseOffsets->dump(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004542 StringAppendF(&result,
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004543 " present offset: %9" PRId64 " ns\t VSYNC period: %9" PRId64 " ns\n\n",
Ana Krulec757f63a2019-01-25 10:46:18 -08004544 dispSyncPresentTimeOffset, getVsyncPeriod());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004545
Ady Abraham97d04232019-03-05 19:48:12 -08004546 StringAppendF(&result, "Scheduler enabled.");
Ana Krulecba13ab32019-02-20 14:14:12 -08004547 StringAppendF(&result, "+ Smart 90 for video detection: %s\n\n",
4548 mUseSmart90ForVideo ? "on" : "off");
Ana Krulecc2870422019-01-29 19:00:58 -08004549 mScheduler->dump(mAppConnectionHandle, result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004550}
4551
Yiwei Zhang5434a782018-12-05 18:06:32 -08004552void SurfaceFlinger::dumpStaticScreenStats(std::string& result) const {
4553 result.append("Static screen stats:\n");
David Sodman4a36e932017-11-07 14:29:47 -08004554 for (size_t b = 0; b < SurfaceFlingerBE::NUM_BUCKETS - 1; ++b) {
4555 float bucketTimeSec = getBE().mFrameBuckets[b] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08004556 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08004557 static_cast<float>(getBE().mFrameBuckets[b]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004558 StringAppendF(&result, " < %zd frames: %.3f s (%.1f%%)\n", b + 1, bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08004559 }
David Sodman4a36e932017-11-07 14:29:47 -08004560 float bucketTimeSec = getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08004561 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08004562 static_cast<float>(getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004563 StringAppendF(&result, " %zd+ frames: %.3f s (%.1f%%)\n", SurfaceFlingerBE::NUM_BUCKETS - 1,
4564 bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08004565}
4566
Dan Stozae77c7662016-05-13 11:37:28 -07004567void SurfaceFlinger::recordBufferingStats(const char* layerName,
4568 std::vector<OccupancyTracker::Segment>&& history) {
David Sodmancbaf0832017-11-07 14:21:36 -08004569 Mutex::Autolock lock(getBE().mBufferingStatsMutex);
4570 auto& stats = getBE().mBufferingStats[layerName];
Dan Stozae77c7662016-05-13 11:37:28 -07004571 for (const auto& segment : history) {
4572 if (!segment.usedThirdBuffer) {
4573 stats.twoBufferTime += segment.totalTime;
4574 }
4575 if (segment.occupancyAverage < 1.0f) {
4576 stats.doubleBufferedTime += segment.totalTime;
4577 } else if (segment.occupancyAverage < 2.0f) {
4578 stats.tripleBufferedTime += segment.totalTime;
4579 }
4580 ++stats.numSegments;
4581 stats.totalTime += segment.totalTime;
4582 }
4583}
4584
Yiwei Zhang5434a782018-12-05 18:06:32 -08004585void SurfaceFlinger::dumpFrameEventsLocked(std::string& result) {
4586 result.append("Layer frame timestamps:\n");
Brian Andersond6927fb2016-07-23 23:37:30 -07004587
4588 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
4589 const size_t count = currentLayers.size();
4590 for (size_t i=0 ; i<count ; i++) {
4591 currentLayers[i]->dumpFrameEvents(result);
4592 }
4593}
4594
Yiwei Zhang5434a782018-12-05 18:06:32 -08004595void SurfaceFlinger::dumpBufferingStats(std::string& result) const {
Dan Stozae77c7662016-05-13 11:37:28 -07004596 result.append("Buffering stats:\n");
4597 result.append(" [Layer name] <Active time> <Two buffer> "
4598 "<Double buffered> <Triple buffered>\n");
David Sodmancbaf0832017-11-07 14:21:36 -08004599 Mutex::Autolock lock(getBE().mBufferingStatsMutex);
Dan Stozae77c7662016-05-13 11:37:28 -07004600 typedef std::tuple<std::string, float, float, float> BufferTuple;
4601 std::map<float, BufferTuple, std::greater<float>> sorted;
David Sodmancbaf0832017-11-07 14:21:36 -08004602 for (const auto& statsPair : getBE().mBufferingStats) {
Dan Stozae77c7662016-05-13 11:37:28 -07004603 const char* name = statsPair.first.c_str();
David Sodmancbaf0832017-11-07 14:21:36 -08004604 const SurfaceFlingerBE::BufferingStats& stats = statsPair.second;
Dan Stozae77c7662016-05-13 11:37:28 -07004605 if (stats.numSegments == 0) {
4606 continue;
4607 }
4608 float activeTime = ns2ms(stats.totalTime) / 1000.0f;
4609 float twoBufferRatio = static_cast<float>(stats.twoBufferTime) /
4610 stats.totalTime;
4611 float doubleBufferRatio = static_cast<float>(
4612 stats.doubleBufferedTime) / stats.totalTime;
4613 float tripleBufferRatio = static_cast<float>(
4614 stats.tripleBufferedTime) / stats.totalTime;
4615 sorted.insert({activeTime, {name, twoBufferRatio,
4616 doubleBufferRatio, tripleBufferRatio}});
4617 }
4618 for (const auto& sortedPair : sorted) {
4619 float activeTime = sortedPair.first;
4620 const BufferTuple& values = sortedPair.second;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004621 StringAppendF(&result, " [%s] %.2f %.3f %.3f %.3f\n", std::get<0>(values).c_str(),
4622 activeTime, std::get<1>(values), std::get<2>(values), std::get<3>(values));
Dan Stozae77c7662016-05-13 11:37:28 -07004623 }
4624 result.append("\n");
4625}
4626
Yiwei Zhang5434a782018-12-05 18:06:32 -08004627void SurfaceFlinger::dumpDisplayIdentificationData(std::string& result) const {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004628 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004629 const auto displayId = display->getId();
4630 if (!displayId) {
4631 continue;
4632 }
4633 const auto hwcDisplayId = getHwComposer().fromPhysicalDisplayId(*displayId);
Dominik Laskowski7e045462018-05-30 13:02:02 -07004634 if (!hwcDisplayId) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004635 continue;
4636 }
4637
Yiwei Zhang5434a782018-12-05 18:06:32 -08004638 StringAppendF(&result,
4639 "Display %s (HWC display %" PRIu64 "): ", to_string(*displayId).c_str(),
4640 *hwcDisplayId);
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004641 uint8_t port;
4642 DisplayIdentificationData data;
Dominik Laskowski7e045462018-05-30 13:02:02 -07004643 if (!getHwComposer().getDisplayIdentificationData(*hwcDisplayId, &port, &data)) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004644 result.append("no identification data\n");
4645 continue;
4646 }
4647
4648 if (!isEdid(data)) {
4649 result.append("unknown identification data: ");
4650 for (uint8_t byte : data) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004651 StringAppendF(&result, "%x ", byte);
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004652 }
4653 result.append("\n");
4654 continue;
4655 }
4656
4657 const auto edid = parseEdid(data);
4658 if (!edid) {
4659 result.append("invalid EDID: ");
4660 for (uint8_t byte : data) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004661 StringAppendF(&result, "%x ", byte);
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004662 }
4663 result.append("\n");
4664 continue;
4665 }
4666
Yiwei Zhang5434a782018-12-05 18:06:32 -08004667 StringAppendF(&result, "port=%u pnpId=%s displayName=\"", port, edid->pnpId.data());
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004668 result.append(edid->displayName.data(), edid->displayName.length());
4669 result.append("\"\n");
4670 }
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004671}
4672
Yiwei Zhang5434a782018-12-05 18:06:32 -08004673void SurfaceFlinger::dumpWideColorInfo(std::string& result) const {
4674 StringAppendF(&result, "Device has wide color display: %d\n", hasWideColorDisplay);
4675 StringAppendF(&result, "Device uses color management: %d\n", useColorManagement);
4676 StringAppendF(&result, "DisplayColorSetting: %s\n",
4677 decodeDisplayColorSetting(mDisplayColorSetting).c_str());
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004678
4679 // TODO: print out if wide-color mode is active or not
4680
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004681 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004682 const auto displayId = display->getId();
4683 if (!displayId) {
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004684 continue;
4685 }
4686
Yiwei Zhang5434a782018-12-05 18:06:32 -08004687 StringAppendF(&result, "Display %s color modes:\n", to_string(*displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004688 std::vector<ColorMode> modes = getHwComposer().getColorModes(*displayId);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004689 for (auto&& mode : modes) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004690 StringAppendF(&result, " %s (%d)\n", decodeColorMode(mode).c_str(), mode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004691 }
4692
Lloyd Pique32cbe282018-10-19 13:09:22 -07004693 ColorMode currentMode = display->getCompositionDisplay()->getState().colorMode;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004694 StringAppendF(&result, " Current color mode: %s (%d)\n",
4695 decodeColorMode(currentMode).c_str(), currentMode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004696 }
4697 result.append("\n");
4698}
4699
Vishnu Nair9245d3b2019-03-22 13:38:56 -07004700LayersProto SurfaceFlinger::dumpProtoInfo(LayerVector::StateSet stateSet,
4701 uint32_t traceFlags) const {
chaviw1d044282017-09-27 12:19:28 -07004702 LayersProto layersProto;
Jorim Jaggi8e0af362017-11-14 16:28:28 +01004703 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
4704 const State& state = useDrawing ? mDrawingState : mCurrentState;
4705 state.traverseInZOrder([&](Layer* layer) {
chaviw1d044282017-09-27 12:19:28 -07004706 LayerProto* layerProto = layersProto.add_layers();
Vishnu Nair9245d3b2019-03-22 13:38:56 -07004707 layer->writeToProto(layerProto, stateSet, traceFlags);
chaviw1d044282017-09-27 12:19:28 -07004708 });
4709
4710 return layersProto;
4711}
4712
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004713LayersProto SurfaceFlinger::dumpVisibleLayersProtoInfo(
4714 const sp<DisplayDevice>& displayDevice) const {
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004715 LayersProto layersProto;
Yiwei Zhang60d1a192018-03-07 14:52:28 -08004716
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004717 SizeProto* resolution = layersProto.mutable_resolution();
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004718 resolution->set_w(displayDevice->getWidth());
4719 resolution->set_h(displayDevice->getHeight());
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004720
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004721 auto display = displayDevice->getCompositionDisplay();
Lloyd Pique32cbe282018-10-19 13:09:22 -07004722 const auto& displayState = display->getState();
Yiwei Zhang60d1a192018-03-07 14:52:28 -08004723
Lloyd Pique32cbe282018-10-19 13:09:22 -07004724 layersProto.set_color_mode(decodeColorMode(displayState.colorMode));
4725 layersProto.set_color_transform(decodeColorTransform(displayState.colorTransform));
4726 layersProto.set_global_transform(displayState.orientation);
4727
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004728 const auto displayId = displayDevice->getId();
Dominik Laskowski075d3172018-05-24 15:50:06 -07004729 LOG_ALWAYS_FATAL_IF(!displayId);
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004730 mDrawingState.traverseInZOrder([&](Layer* layer) {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004731 if (!layer->visibleRegion.isEmpty() && !display->getOutputLayersOrderedByZ().empty()) {
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004732 LayerProto* layerProto = layersProto.add_layers();
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004733 layer->writeToProto(layerProto, displayDevice);
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004734 }
4735 });
4736
4737 return layersProto;
4738}
4739
Dominik Laskowskic2867142019-01-21 11:33:38 -08004740void SurfaceFlinger::dumpAllLocked(const DumpArgs& args, std::string& result) const {
4741 const bool colorize = !args.empty() && args[0] == String16("--color");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004742 Colorizer colorizer(colorize);
4743
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004744 // figure out if we're stuck somewhere
4745 const nsecs_t now = systemTime();
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004746 const nsecs_t inTransaction(mDebugInTransaction);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004747 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
4748
4749 /*
Andy McFadden4803b742012-09-24 19:07:20 -07004750 * Dump library configuration.
4751 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004752
4753 colorizer.bold(result);
Andy McFadden4803b742012-09-24 19:07:20 -07004754 result.append("Build configuration:");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004755 colorizer.reset(result);
Andy McFadden4803b742012-09-24 19:07:20 -07004756 appendSfConfigString(result);
4757 appendUiConfigString(result);
4758 appendGuiConfigString(result);
4759 result.append("\n");
4760
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004761 result.append("\nDisplay identification data:\n");
4762 dumpDisplayIdentificationData(result);
4763
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004764 result.append("\nWide-Color information:\n");
4765 dumpWideColorInfo(result);
4766
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004767 colorizer.bold(result);
Mathias Agopianca088332013-03-28 17:44:13 -07004768 result.append("Sync configuration: ");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004769 colorizer.reset(result);
Mathias Agopianca088332013-03-28 17:44:13 -07004770 result.append(SyncFeatures::getInstance().toString());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004771 result.append("\n\n");
Mathias Agopianca088332013-03-28 17:44:13 -07004772
Andy McFadden41d67d72014-04-25 16:58:34 -07004773 colorizer.bold(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004774 result.append("VSYNC configuration:\n");
Andy McFadden41d67d72014-04-25 16:58:34 -07004775 colorizer.reset(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004776 dumpVSync(result);
Dan Stozab90cf072015-03-05 11:05:59 -08004777 result.append("\n");
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004778
Dan Stozab90cf072015-03-05 11:05:59 -08004779 dumpStaticScreenStats(result);
4780 result.append("\n");
4781
Alec Mouri40189b02019-03-05 15:07:54 -08004782 StringAppendF(&result, "Total missed frame count: %u\n", mFrameMissedCount.load());
4783 StringAppendF(&result, "HWC missed frame count: %u\n", mHwcFrameMissedCount.load());
4784 StringAppendF(&result, "GPU missed frame count: %u\n\n", mGpuFrameMissedCount.load());
Marissa Wallcfcdaa52018-05-21 15:45:59 -07004785
Dan Stozae77c7662016-05-13 11:37:28 -07004786 dumpBufferingStats(result);
4787
Andy McFadden4803b742012-09-24 19:07:20 -07004788 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004789 * Dump the visible layer list
4790 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004791 colorizer.bold(result);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004792 StringAppendF(&result, "Visible layers (count = %zu)\n", mNumLayers);
4793 StringAppendF(&result, "GraphicBufferProducers: %zu, max %zu\n",
4794 mGraphicBufferProducerList.size(), mMaxGraphicBufferProducerListSize);
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004795 colorizer.reset(result);
chaviw1d044282017-09-27 12:19:28 -07004796
Chia-I Wu2f884132018-09-13 15:17:58 -07004797 {
4798 LayersProto layersProto = dumpProtoInfo(LayerVector::StateSet::Current);
4799 auto layerTree = LayerProtoParser::generateLayerTree(layersProto);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004800 result.append(LayerProtoParser::layerTreeToString(layerTree));
Chia-I Wu2f884132018-09-13 15:17:58 -07004801 result.append("\n");
4802 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004803
Lloyd Pique207def92019-02-28 16:09:52 -08004804 {
4805 StringAppendF(&result, "Composition layers\n");
4806 mDrawingState.traverseInZOrder([&](Layer* layer) {
4807 auto compositionLayer = layer->getCompositionLayer();
4808 if (compositionLayer) compositionLayer->dump(result);
4809 });
4810 }
4811
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004812 /*
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004813 * Dump Display state
4814 */
4815
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004816 colorizer.bold(result);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004817 StringAppendF(&result, "Displays (%zu entries)\n", mDisplays.size());
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004818 colorizer.reset(result);
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004819 for (const auto& [token, display] : mDisplays) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004820 display->dump(result);
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004821 }
Chia-I Wu1e043612018-03-01 09:45:09 -08004822 result.append("\n");
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004823
4824 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004825 * Dump SurfaceFlinger global state
4826 */
4827
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004828 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02004829 result.append("SurfaceFlinger global state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004830 colorizer.reset(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004831
Lloyd Piqueb97e04f2018-10-18 17:07:05 -07004832 getRenderEngine().dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004833
Dominik Laskowski075d3172018-05-24 15:50:06 -07004834 if (const auto display = getDefaultDisplayDeviceLocked()) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07004835 display->getCompositionDisplay()->getState().undefinedRegion.dump(result,
4836 "undefinedRegion");
Yiwei Zhang5434a782018-12-05 18:06:32 -08004837 StringAppendF(&result, " orientation=%d, isPoweredOn=%d\n", display->getOrientation(),
4838 display->isPoweredOn());
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08004839 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08004840 StringAppendF(&result,
4841 " transaction-flags : %08x\n"
4842 " gpu_to_cpu_unsupported : %d\n",
4843 mTransactionFlags.load(), !mGpuToCpuSupported);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004844
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08004845 if (const auto displayId = getInternalDisplayIdLocked();
Dominik Laskowski075d3172018-05-24 15:50:06 -07004846 displayId && getHwComposer().isConnected(*displayId)) {
4847 const auto activeConfig = getHwComposer().getActiveConfig(*displayId);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004848 StringAppendF(&result,
4849 " refresh-rate : %f fps\n"
4850 " x-dpi : %f\n"
4851 " y-dpi : %f\n",
4852 1e9 / activeConfig->getVsyncPeriod(), activeConfig->getDpiX(),
4853 activeConfig->getDpiY());
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004854 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004855
Yiwei Zhang5434a782018-12-05 18:06:32 -08004856 StringAppendF(&result, " transaction time: %f us\n", inTransactionDuration / 1000.0);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004857
Dan Stozae22aec72016-08-01 13:20:59 -07004858 /*
Yichi Chenadc69612018-09-15 14:51:18 +08004859 * Tracing state
4860 */
4861 mTracing.dump(result);
4862 result.append("\n");
4863
4864 /*
Dan Stozae22aec72016-08-01 13:20:59 -07004865 * HWC layer minidump
4866 */
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004867 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004868 const auto displayId = display->getId();
4869 if (!displayId) {
Dan Stozae22aec72016-08-01 13:20:59 -07004870 continue;
4871 }
4872
Yiwei Zhang5434a782018-12-05 18:06:32 -08004873 StringAppendF(&result, "Display %s HWC layers:\n", to_string(*displayId).c_str());
Dan Stozae22aec72016-08-01 13:20:59 -07004874 Layer::miniDumpHeader(result);
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004875 const sp<DisplayDevice> displayDevice = display;
4876 mCurrentState.traverseInZOrder(
4877 [&](Layer* layer) { layer->miniDump(result, displayDevice); });
Dan Stozae22aec72016-08-01 13:20:59 -07004878 result.append("\n");
4879 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004880
4881 /*
4882 * Dump HWComposer state
4883 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004884 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02004885 result.append("h/w composer state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004886 colorizer.reset(result);
Dan Stoza9f26a9c2016-06-22 14:51:09 -07004887 bool hwcDisabled = mDebugDisableHWC || mDebugRegion;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004888 StringAppendF(&result, " h/w composer %s\n", hwcDisabled ? "disabled" : "enabled");
Dominik Laskowski075d3172018-05-24 15:50:06 -07004889 getHwComposer().dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004890
4891 /*
4892 * Dump gralloc state
4893 */
4894 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
4895 alloc.dump(result);
Karthik Ravi Shankar171155a2017-06-28 15:40:24 -07004896
4897 /*
4898 * Dump VrFlinger state if in use.
4899 */
4900 if (mVrFlingerRequestsDisplay && mVrFlinger) {
4901 result.append("VrFlinger state:\n");
Yiwei Zhang5434a782018-12-05 18:06:32 -08004902 result.append(mVrFlinger->Dump());
Karthik Ravi Shankar171155a2017-06-28 15:40:24 -07004903 result.append("\n");
4904 }
Ana Krulecb43429d2019-01-09 14:28:51 -08004905
4906 /**
4907 * Scheduler dump state.
4908 */
Ana Krulecc2870422019-01-29 19:00:58 -08004909 result.append("\nScheduler state:\n");
4910 result.append(mScheduler->doDump() + "\n");
Ana Krulecfefd6ae2019-02-13 17:53:08 -08004911 StringAppendF(&result, "+ Smart video mode: %s\n\n", mUseSmart90ForVideo ? "on" : "off");
Ana Krulecc2870422019-01-29 19:00:58 -08004912 result.append(mRefreshRateStats->doDump() + "\n");
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004913}
4914
Dominik Laskowski075d3172018-05-24 15:50:06 -07004915const Vector<sp<Layer>>& SurfaceFlinger::getLayerSortedByZForHwcDisplay(DisplayId displayId) {
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07004916 // Note: mStateLock is held here
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004917 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski7e045462018-05-30 13:02:02 -07004918 if (display->getId() == displayId) {
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004919 return getDisplayDeviceLocked(token)->getVisibleLayersSortedByZ();
Jesse Hall48bc05b2013-03-21 14:06:52 -07004920 }
4921 }
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004922
Dominik Laskowski34157762018-10-31 13:07:19 -07004923 ALOGE("%s: Invalid display %s", __FUNCTION__, to_string(displayId).c_str());
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004924 static const Vector<sp<Layer>> empty;
4925 return empty;
Mathias Agopiancb558572012-10-04 15:58:54 -07004926}
4927
Chia-I Wu28f320b2018-05-03 11:02:56 -07004928void SurfaceFlinger::updateColorMatrixLocked() {
4929 mat4 colorMatrix;
4930 if (mGlobalSaturationFactor != 1.0f) {
4931 // Rec.709 luma coefficients
4932 float3 luminance{0.213f, 0.715f, 0.072f};
4933 luminance *= 1.0f - mGlobalSaturationFactor;
4934 mat4 saturationMatrix = mat4(
4935 vec4{luminance.r + mGlobalSaturationFactor, luminance.r, luminance.r, 0.0f},
4936 vec4{luminance.g, luminance.g + mGlobalSaturationFactor, luminance.g, 0.0f},
4937 vec4{luminance.b, luminance.b, luminance.b + mGlobalSaturationFactor, 0.0f},
4938 vec4{0.0f, 0.0f, 0.0f, 1.0f}
4939 );
4940 colorMatrix = mClientColorMatrix * saturationMatrix * mDaltonizer();
4941 } else {
4942 colorMatrix = mClientColorMatrix * mDaltonizer();
4943 }
4944
4945 if (mCurrentState.colorMatrix != colorMatrix) {
4946 mCurrentState.colorMatrix = colorMatrix;
4947 mCurrentState.colorMatrixChanged = true;
4948 setTransactionFlags(eTransactionNeeded);
4949 }
4950}
4951
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07004952status_t SurfaceFlinger::CheckTransactCodeCredentials(uint32_t code) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004953#pragma clang diagnostic push
4954#pragma clang diagnostic error "-Wswitch-enum"
4955 switch (static_cast<ISurfaceComposerTag>(code)) {
4956 // These methods should at minimum make sure that the client requested
4957 // access to SF.
Dan Stozae3344402018-08-20 19:53:42 +00004958 case BOOT_FINISHED:
4959 case CLEAR_ANIMATION_FRAME_STATS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004960 case CREATE_DISPLAY:
4961 case DESTROY_DISPLAY:
Dan Stozae3344402018-08-20 19:53:42 +00004962 case ENABLE_VSYNC_INJECTIONS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004963 case GET_ANIMATION_FRAME_STATS:
4964 case GET_HDR_CAPABILITIES:
4965 case SET_ACTIVE_CONFIG:
Ady Abraham838de062019-02-04 10:24:03 -08004966 case SET_ALLOWED_DISPLAY_CONFIGS:
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08004967 case GET_ALLOWED_DISPLAY_CONFIGS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004968 case SET_ACTIVE_COLOR_MODE:
Chia-I Wu90f669f2017-10-05 14:24:41 -07004969 case INJECT_VSYNC:
Kevin DuBois9c0a1762018-10-16 13:32:31 -07004970 case SET_POWER_MODE:
Kevin DuBois74e53772018-11-19 10:52:38 -08004971 case GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES:
Kevin DuBois1d4249a2018-08-29 10:45:14 -07004972 case SET_DISPLAY_CONTENT_SAMPLING_ENABLED:
4973 case GET_DISPLAYED_CONTENT_SAMPLE: {
Robert Carrd4ae7f32018-06-07 16:10:57 -07004974 if (!callingThreadHasUnscopedSurfaceFlingerAccess()) {
4975 IPCThreadState* ipc = IPCThreadState::self();
4976 ALOGE("Permission Denial: can't access SurfaceFlinger pid=%d, uid=%d",
4977 ipc->getCallingPid(), ipc->getCallingUid());
Mathias Agopian375f5632009-06-15 18:24:59 -07004978 return PERMISSION_DENIED;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004979 }
Robert Carr1db73f62016-12-21 12:58:51 -08004980 return OK;
4981 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004982 case GET_LAYER_DEBUG_INFO: {
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07004983 IPCThreadState* ipc = IPCThreadState::self();
4984 const int pid = ipc->getCallingPid();
4985 const int uid = ipc->getCallingUid();
Ana Krulec13be8ad2018-08-21 02:43:56 +00004986 if ((uid != AID_SHELL) && !PermissionCache::checkPermission(sDump, pid, uid)) {
4987 ALOGE("Layer debug info permission denied for pid=%d, uid=%d", pid, uid);
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07004988 return PERMISSION_DENIED;
4989 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004990 return OK;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004991 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004992 // Used by apps to hook Choreographer to SurfaceFlinger.
4993 case CREATE_DISPLAY_EVENT_CONNECTION:
4994 // The following calls are currently used by clients that do not
4995 // request necessary permissions. However, they do not expose any secret
4996 // information, so it is OK to pass them.
4997 case AUTHENTICATE_SURFACE:
Peiyong Lind1fedb42019-03-11 17:48:41 -07004998 case GET_ACTIVE_COLOR_MODE:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004999 case GET_ACTIVE_CONFIG:
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08005000 case GET_PHYSICAL_DISPLAY_IDS:
5001 case GET_PHYSICAL_DISPLAY_TOKEN:
Ana Krulec13be8ad2018-08-21 02:43:56 +00005002 case GET_DISPLAY_COLOR_MODES:
Daniel Solomon42d04562019-01-20 21:03:19 -08005003 case GET_DISPLAY_NATIVE_PRIMARIES:
Ana Krulec13be8ad2018-08-21 02:43:56 +00005004 case GET_DISPLAY_CONFIGS:
5005 case GET_DISPLAY_STATS:
5006 case GET_SUPPORTED_FRAME_TIMESTAMPS:
5007 // Calling setTransactionState is safe, because you need to have been
5008 // granted a reference to Client* and Handle* to do anything with it.
5009 case SET_TRANSACTION_STATE:
Robert Carrb89ea9d2018-12-10 13:01:14 -08005010 case CREATE_CONNECTION:
Ady Abraham37965d42018-11-01 13:43:32 -07005011 case GET_COLOR_MANAGEMENT:
Peiyong Lin3c2791e2019-01-14 17:05:18 -08005012 case GET_COMPOSITION_PREFERENCE:
Marissa Wallebc2c052019-01-16 19:16:55 -08005013 case GET_PROTECTED_CONTENT_SUPPORT:
Dan Gittik57e63c52019-01-18 16:37:54 +00005014 case IS_WIDE_COLOR_DISPLAY:
5015 case GET_DISPLAY_BRIGHTNESS_SUPPORT:
5016 case SET_DISPLAY_BRIGHTNESS: {
Ana Krulec13be8ad2018-08-21 02:43:56 +00005017 return OK;
5018 }
5019 case CAPTURE_LAYERS:
Dan Stoza84ab9372018-12-17 15:27:57 -08005020 case CAPTURE_SCREEN:
5021 case ADD_REGION_SAMPLING_LISTENER:
5022 case REMOVE_REGION_SAMPLING_LISTENER: {
Ana Krulec13be8ad2018-08-21 02:43:56 +00005023 // codes that require permission check
chaviwa76b2712017-09-20 12:02:26 -07005024 IPCThreadState* ipc = IPCThreadState::self();
5025 const int pid = ipc->getCallingPid();
5026 const int uid = ipc->getCallingUid();
5027 if ((uid != AID_GRAPHICS) &&
5028 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
5029 ALOGE("Permission Denial: can't read framebuffer pid=%d, uid=%d", pid, uid);
5030 return PERMISSION_DENIED;
5031 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00005032 return OK;
5033 }
5034 // The following codes are deprecated and should never be allowed to access SF.
5035 case CONNECT_DISPLAY_UNUSED:
5036 case CREATE_GRAPHIC_BUFFER_ALLOC_UNUSED: {
5037 ALOGE("Attempting to access SurfaceFlinger with unused code: %u", code);
5038 return PERMISSION_DENIED;
chaviwa76b2712017-09-20 12:02:26 -07005039 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005040 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00005041
5042 // These codes are used for the IBinder protocol to either interrogate the recipient
5043 // side of the transaction for its canonical interface descriptor or to dump its state.
5044 // We let them pass by default.
5045 if (code == IBinder::INTERFACE_TRANSACTION || code == IBinder::DUMP_TRANSACTION ||
5046 code == IBinder::PING_TRANSACTION || code == IBinder::SHELL_COMMAND_TRANSACTION ||
5047 code == IBinder::SYSPROPS_TRANSACTION) {
5048 return OK;
5049 }
Ady Abraham03b02dd2019-03-21 15:40:11 -07005050 // Numbers from 1000 to 1034 are currently used for backdoors. The code
Ana Krulec13be8ad2018-08-21 02:43:56 +00005051 // in onTransact verifies that the user is root, and has access to use SF.
Ady Abraham03b02dd2019-03-21 15:40:11 -07005052 if (code >= 1000 && code <= 1034) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00005053 ALOGV("Accessing SurfaceFlinger through backdoor code: %u", code);
5054 return OK;
5055 }
5056 ALOGE("Permission Denial: SurfaceFlinger did not recognize request code: %u", code);
5057 return PERMISSION_DENIED;
5058#pragma clang diagnostic pop
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07005059}
5060
Ana Krulec13be8ad2018-08-21 02:43:56 +00005061status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
5062 uint32_t flags) {
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07005063 status_t credentialCheck = CheckTransactCodeCredentials(code);
5064 if (credentialCheck != OK) {
5065 return credentialCheck;
5066 }
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07005067
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005068 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
5069 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
Mathias Agopianb8a55602009-06-26 19:06:36 -07005070 CHECK_INTERFACE(ISurfaceComposer, data, reply);
Romain Guy8c6bbd62017-06-05 13:51:43 -07005071 IPCThreadState* ipc = IPCThreadState::self();
5072 const int uid = ipc->getCallingUid();
5073 if (CC_UNLIKELY(uid != AID_SYSTEM
5074 && !PermissionCache::checkCallingPermission(sHardwareTest))) {
Mathias Agopian375f5632009-06-15 18:24:59 -07005075 const int pid = ipc->getCallingPid();
Steve Blocke6f43dd2012-01-06 19:20:56 +00005076 ALOGE("Permission Denial: "
Mathias Agopian375f5632009-06-15 18:24:59 -07005077 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005078 return PERMISSION_DENIED;
5079 }
5080 int n;
5081 switch (code) {
Mathias Agopian01b76682009-04-16 20:04:08 -07005082 case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
Mathias Agopian35b48d12010-09-13 22:57:58 -07005083 case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005084 return NO_ERROR;
5085 case 1002: // SHOW_UPDATES
5086 n = data.readInt32();
5087 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
Mathias Agopian53331da2011-08-22 21:44:41 -07005088 invalidateHwcGeometry();
5089 repaintEverything();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005090 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005091 case 1004:{ // repaint everything
Mathias Agopian53331da2011-08-22 21:44:41 -07005092 repaintEverything();
Mathias Agopiancbb288b2009-09-07 16:32:45 -07005093 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005094 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -07005095 case 1005:{ // force transaction
Steven Thomas6d8110b2017-08-31 18:24:21 -07005096 Mutex::Autolock _l(mStateLock);
Mathias Agopiane57f2922012-08-09 16:29:12 -07005097 setTransactionFlags(
5098 eTransactionNeeded|
5099 eDisplayTransactionNeeded|
5100 eTraversalNeeded);
Mathias Agopiancbb288b2009-09-07 16:32:45 -07005101 return NO_ERROR;
5102 }
Mathias Agopian4d143ee2012-02-23 20:05:39 -08005103 case 1006:{ // send empty update
5104 signalRefresh();
5105 return NO_ERROR;
5106 }
Mathias Agopian53331da2011-08-22 21:44:41 -07005107 case 1008: // toggle use of hw composer
5108 n = data.readInt32();
5109 mDebugDisableHWC = n ? 1 : 0;
5110 invalidateHwcGeometry();
5111 repaintEverything();
5112 return NO_ERROR;
Mathias Agopiana4583642011-08-23 18:03:18 -07005113 case 1009: // toggle use of transform hint
5114 n = data.readInt32();
5115 mDebugDisableTransformHint = n ? 1 : 0;
5116 invalidateHwcGeometry();
5117 repaintEverything();
5118 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005119 case 1010: // interrogate.
Mathias Agopian01b76682009-04-16 20:04:08 -07005120 reply->writeInt32(0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005121 reply->writeInt32(0);
5122 reply->writeInt32(mDebugRegion);
Mathias Agopianb9494d52012-04-18 02:28:45 -07005123 reply->writeInt32(0);
Dianne Hackborn12839be2012-02-06 21:21:05 -08005124 reply->writeInt32(mDebugDisableHWC);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005125 return NO_ERROR;
5126 case 1013: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005127 const auto display = getDefaultDisplayDevice();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07005128 if (!display) {
5129 return NAME_NOT_FOUND;
5130 }
5131
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005132 reply->writeInt32(display->getPageFlipCount());
Mathias Agopianff2ed702013-09-01 21:36:12 -07005133 return NO_ERROR;
5134 }
5135 case 1014: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005136 Mutex::Autolock _l(mStateLock);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005137 // daltonize
5138 n = data.readInt32();
5139 switch (n % 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005140 case 1:
5141 mDaltonizer.setType(ColorBlindnessType::Protanomaly);
5142 break;
5143 case 2:
5144 mDaltonizer.setType(ColorBlindnessType::Deuteranomaly);
5145 break;
5146 case 3:
5147 mDaltonizer.setType(ColorBlindnessType::Tritanomaly);
5148 break;
5149 default:
5150 mDaltonizer.setType(ColorBlindnessType::None);
5151 break;
Mathias Agopianff2ed702013-09-01 21:36:12 -07005152 }
5153 if (n >= 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005154 mDaltonizer.setMode(ColorBlindnessMode::Correction);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005155 } else {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005156 mDaltonizer.setMode(ColorBlindnessMode::Simulation);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005157 }
Chia-I Wu28f320b2018-05-03 11:02:56 -07005158
5159 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005160 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005161 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005162 case 1015: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005163 Mutex::Autolock _l(mStateLock);
Alan Viverette9c5a3332013-09-12 20:04:35 -07005164 // apply a color matrix
5165 n = data.readInt32();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005166 if (n) {
Romain Guy0147a172017-06-01 13:53:56 -07005167 // color matrix is sent as a column-major mat4 matrix
Alan Viverette794c5ba2013-10-03 16:40:52 -07005168 for (size_t i = 0 ; i < 4; i++) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005169 for (size_t j = 0; j < 4; j++) {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005170 mClientColorMatrix[i][j] = data.readFloat();
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005171 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005172 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005173 } else {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005174 mClientColorMatrix = mat4();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005175 }
Romain Guy88d37dd2017-05-26 17:57:05 -07005176
5177 // Check that supplied matrix's last row is {0,0,0,1} so we can avoid
5178 // the division by w in the fragment shader
Chia-I Wu28f320b2018-05-03 11:02:56 -07005179 float4 lastRow(transpose(mClientColorMatrix)[3]);
Romain Guy88d37dd2017-05-26 17:57:05 -07005180 if (any(greaterThan(abs(lastRow - float4{0, 0, 0, 1}), float4{1e-4f}))) {
5181 ALOGE("The color transform's last row must be (0, 0, 0, 1)");
5182 }
5183
Chia-I Wu28f320b2018-05-03 11:02:56 -07005184 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005185 return NO_ERROR;
5186 }
Ruchi Kandoif52b3c82014-04-24 16:42:35 -07005187 // This is an experimental interface
5188 // Needs to be shifted to proper binder interface when we productize
5189 case 1016: {
Andy McFadden645b1f72014-06-10 14:43:32 -07005190 n = data.readInt32();
Ana Krulece588e312018-09-18 12:32:24 -07005191 // TODO(b/113612090): Evaluate if this can be removed.
Ana Krulecc2870422019-01-29 19:00:58 -08005192 mScheduler->setRefreshSkipCount(n);
Ruchi Kandoif52b3c82014-04-24 16:42:35 -07005193 return NO_ERROR;
5194 }
Dan Stozaee44edd2015-03-23 15:50:23 -07005195 case 1017: {
5196 n = data.readInt32();
5197 mForceFullDamage = static_cast<bool>(n);
5198 return NO_ERROR;
5199 }
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005200 case 1018: { // Modify Choreographer's phase offset
5201 n = data.readInt32();
Ana Krulecc2870422019-01-29 19:00:58 -08005202 mScheduler->setPhaseOffset(mAppConnectionHandle, static_cast<nsecs_t>(n));
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005203 return NO_ERROR;
5204 }
5205 case 1019: { // Modify SurfaceFlinger's phase offset
5206 n = data.readInt32();
Ana Krulecc2870422019-01-29 19:00:58 -08005207 mScheduler->setPhaseOffset(mSfConnectionHandle, static_cast<nsecs_t>(n));
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005208 return NO_ERROR;
5209 }
Irvel468051e2016-06-13 16:44:44 -07005210 case 1020: { // Layer updates interceptor
5211 n = data.readInt32();
5212 if (n) {
5213 ALOGV("Interceptor enabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08005214 mInterceptor->enable(mDrawingState.layersSortedByZ, mDrawingState.displays);
Irvel468051e2016-06-13 16:44:44 -07005215 }
5216 else{
5217 ALOGV("Interceptor disabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08005218 mInterceptor->disable();
Irvel468051e2016-06-13 16:44:44 -07005219 }
5220 return NO_ERROR;
5221 }
Dan Stoza8cf150a2016-08-02 10:27:31 -07005222 case 1021: { // Disable HWC virtual displays
5223 n = data.readInt32();
5224 mUseHwcVirtualDisplays = !n;
5225 return NO_ERROR;
5226 }
Romain Guy0147a172017-06-01 13:53:56 -07005227 case 1022: { // Set saturation boost
Chia-I Wu28f320b2018-05-03 11:02:56 -07005228 Mutex::Autolock _l(mStateLock);
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005229 mGlobalSaturationFactor = std::max(0.0f, std::min(data.readFloat(), 2.0f));
Romain Guy0147a172017-06-01 13:53:56 -07005230
Chia-I Wu28f320b2018-05-03 11:02:56 -07005231 updateColorMatrixLocked();
Romain Guy0147a172017-06-01 13:53:56 -07005232 return NO_ERROR;
5233 }
Romain Guy54f154a2017-10-24 21:40:32 +01005234 case 1023: { // Set native mode
Chia-I Wu0d711262018-05-21 15:19:35 -07005235 mDisplayColorSetting = static_cast<DisplayColorSetting>(data.readInt32());
Romain Guy54f154a2017-10-24 21:40:32 +01005236 invalidateHwcGeometry();
5237 repaintEverything();
5238 return NO_ERROR;
5239 }
Peiyong Lin4bac91c2018-10-25 09:48:33 -07005240 // Deprecate, use 1030 to check whether the device is color managed.
5241 case 1024: {
5242 return NAME_NOT_FOUND;
Romain Guy54f154a2017-10-24 21:40:32 +01005243 }
Vishnu Nair87704c92018-01-08 15:32:57 -08005244 case 1025: { // Set layer tracing
Adrian Roos1e1a1282017-11-01 19:05:31 +01005245 n = data.readInt32();
5246 if (n) {
Yichi Chenadc69612018-09-15 14:51:18 +08005247 ALOGD("LayerTracing enabled");
Nataniel Borges2b796da2019-02-15 13:32:18 -08005248 Mutex::Autolock lock(mStateLock);
5249 mTracingEnabledChanged = true;
Adrian Roos1e1a1282017-11-01 19:05:31 +01005250 mTracing.enable();
Adrian Roos1e1a1282017-11-01 19:05:31 +01005251 reply->writeInt32(NO_ERROR);
5252 } else {
Yichi Chenadc69612018-09-15 14:51:18 +08005253 ALOGD("LayerTracing disabled");
Nataniel Borges2b796da2019-02-15 13:32:18 -08005254 bool writeFile = false;
5255 {
5256 Mutex::Autolock lock(mStateLock);
5257 mTracingEnabledChanged = true;
5258 writeFile = mTracing.disable();
5259 }
5260
5261 if (writeFile) {
5262 reply->writeInt32(mTracing.writeToFile());
5263 } else {
5264 reply->writeInt32(NO_ERROR);
5265 }
Adrian Roos1e1a1282017-11-01 19:05:31 +01005266 }
5267 return NO_ERROR;
5268 }
Vishnu Nair87704c92018-01-08 15:32:57 -08005269 case 1026: { // Get layer tracing status
5270 reply->writeBool(mTracing.isEnabled());
5271 return NO_ERROR;
5272 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005273 // Is a DisplayColorSetting supported?
5274 case 1027: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005275 const auto display = getDefaultDisplayDevice();
5276 if (!display) {
Chia-I Wu0d711262018-05-21 15:19:35 -07005277 return NAME_NOT_FOUND;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005278 }
Chia-I Wu0d711262018-05-21 15:19:35 -07005279
5280 DisplayColorSetting setting = static_cast<DisplayColorSetting>(data.readInt32());
5281 switch (setting) {
5282 case DisplayColorSetting::MANAGED:
Peiyong Lin13effd12018-07-24 17:01:47 -07005283 reply->writeBool(useColorManagement);
Chia-I Wu0d711262018-05-21 15:19:35 -07005284 break;
5285 case DisplayColorSetting::UNMANAGED:
5286 reply->writeBool(true);
5287 break;
5288 case DisplayColorSetting::ENHANCED:
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005289 reply->writeBool(display->hasRenderIntent(RenderIntent::ENHANCE));
Chia-I Wu0d711262018-05-21 15:19:35 -07005290 break;
5291 default: // vendor display color setting
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005292 reply->writeBool(
5293 display->hasRenderIntent(static_cast<RenderIntent>(setting)));
Chia-I Wu0d711262018-05-21 15:19:35 -07005294 break;
5295 }
5296 return NO_ERROR;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005297 }
Steven Thomas97f1f4c2018-06-01 12:04:16 -07005298 // Is VrFlinger active?
5299 case 1028: {
5300 Mutex::Autolock _l(mStateLock);
Lloyd Pique441d5042018-10-18 16:49:51 -07005301 reply->writeBool(getHwComposer().isUsingVrComposer());
Steven Thomas97f1f4c2018-06-01 12:04:16 -07005302 return NO_ERROR;
5303 }
Nataniel Borges2b796da2019-02-15 13:32:18 -08005304 // Set buffer size for SF tracing (value in KB)
5305 case 1029: {
5306 n = data.readInt32();
5307 if (n <= 0 || n > MAX_TRACING_MEMORY) {
5308 ALOGW("Invalid buffer size: %d KB", n);
5309 reply->writeInt32(BAD_VALUE);
5310 return BAD_VALUE;
5311 }
5312
5313 ALOGD("Updating trace buffer to %d KB", n);
5314 mTracing.setBufferSize(n * 1024);
5315 reply->writeInt32(NO_ERROR);
5316 return NO_ERROR;
5317 }
Peiyong Lin13effd12018-07-24 17:01:47 -07005318 // Is device color managed?
5319 case 1030: {
5320 reply->writeBool(useColorManagement);
5321 return NO_ERROR;
5322 }
Peiyong Lin9d846a52018-11-05 13:18:20 -08005323 // Override default composition data space
5324 // adb shell service call SurfaceFlinger 1031 i32 1 DATASPACE_NUMBER DATASPACE_NUMBER \
5325 // && adb shell stop zygote && adb shell start zygote
5326 // to restore: adb shell service call SurfaceFlinger 1031 i32 0 && \
5327 // adb shell stop zygote && adb shell start zygote
5328 case 1031: {
5329 Mutex::Autolock _l(mStateLock);
5330 n = data.readInt32();
5331 if (n) {
5332 n = data.readInt32();
5333 if (n) {
5334 Dataspace dataspace = static_cast<Dataspace>(n);
5335 if (!validateCompositionDataspace(dataspace)) {
5336 return BAD_VALUE;
5337 }
5338 mDefaultCompositionDataspace = dataspace;
5339 }
5340 n = data.readInt32();
5341 if (n) {
5342 Dataspace dataspace = static_cast<Dataspace>(n);
5343 if (!validateCompositionDataspace(dataspace)) {
5344 return BAD_VALUE;
5345 }
5346 mWideColorGamutCompositionDataspace = dataspace;
5347 }
5348 } else {
5349 // restore composition data space.
5350 mDefaultCompositionDataspace = defaultCompositionDataspace;
5351 mWideColorGamutCompositionDataspace = wideColorGamutCompositionDataspace;
5352 }
5353 return NO_ERROR;
5354 }
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08005355 case 1032: {
5356 n = data.readInt32();
5357 mDebugEnableProtectedContent = n;
5358 return NO_ERROR;
5359 }
Vishnu Nair9245d3b2019-03-22 13:38:56 -07005360 // Set trace flags
5361 case 1033: {
5362 n = data.readUint32();
5363 ALOGD("Updating trace flags to 0x%x", n);
5364 mTracing.setTraceFlags(n);
5365 reply->writeInt32(NO_ERROR);
5366 return NO_ERROR;
5367 }
Ady Abraham03b02dd2019-03-21 15:40:11 -07005368 case 1034: {
5369 // TODO(b/129297325): expose this via developer menu option
5370 n = data.readInt32();
5371 if (n && !mRefreshRateOverlay) {
5372 std::lock_guard<std::mutex> lock(mActiveConfigLock);
5373 mRefreshRateOverlay = std::make_unique<RefreshRateOverlay>(*this);
5374 mRefreshRateOverlay->changeRefreshRate(mDesiredActiveConfig.type);
5375 } else if (!n) {
5376 mRefreshRateOverlay.reset();
5377 }
5378 return NO_ERROR;
5379 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005380 }
5381 }
5382 return err;
5383}
5384
Steven Thomas6d8110b2017-08-31 18:24:21 -07005385void SurfaceFlinger::repaintEverything() {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07005386 mRepaintEverything = true;
Dan Stozac7a25ad2018-04-12 11:45:09 -07005387 signalTransaction();
Steven Thomas6d8110b2017-08-31 18:24:21 -07005388}
5389
Ana Krulec7d1d6832018-12-27 11:10:09 -08005390void SurfaceFlinger::repaintEverythingForHWC() {
5391 mRepaintEverything = true;
5392 mEventQueue->invalidateForHWC();
5393}
5394
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005395// A simple RAII class to disconnect from an ANativeWindow* when it goes out of scope
5396class WindowDisconnector {
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005397public:
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005398 WindowDisconnector(ANativeWindow* window, int api) : mWindow(window), mApi(api) {}
5399 ~WindowDisconnector() {
5400 native_window_api_disconnect(mWindow, mApi);
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005401 }
5402
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005403private:
5404 ANativeWindow* mWindow;
5405 const int mApi;
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005406};
5407
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005408status_t SurfaceFlinger::captureScreen(const sp<IBinder>& displayToken,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005409 sp<GraphicBuffer>* outBuffer, const Dataspace reqDataspace,
5410 const ui::PixelFormat reqPixelFormat, Rect sourceCrop,
chaviw0e3479f2018-09-10 16:49:30 -07005411 uint32_t reqWidth, uint32_t reqHeight,
5412 bool useIdentityTransform,
Robert Carrfa8855f2019-02-19 10:05:00 -08005413 ISurfaceComposer::Rotation rotation,
5414 bool captureSecureLayers) {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005415 ATRACE_CALL();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005416
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005417 if (!displayToken) return BAD_VALUE;
chaviwa76b2712017-09-20 12:02:26 -07005418
Chia-I Wuc80dcbb2018-08-24 15:34:02 -07005419 auto renderAreaRotation = fromSurfaceComposerRotation(rotation);
5420
Chia-I Wu20261cb2018-08-23 12:55:44 -07005421 sp<DisplayDevice> display;
5422 {
5423 Mutex::Autolock _l(mStateLock);
Garfield Tan3b1b8af2018-03-16 17:37:33 -07005424
Chia-I Wu20261cb2018-08-23 12:55:44 -07005425 display = getDisplayDeviceLocked(displayToken);
5426 if (!display) return BAD_VALUE;
5427
Chia-I Wucb023152018-08-28 12:57:23 -07005428 // set the requested width/height to the logical display viewport size
5429 // by default
5430 if (reqWidth == 0 || reqHeight == 0) {
5431 reqWidth = uint32_t(display->getViewport().width());
5432 reqHeight = uint32_t(display->getViewport().height());
Chia-I Wu20261cb2018-08-23 12:55:44 -07005433 }
Yiwei Zhang06a58e22018-08-20 16:42:23 -07005434 }
5435
Peiyong Lin0e003c92018-09-17 11:09:51 -07005436 DisplayRenderArea renderArea(display, sourceCrop, reqWidth, reqHeight, reqDataspace,
Robert Carrfa8855f2019-02-19 10:05:00 -08005437 renderAreaRotation, captureSecureLayers);
chaviwa76b2712017-09-20 12:02:26 -07005438
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08005439 auto traverseLayers = std::bind(&SurfaceFlinger::traverseLayersInDisplay, this, display,
5440 std::placeholders::_1);
Peiyong Lin0e003c92018-09-17 11:09:51 -07005441 return captureScreenCommon(renderArea, traverseLayers, outBuffer, reqPixelFormat,
5442 useIdentityTransform);
chaviwa76b2712017-09-20 12:02:26 -07005443}
5444
5445status_t SurfaceFlinger::captureLayers(const sp<IBinder>& layerHandleBinder,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005446 sp<GraphicBuffer>* outBuffer, const Dataspace reqDataspace,
5447 const ui::PixelFormat reqPixelFormat, const Rect& sourceCrop,
Robert Carr578038f2018-03-09 12:25:24 -08005448 float frameScale, bool childrenOnly) {
chaviwa76b2712017-09-20 12:02:26 -07005449 ATRACE_CALL();
5450
5451 class LayerRenderArea : public RenderArea {
5452 public:
Robert Carr578038f2018-03-09 12:25:24 -08005453 LayerRenderArea(SurfaceFlinger* flinger, const sp<Layer>& layer, const Rect crop,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005454 int32_t reqWidth, int32_t reqHeight, Dataspace reqDataSpace,
5455 bool childrenOnly)
5456 : RenderArea(reqWidth, reqHeight, CaptureFill::CLEAR, reqDataSpace),
Robert Carr578038f2018-03-09 12:25:24 -08005457 mLayer(layer),
5458 mCrop(crop),
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005459 mNeedsFiltering(false),
Robert Carr578038f2018-03-09 12:25:24 -08005460 mFlinger(flinger),
5461 mChildrenOnly(childrenOnly) {}
Peiyong Linefefaac2018-08-17 12:27:51 -07005462 const ui::Transform& getTransform() const override { return mTransform; }
Lloyd Pique0449b0f2018-12-20 16:23:45 -08005463 Rect getBounds() const override {
5464 const Layer::State& layerState(mLayer->getDrawingState());
5465 return mLayer->getBufferSize(layerState);
5466 }
Marissa Wall61c58622018-07-18 10:12:20 -07005467 int getHeight() const override {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08005468 return mLayer->getBufferSize(mLayer->getDrawingState()).getHeight();
Marissa Wall61c58622018-07-18 10:12:20 -07005469 }
Vishnu Nair88a11f22018-11-28 18:30:57 -08005470 int getWidth() const override {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08005471 return mLayer->getBufferSize(mLayer->getDrawingState()).getWidth();
Vishnu Nair88a11f22018-11-28 18:30:57 -08005472 }
chaviwa76b2712017-09-20 12:02:26 -07005473 bool isSecure() const override { return false; }
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005474 bool needsFiltering() const override { return mNeedsFiltering; }
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08005475 const sp<const DisplayDevice> getDisplayDevice() const override { return nullptr; }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005476 Rect getSourceCrop() const override {
5477 if (mCrop.isEmpty()) {
5478 return getBounds();
5479 } else {
5480 return mCrop;
5481 }
5482 }
Robert Carr578038f2018-03-09 12:25:24 -08005483 class ReparentForDrawing {
5484 public:
5485 const sp<Layer>& oldParent;
5486 const sp<Layer>& newParent;
5487
Vishnu Nair4351ad52019-02-11 14:13:02 -08005488 ReparentForDrawing(const sp<Layer>& oldParent, const sp<Layer>& newParent,
5489 const Rect& drawingBounds)
Robert Carr578038f2018-03-09 12:25:24 -08005490 : oldParent(oldParent), newParent(newParent) {
Vishnu Nair4351ad52019-02-11 14:13:02 -08005491 // Compute and cache the bounds for the new parent layer.
5492 newParent->computeBounds(drawingBounds.toFloatRect(), ui::Transform());
Robert Carr15eae092018-03-23 13:43:53 -07005493 oldParent->setChildrenDrawingParent(newParent);
Robert Carr578038f2018-03-09 12:25:24 -08005494 }
Vishnu Nairbce6ffd2019-02-14 10:58:59 -08005495 ~ReparentForDrawing() { oldParent->setChildrenDrawingParent(oldParent); }
Robert Carr578038f2018-03-09 12:25:24 -08005496 };
5497
5498 void render(std::function<void()> drawLayers) override {
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005499 const Rect sourceCrop = getSourceCrop();
5500 // no need to check rotation because there is none
5501 mNeedsFiltering = sourceCrop.width() != getReqWidth() ||
5502 sourceCrop.height() != getReqHeight();
5503
Robert Carr578038f2018-03-09 12:25:24 -08005504 if (!mChildrenOnly) {
5505 mTransform = mLayer->getTransform().inverse();
5506 drawLayers();
5507 } else {
5508 Rect bounds = getBounds();
Lloyd Pique90c115d2018-09-18 21:39:42 -07005509 screenshotParentLayer = mFlinger->getFactory().createContainerLayer(
Lloyd Pique42ab75e2018-09-12 20:46:03 -07005510 LayerCreationArgs(mFlinger, nullptr, String8("Screenshot Parent"),
Evan Roskya1f1e152019-01-24 16:17:46 -08005511 bounds.getWidth(), bounds.getHeight(), 0,
5512 LayerMetadata()));
Robert Carr578038f2018-03-09 12:25:24 -08005513
Vishnu Nair4351ad52019-02-11 14:13:02 -08005514 ReparentForDrawing reparent(mLayer, screenshotParentLayer, sourceCrop);
Robert Carr578038f2018-03-09 12:25:24 -08005515 drawLayers();
5516 }
5517 }
chaviwa76b2712017-09-20 12:02:26 -07005518
chaviwa76b2712017-09-20 12:02:26 -07005519 private:
chaviw7206d492017-11-10 16:16:12 -08005520 const sp<Layer> mLayer;
5521 const Rect mCrop;
Robert Carr578038f2018-03-09 12:25:24 -08005522
5523 // In the "childrenOnly" case we reparent the children to a screenshot
5524 // layer which has no properties set and which does not draw.
5525 sp<ContainerLayer> screenshotParentLayer;
Peiyong Linefefaac2018-08-17 12:27:51 -07005526 ui::Transform mTransform;
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005527 bool mNeedsFiltering;
Robert Carr578038f2018-03-09 12:25:24 -08005528
5529 SurfaceFlinger* mFlinger;
5530 const bool mChildrenOnly;
chaviwa76b2712017-09-20 12:02:26 -07005531 };
5532
5533 auto layerHandle = reinterpret_cast<Layer::Handle*>(layerHandleBinder.get());
5534 auto parent = layerHandle->owner.promote();
5535
Robert Carr2e102c92018-10-23 12:11:15 -07005536 if (parent == nullptr || parent->isRemovedFromCurrentState()) {
chaviw7206d492017-11-10 16:16:12 -08005537 ALOGE("captureLayers called with a removed parent");
5538 return NAME_NOT_FOUND;
5539 }
5540
Robert Carr578038f2018-03-09 12:25:24 -08005541 const int uid = IPCThreadState::self()->getCallingUid();
5542 const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08005543 if (!forSystem && parent->getCurrentState().flags & layer_state_t::eLayerSecure) {
Robert Carr578038f2018-03-09 12:25:24 -08005544 ALOGW("Attempting to capture secure layer: PERMISSION_DENIED");
5545 return PERMISSION_DENIED;
5546 }
5547
chaviw7206d492017-11-10 16:16:12 -08005548 Rect crop(sourceCrop);
5549 if (sourceCrop.width() <= 0) {
5550 crop.left = 0;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08005551 crop.right = parent->getBufferSize(parent->getCurrentState()).getWidth();
chaviw7206d492017-11-10 16:16:12 -08005552 }
5553
5554 if (sourceCrop.height() <= 0) {
5555 crop.top = 0;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08005556 crop.bottom = parent->getBufferSize(parent->getCurrentState()).getHeight();
chaviw7206d492017-11-10 16:16:12 -08005557 }
5558
5559 int32_t reqWidth = crop.width() * frameScale;
5560 int32_t reqHeight = crop.height() * frameScale;
5561
Chia-I Wu20261cb2018-08-23 12:55:44 -07005562 // really small crop or frameScale
5563 if (reqWidth <= 0) {
5564 reqWidth = 1;
5565 }
5566 if (reqHeight <= 0) {
5567 reqHeight = 1;
5568 }
5569
Peiyong Lin0e003c92018-09-17 11:09:51 -07005570 LayerRenderArea renderArea(this, parent, crop, reqWidth, reqHeight, reqDataspace, childrenOnly);
chaviw7206d492017-11-10 16:16:12 -08005571
Robert Carr578038f2018-03-09 12:25:24 -08005572 auto traverseLayers = [parent, childrenOnly](const LayerVector::Visitor& visitor) {
chaviwa76b2712017-09-20 12:02:26 -07005573 parent->traverseChildrenInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
5574 if (!layer->isVisible()) {
5575 return;
Robert Carr578038f2018-03-09 12:25:24 -08005576 } else if (childrenOnly && layer == parent.get()) {
5577 return;
chaviwa76b2712017-09-20 12:02:26 -07005578 }
5579 visitor(layer);
5580 });
5581 };
Peiyong Lin0e003c92018-09-17 11:09:51 -07005582 return captureScreenCommon(renderArea, traverseLayers, outBuffer, reqPixelFormat, false);
chaviwa76b2712017-09-20 12:02:26 -07005583}
5584
5585status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea,
5586 TraverseLayersFunction traverseLayers,
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005587 sp<GraphicBuffer>* outBuffer,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005588 const ui::PixelFormat reqPixelFormat,
chaviwa76b2712017-09-20 12:02:26 -07005589 bool useIdentityTransform) {
5590 ATRACE_CALL();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005591
Peiyong Lin0e003c92018-09-17 11:09:51 -07005592 // TODO(b/116112787) Make buffer usage a parameter.
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005593 const uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
5594 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
Lloyd Pique90c115d2018-09-18 21:39:42 -07005595 *outBuffer =
5596 getFactory().createGraphicBuffer(renderArea.getReqWidth(), renderArea.getReqHeight(),
5597 static_cast<android_pixel_format>(reqPixelFormat), 1,
5598 usage, "screenshot");
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005599
Kevin DuBois7cbcc372019-02-25 14:53:28 -08005600 return captureScreenCommon(renderArea, traverseLayers, *outBuffer, useIdentityTransform);
Dan Stozaec460082018-12-17 15:35:09 -08005601}
5602
Kevin DuBois7cbcc372019-02-25 14:53:28 -08005603status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea,
5604 TraverseLayersFunction traverseLayers,
5605 const sp<GraphicBuffer>& buffer,
5606 bool useIdentityTransform) {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005607 // This mutex protects syncFd and captureResult for communication of the return values from the
5608 // main thread back to this Binder thread
5609 std::mutex captureMutex;
5610 std::condition_variable captureCondition;
5611 std::unique_lock<std::mutex> captureLock(captureMutex);
5612 int syncFd = -1;
5613 std::optional<status_t> captureResult;
5614
Robert Carr03480e22018-01-04 16:02:06 -08005615 const int uid = IPCThreadState::self()->getCallingUid();
5616 const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
5617
Dominik Laskowski8c001672018-05-30 16:52:06 -07005618 sp<LambdaMessage> message = new LambdaMessage([&] {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005619 // If there is a refresh pending, bug out early and tell the binder thread to try again
5620 // after the refresh.
5621 if (mRefreshPending) {
5622 ATRACE_NAME("Skipping screenshot for now");
5623 std::unique_lock<std::mutex> captureLock(captureMutex);
5624 captureResult = std::make_optional<status_t>(EAGAIN);
5625 captureCondition.notify_one();
5626 return;
5627 }
5628
5629 status_t result = NO_ERROR;
5630 int fd = -1;
5631 {
5632 Mutex::Autolock _l(mStateLock);
Dominik Laskowski8c001672018-05-30 16:52:06 -07005633 renderArea.render([&] {
Dan Stozaec460082018-12-17 15:35:09 -08005634 result = captureScreenImplLocked(renderArea, traverseLayers, buffer.get(),
Robert Carr578038f2018-03-09 12:25:24 -08005635 useIdentityTransform, forSystem, &fd);
5636 });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005637 }
5638
5639 {
5640 std::unique_lock<std::mutex> captureLock(captureMutex);
5641 syncFd = fd;
5642 captureResult = std::make_optional<status_t>(result);
5643 captureCondition.notify_one();
5644 }
5645 });
5646
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005647 status_t result = postMessageAsync(message);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005648 if (result == NO_ERROR) {
Dominik Laskowski8c001672018-05-30 16:52:06 -07005649 captureCondition.wait(captureLock, [&] { return captureResult; });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005650 while (*captureResult == EAGAIN) {
5651 captureResult.reset();
5652 result = postMessageAsync(message);
5653 if (result != NO_ERROR) {
5654 return result;
5655 }
Dominik Laskowski8c001672018-05-30 16:52:06 -07005656 captureCondition.wait(captureLock, [&] { return captureResult; });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005657 }
5658 result = *captureResult;
5659 }
5660
5661 if (result == NO_ERROR) {
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005662 sync_wait(syncFd, -1);
5663 close(syncFd);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005664 }
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005665
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005666 return result;
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005667}
5668
chaviwa76b2712017-09-20 12:02:26 -07005669void SurfaceFlinger::renderScreenImplLocked(const RenderArea& renderArea,
Chia-I Wu1be50b52018-08-29 10:44:48 -07005670 TraverseLayersFunction traverseLayers,
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005671 ANativeWindowBuffer* buffer, bool useIdentityTransform,
5672 int* outSyncFd) {
Mathias Agopian180f10d2013-04-10 22:55:41 -07005673 ATRACE_CALL();
chaviwa76b2712017-09-20 12:02:26 -07005674
chaviwa76b2712017-09-20 12:02:26 -07005675 const auto reqWidth = renderArea.getReqWidth();
5676 const auto reqHeight = renderArea.getReqHeight();
Chia-I Wuf2aa3112018-08-27 14:54:37 -07005677 const auto sourceCrop = renderArea.getSourceCrop();
5678 const auto rotation = renderArea.getRotationFlags();
Dan Stozac1879002014-05-22 15:59:05 -07005679
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005680 renderengine::DisplaySettings clientCompositionDisplay;
5681 std::vector<renderengine::LayerSettings> clientCompositionLayers;
Romain Guy88d37dd2017-05-26 17:57:05 -07005682
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005683 // assume that bounds are never offset, and that they are the same as the
5684 // buffer bounds.
5685 clientCompositionDisplay.physicalDisplay = Rect(reqWidth, reqHeight);
5686 ui::Transform transform = renderArea.getTransform();
Lloyd Pique7e06e7f2019-03-15 18:36:44 -07005687 clientCompositionDisplay.globalTransform = transform.asMatrix4();
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005688 mat4 rotMatrix;
5689 // Displacement for repositioning the clipping rectangle after rotating it
5690 // with the rotation hint.
5691 int displacementX = 0;
5692 int displacementY = 0;
5693 float rot90InRadians = 2.0f * static_cast<float>(M_PI) / 4.0f;
5694 switch (rotation) {
5695 case ui::Transform::ROT_90:
5696 rotMatrix = mat4::rotate(rot90InRadians, vec3(0, 0, 1));
5697 displacementX = reqWidth;
5698 break;
5699 case ui::Transform::ROT_180:
5700 rotMatrix = mat4::rotate(rot90InRadians * 2.0f, vec3(0, 0, 1));
5701 displacementX = reqWidth;
5702 displacementY = reqHeight;
5703 break;
5704 case ui::Transform::ROT_270:
5705 rotMatrix = mat4::rotate(rot90InRadians * 3.0f, vec3(0, 0, 1));
5706 displacementY = reqHeight;
5707 break;
5708 default:
5709 break;
5710 }
5711 // We need to transform the clipping window into the right spot.
5712 // First, rotate the clipping rectangle by the rotation hint to get the
5713 // right orientation
5714 const vec4 clipTL = vec4(sourceCrop.left, sourceCrop.top, 0, 1);
5715 const vec4 clipBR = vec4(sourceCrop.right, sourceCrop.bottom, 0, 1);
5716 const vec4 rotClipTL = rotMatrix * clipTL;
5717 const vec4 rotClipBR = rotMatrix * clipBR;
5718 const int newClipLeft = std::min(rotClipTL[0], rotClipBR[0]);
5719 const int newClipTop = std::min(rotClipTL[1], rotClipBR[1]);
5720 const int newClipRight = std::max(rotClipTL[0], rotClipBR[0]);
5721 const int newClipBottom = std::max(rotClipTL[1], rotClipBR[1]);
5722
5723 // Now reposition the clipping rectangle with the displacement vector
5724 // computed above.
5725 const mat4 displacementMat = mat4::translate(vec4(displacementX, displacementY, 0, 1));
5726
5727 clientCompositionDisplay.clip =
5728 Rect(newClipLeft + displacementX, newClipTop + displacementY,
5729 newClipRight + displacementX, newClipBottom + displacementY);
5730
5731 // We need to perform the same transformation in layer space, so propagate
5732 // it to the global transform.
5733 mat4 clipTransform = displacementMat * rotMatrix;
5734 clientCompositionDisplay.globalTransform *= clipTransform;
5735 clientCompositionDisplay.outputDataspace = renderArea.getReqDataSpace();
5736 clientCompositionDisplay.maxLuminance = DisplayDevice::sDefaultMaxLumiance;
Mathias Agopian180f10d2013-04-10 22:55:41 -07005737
chaviw50da5042018-04-09 13:49:37 -07005738 const float alpha = RenderArea::getCaptureFillValue(renderArea.getCaptureFill());
Mathias Agopian180f10d2013-04-10 22:55:41 -07005739
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005740 renderengine::LayerSettings fillLayer;
5741 fillLayer.source.buffer.buffer = nullptr;
5742 fillLayer.source.solidColor = half3(0.0, 0.0, 0.0);
5743 fillLayer.geometry.boundaries = FloatRect(0.0, 0.0, 1.0, 1.0);
5744 fillLayer.alpha = half(alpha);
5745 clientCompositionLayers.push_back(fillLayer);
5746
5747 Region clearRegion = Region::INVALID_REGION;
chaviwa76b2712017-09-20 12:02:26 -07005748 traverseLayers([&](Layer* layer) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005749 renderengine::LayerSettings layerSettings;
5750 bool prepared = layer->prepareClientLayer(renderArea, useIdentityTransform, clearRegion,
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08005751 false, layerSettings);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005752 if (prepared) {
5753 clientCompositionLayers.push_back(layerSettings);
5754 }
chaviwa76b2712017-09-20 12:02:26 -07005755 });
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005756
5757 clientCompositionDisplay.clearRegion = clearRegion;
Alec Mouri6338c9d2019-02-07 16:57:51 -08005758 // Use an empty fence for the buffer fence, since we just created the buffer so
5759 // there is no need for synchronization with the GPU.
5760 base::unique_fd bufferFence;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005761 base::unique_fd drawFence;
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08005762 getRenderEngine().useProtectedContext(false);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005763 getRenderEngine().drawLayers(clientCompositionDisplay, clientCompositionLayers, buffer,
Alec Mourife0d72b2019-03-21 14:05:56 -07005764 /*useFramebufferCache=*/false, std::move(bufferFence), &drawFence);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005765
5766 *outSyncFd = drawFence.release();
Mathias Agopian180f10d2013-04-10 22:55:41 -07005767}
5768
chaviwa76b2712017-09-20 12:02:26 -07005769status_t SurfaceFlinger::captureScreenImplLocked(const RenderArea& renderArea,
5770 TraverseLayersFunction traverseLayers,
5771 ANativeWindowBuffer* buffer,
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005772 bool useIdentityTransform,
Robert Carr03480e22018-01-04 16:02:06 -08005773 bool forSystem,
chaviwa76b2712017-09-20 12:02:26 -07005774 int* outSyncFd) {
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005775 ATRACE_CALL();
5776
Pablo Ceballosb5b35632016-02-23 11:18:51 -08005777 bool secureLayerIsVisible = false;
chaviwa76b2712017-09-20 12:02:26 -07005778
5779 traverseLayers([&](Layer* layer) {
5780 secureLayerIsVisible = secureLayerIsVisible || (layer->isVisible() && layer->isSecure());
5781 });
Pablo Ceballosb5b35632016-02-23 11:18:51 -08005782
Robert Carr03480e22018-01-04 16:02:06 -08005783 // We allow the system server to take screenshots of secure layers for
5784 // use in situations like the Screen-rotation animation and place
5785 // the impetus on WindowManager to not persist them.
5786 if (secureLayerIsVisible && !forSystem) {
Pablo Ceballosb5b35632016-02-23 11:18:51 -08005787 ALOGW("FB is protected: PERMISSION_DENIED");
5788 return PERMISSION_DENIED;
5789 }
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005790 renderScreenImplLocked(renderArea, traverseLayers, buffer, useIdentityTransform, outSyncFd);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005791 return NO_ERROR;
Mathias Agopian74c40c02010-09-29 13:02:36 -07005792}
5793
chaviw95ef3c42019-02-14 10:55:09 -08005794void SurfaceFlinger::setInputWindowsFinished() {
5795 Mutex::Autolock _l(mStateLock);
5796
5797 mPendingSyncInputWindows = false;
5798 mTransactionCV.broadcast();
5799}
chaviw5f21a5e2019-02-14 10:00:34 -08005800
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07005801// ---------------------------------------------------------------------------
5802
Dan Stoza412903f2017-04-27 13:42:17 -07005803void SurfaceFlinger::State::traverseInZOrder(const LayerVector::Visitor& visitor) const {
5804 layersSortedByZ.traverseInZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07005805}
5806
Dan Stoza412903f2017-04-27 13:42:17 -07005807void SurfaceFlinger::State::traverseInReverseZOrder(const LayerVector::Visitor& visitor) const {
5808 layersSortedByZ.traverseInReverseZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07005809}
5810
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005811void SurfaceFlinger::traverseLayersInDisplay(const sp<const DisplayDevice>& display,
chaviwa76b2712017-09-20 12:02:26 -07005812 const LayerVector::Visitor& visitor) {
5813 // We loop through the first level of layers without traversing,
chaviw0e3479f2018-09-10 16:49:30 -07005814 // as we need to determine which layers belong to the requested display.
chaviwa76b2712017-09-20 12:02:26 -07005815 for (const auto& layer : mDrawingState.layersSortedByZ) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005816 if (!layer->belongsToDisplay(display->getLayerStack(), false)) {
chaviwa76b2712017-09-20 12:02:26 -07005817 continue;
5818 }
Chia-I Wuec2d9852017-11-21 09:21:01 -08005819 // relative layers are traversed in Layer::traverseInZOrder
chaviwa76b2712017-09-20 12:02:26 -07005820 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005821 if (!layer->belongsToDisplay(display->getLayerStack(), false)) {
Adrian Roos8acf5a02018-01-17 21:28:19 +01005822 return;
5823 }
chaviwa76b2712017-09-20 12:02:26 -07005824 if (!layer->isVisible()) {
5825 return;
5826 }
5827 visitor(layer);
5828 });
5829 }
5830}
5831
Ady Abraham838de062019-02-04 10:24:03 -08005832void SurfaceFlinger::setAllowedDisplayConfigsInternal(
5833 const android::sp<android::IBinder>& displayToken,
5834 std::unique_ptr<const AllowedDisplayConfigs>&& allowedConfigs) {
5835 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
5836 if (!displayId) {
5837 ALOGE("setAllowedDisplayConfigsInternal: getPhysicalDisplayId failed");
5838 return;
5839 }
5840
5841 ALOGV("Updating allowed configs");
5842 {
5843 std::lock_guard lock(mAllowedConfigsLock);
5844 mAllowedConfigs[*displayId] = std::move(allowedConfigs);
5845 }
5846
Ady Abrahamde3b67b2019-03-25 16:38:10 -07005847 // Set the highest allowed config by iterating backwards on available refresh rates
5848 const auto& refreshRates = mRefreshRateConfigs[*displayId]->getRefreshRates();
5849 for (auto iter = refreshRates.crbegin(); iter != refreshRates.crend(); ++iter) {
5850 if (iter->second && isConfigAllowed(*displayId, iter->second->configId)) {
5851 ALOGV("switching to config %d", iter->second->configId);
Ady Abraham03b02dd2019-03-21 15:40:11 -07005852 setDesiredActiveConfig({iter->first, iter->second->configId, displayToken,
5853 Scheduler::ConfigEvent::Changed});
Ady Abrahamde3b67b2019-03-25 16:38:10 -07005854 break;
Ady Abraham97d04232019-03-05 19:48:12 -08005855 }
5856 }
Ady Abraham838de062019-02-04 10:24:03 -08005857}
5858
5859status_t SurfaceFlinger::setAllowedDisplayConfigs(const android::sp<android::IBinder>& displayToken,
5860 const std::vector<int32_t>& allowedConfigs) {
5861 ATRACE_CALL();
5862
5863 if (!displayToken) {
5864 ALOGE("setAllowedDisplayConfigs: displayToken is null");
5865 return BAD_VALUE;
5866 }
5867
5868 if (!allowedConfigs.size()) {
5869 ALOGE("setAllowedDisplayConfigs: empty config set provided");
5870 return BAD_VALUE;
5871 }
5872
5873 {
5874 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
5875 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
5876 if (!displayId) {
5877 ALOGE("setAllowedDisplayConfigs: display not found");
5878 return NAME_NOT_FOUND;
5879 }
5880 }
5881
5882 auto allowedDisplayConfigsBuilder = AllowedDisplayConfigs::Builder();
5883 for (int config : allowedConfigs) {
5884 ALOGV("setAllowedDisplayConfigs: Adding config to the allowed configs = %d", config);
5885 allowedDisplayConfigsBuilder.addConfig(config);
5886 }
5887 auto allowedDisplayConfigs = allowedDisplayConfigsBuilder.build();
5888 postMessageSync(new LambdaMessage([&]() NO_THREAD_SAFETY_ANALYSIS {
5889 setAllowedDisplayConfigsInternal(displayToken, std::move(allowedDisplayConfigs));
5890 }));
5891 return NO_ERROR;
5892}
5893
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08005894status_t SurfaceFlinger::getAllowedDisplayConfigs(const android::sp<android::IBinder>& displayToken,
5895 std::vector<int32_t>* outAllowedConfigs) {
5896 ATRACE_CALL();
5897
5898 if (!displayToken) {
5899 ALOGE("getAllowedDisplayConfigs: displayToken is null");
5900 return BAD_VALUE;
5901 }
5902
5903 if (!outAllowedConfigs) {
5904 ALOGE("getAllowedDisplayConfigs: outAllowedConfigs is null");
5905 return BAD_VALUE;
5906 }
5907
5908 ConditionalLock stateLock(mStateLock, std::this_thread::get_id() != mMainThreadId);
5909 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
5910 if (!displayId) {
5911 ALOGE("getAllowedDisplayConfigs: display not found");
5912 return NAME_NOT_FOUND;
5913 }
5914
5915 std::lock_guard allowedConfigLock(mAllowedConfigsLock);
5916 auto allowedConfigIterator = mAllowedConfigs.find(displayId.value());
5917 if (allowedConfigIterator != mAllowedConfigs.end()) {
5918 allowedConfigIterator->second->getAllowedConfigs(outAllowedConfigs);
5919 }
5920
5921 return NO_ERROR;
5922}
5923
chaviw291d88a2019-02-14 10:33:58 -08005924// ----------------------------------------------------------------------------
5925
5926void SetInputWindowsListener::onSetInputWindowsFinished() {
5927 mFlinger->setInputWindowsFinished();
5928}
5929
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005930}; // namespace android
Mathias Agopian3f844832013-08-07 21:24:32 -07005931
Lloyd Pique074e8122018-07-26 12:57:23 -07005932
Mathias Agopian3f844832013-08-07 21:24:32 -07005933#if defined(__gl_h_)
5934#error "don't include gl/gl.h in this file"
5935#endif
5936
5937#if defined(__gl2_h_)
5938#error "don't include gl2/gl2.h in this file"
Chia-I Wu767fcf72017-11-30 22:07:38 -08005939#endif