blob: 1b31674d03d51fb8f2486a4d1e1b613f1dc3bfd9 [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
Dan Stoza9e56aa02015-11-02 13:00:03 -080017// #define LOG_NDEBUG 0
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080018#define ATRACE_TAG ATRACE_TAG_GRAPHICS
19
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080020#include <stdint.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070021#include <sys/types.h>
Romain Guy0147a172017-06-01 13:53:56 -070022#include <algorithm>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080023#include <errno.h>
24#include <math.h>
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -070025#include <mutex>
Keun young Park63f165f2012-08-31 10:53:36 -070026#include <dlfcn.h>
Greg Hackmann86efcc02014-03-07 12:44:02 -080027#include <inttypes.h>
Jesse Hallb154c422014-07-13 12:47:02 -070028#include <stdatomic.h>
Dan Stoza2b6d38e2017-06-01 16:40:30 -070029#include <optional>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070030
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080031#include <cutils/properties.h>
Mark Salyzyn7823e122016-09-29 08:08:05 -070032#include <log/log.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080033
Mathias Agopianc5b2c0b2009-05-19 19:08:10 -070034#include <binder/IPCThreadState.h>
35#include <binder/IServiceManager.h>
Mathias Agopian99b49842011-06-27 16:05:52 -070036#include <binder/PermissionCache.h>
Mathias Agopian7303c6b2009-07-02 18:11:53 -070037
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -080038#include <dvr/vr_flinger.h>
39
Robert Carr720e5062018-07-30 17:45:14 -070040#include <input/IInputFlinger.h>
41
Chia-I Wud49d6692018-06-27 07:17:41 +080042#include <ui/ColorSpace.h>
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -060043#include <ui/DebugUtils.h>
Mathias Agopianc666cae2012-07-25 18:56:13 -070044#include <ui/DisplayInfo.h>
Lajos Molnar67d8bd62014-09-11 14:58:45 -070045#include <ui/DisplayStatInfo.h>
Mathias Agopianc666cae2012-07-25 18:56:13 -070046
Jamie Gennis1a4d8832012-08-02 20:11:05 -070047#include <gui/BufferQueue.h>
Andy McFadden4803b742012-09-24 19:07:20 -070048#include <gui/GuiConfig.h>
Jamie Gennis1a4d8832012-08-02 20:11:05 -070049#include <gui/IDisplayEventConnection.h>
Alec Mouri0a9c7b82018-11-16 13:05:25 -080050#include <gui/IProducerListener.h>
Kalle Raitaa099a242017-01-11 11:17:29 -080051#include <gui/LayerDebugInfo.h>
Mathias Agopiane3c697f2013-02-14 17:11:02 -080052#include <gui/Surface.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070053#include <renderengine/RenderEngine.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070054#include <ui/GraphicBufferAllocator.h>
55#include <ui/PixelFormat.h>
Andy McFadden4803b742012-09-24 19:07:20 -070056#include <ui/UiConfig.h>
Mathias Agopiand0566bc2011-11-17 17:49:17 -080057
Mathias Agopiancde87a32012-09-13 14:09:01 -070058#include <utils/misc.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080059#include <utils/String8.h>
60#include <utils/String16.h>
61#include <utils/StopWatch.h>
Yusuke Sato0a688f52015-07-30 23:05:39 -070062#include <utils/Timers.h>
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080063#include <utils/Trace.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080064
Mathias Agopian921e6ac2012-07-23 23:11:29 -070065#include <private/android_filesystem_config.h>
Mathias Agopianca088332013-03-28 17:44:13 -070066#include <private/gui/SyncFeatures.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080067
Robert Carr578038f2018-03-09 12:25:24 -080068#include "BufferLayer.h"
Marissa Wallfd668622018-05-10 10:21:13 -070069#include "BufferQueueLayer.h"
Marissa Wall61c58622018-07-18 10:12:20 -070070#include "BufferStateLayer.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +020071#include "Client.h"
Robert Carr578038f2018-03-09 12:25:24 -080072#include "ColorLayer.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +020073#include "Colorizer.h"
Robert Carr578038f2018-03-09 12:25:24 -080074#include "ContainerLayer.h"
Mathias Agopian90ac7992012-02-25 18:48:35 -080075#include "DdmConnection.h"
Robert Carr578038f2018-03-09 12:25:24 -080076#include "DisplayDevice.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080077#include "Layer.h"
Robert Carr1f0a16a2016-10-24 16:27:39 -070078#include "LayerVector.h"
Robert Carr1db73f62016-12-21 12:58:51 -080079#include "MonitoredProducer.h"
Lloyd Pique22098362018-09-13 11:46:49 -070080#include "NativeWindowSurface.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070081#include "StartPropertySetThread.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080082#include "SurfaceFlinger.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070083#include "SurfaceInterceptor.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080084
Steven Thomasb02664d2017-07-26 18:48:28 -070085#include "DisplayHardware/ComposerHal.h"
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -070086#include "DisplayHardware/DisplayIdentification.h"
Mathias Agopiana4912602012-07-12 14:25:33 -070087#include "DisplayHardware/FramebufferSurface.h"
Mathias Agopiana350ff92010-08-10 17:14:02 -070088#include "DisplayHardware/HWComposer.h"
Jesse Hall99c7dbb2013-03-14 14:29:29 -070089#include "DisplayHardware/VirtualDisplaySurface.h"
Mathias Agopianff2ed702013-09-01 21:36:12 -070090#include "Effects/Daltonizer.h"
Ana Krulecfefcb582018-08-07 14:22:37 -070091#include "Scheduler/DispSync.h"
Ana Krulec241cf832018-08-10 15:03:23 -070092#include "Scheduler/DispSyncSource.h"
Ana Krulecfefcb582018-08-07 14:22:37 -070093#include "Scheduler/EventControlThread.h"
94#include "Scheduler/EventThread.h"
Ana Krulec47454452018-08-14 11:04:14 -070095#include "Scheduler/InjectVSyncSource.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070096#include "Scheduler/MessageQueue.h"
Ana Krulec98b5b242018-08-10 15:03:23 -070097#include "Scheduler/Scheduler.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -080098#include "TimeStats/TimeStats.h"
Ana Krulecfefcb582018-08-07 14:22:37 -070099
Mathias Agopianff2ed702013-09-01 21:36:12 -0700100#include <cutils/compiler.h>
Mathias Agopian875d8e12013-06-07 15:35:48 -0700101
David Sodman7e4ae112018-02-09 15:02:28 -0800102#include "android-base/stringprintf.h"
103
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900104#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
Iris Chang7501ed62018-04-30 14:45:42 +0800105#include <android/hardware/configstore/1.1/ISurfaceFlingerConfigs.h>
Peiyong Lin13effd12018-07-24 17:01:47 -0700106#include <android/hardware/configstore/1.2/ISurfaceFlingerConfigs.h>
Iris Chang7501ed62018-04-30 14:45:42 +0800107#include <android/hardware/configstore/1.1/types.h>
Jaesoo Lee43518572017-01-23 19:03:16 +0900108#include <configstore/Utils.h>
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900109
chaviw1d044282017-09-27 12:19:28 -0700110#include <layerproto/LayerProtoParser.h>
111
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800112namespace android {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700113
Jaesoo Lee43518572017-01-23 19:03:16 +0900114using namespace android::hardware::configstore;
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900115using namespace android::hardware::configstore::V1_0;
Yiwei Zhang5434a782018-12-05 18:06:32 -0800116using base::StringAppendF;
Peiyong Lin9f034472018-03-28 15:29:00 -0700117using ui::ColorMode;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700118using ui::Dataspace;
Peiyong Lin62665892018-04-16 11:07:44 -0700119using ui::Hdr;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700120using ui::RenderIntent;
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900121
Steven Thomasb02664d2017-07-26 18:48:28 -0700122namespace {
Peiyong Linfca547f2018-07-09 13:03:33 -0700123
124#pragma clang diagnostic push
125#pragma clang diagnostic error "-Wswitch-enum"
126
127bool isWideColorMode(const ColorMode colorMode) {
128 switch (colorMode) {
129 case ColorMode::DISPLAY_P3:
130 case ColorMode::ADOBE_RGB:
131 case ColorMode::DCI_P3:
132 case ColorMode::BT2020:
Valerie Hau9758ae02018-10-09 16:05:09 -0700133 case ColorMode::DISPLAY_BT2020:
Peiyong Linfca547f2018-07-09 13:03:33 -0700134 case ColorMode::BT2100_PQ:
135 case ColorMode::BT2100_HLG:
136 return true;
137 case ColorMode::NATIVE:
138 case ColorMode::STANDARD_BT601_625:
139 case ColorMode::STANDARD_BT601_625_UNADJUSTED:
140 case ColorMode::STANDARD_BT601_525:
141 case ColorMode::STANDARD_BT601_525_UNADJUSTED:
142 case ColorMode::STANDARD_BT709:
143 case ColorMode::SRGB:
144 return false;
145 }
146 return false;
147}
148
Chia-I Wuc80dcbb2018-08-24 15:34:02 -0700149ui::Transform::orientation_flags fromSurfaceComposerRotation(ISurfaceComposer::Rotation rotation) {
150 switch (rotation) {
151 case ISurfaceComposer::eRotateNone:
152 return ui::Transform::ROT_0;
153 case ISurfaceComposer::eRotate90:
154 return ui::Transform::ROT_90;
155 case ISurfaceComposer::eRotate180:
156 return ui::Transform::ROT_180;
157 case ISurfaceComposer::eRotate270:
158 return ui::Transform::ROT_270;
159 }
160 ALOGE("Invalid rotation passed to captureScreen(): %d\n", rotation);
161 return ui::Transform::ROT_0;
162}
163
Peiyong Linfca547f2018-07-09 13:03:33 -0700164#pragma clang diagnostic pop
165
Steven Thomasb02664d2017-07-26 18:48:28 -0700166class ConditionalLock {
167public:
168 ConditionalLock(Mutex& mutex, bool lock) : mMutex(mutex), mLocked(lock) {
169 if (lock) {
170 mMutex.lock();
171 }
172 }
173 ~ConditionalLock() { if (mLocked) mMutex.unlock(); }
174private:
175 Mutex& mMutex;
176 bool mLocked;
177};
Peiyong Linfca547f2018-07-09 13:03:33 -0700178
Peiyong Lin9d846a52018-11-05 13:18:20 -0800179// Currently we only support V0_SRGB and DISPLAY_P3 as composition preference.
180bool validateCompositionDataspace(Dataspace dataspace) {
181 return dataspace == Dataspace::V0_SRGB || dataspace == Dataspace::DISPLAY_P3;
182}
183
Steven Thomasb02664d2017-07-26 18:48:28 -0700184} // namespace anonymous
185
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800186// ---------------------------------------------------------------------------
187
Mathias Agopian99b49842011-06-27 16:05:52 -0700188const String16 sHardwareTest("android.permission.HARDWARE_TEST");
189const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER");
190const String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER");
191const String16 sDump("android.permission.DUMP");
192
193// ---------------------------------------------------------------------------
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800194int64_t SurfaceFlinger::vsyncPhaseOffsetNs;
195int64_t SurfaceFlinger::sfVsyncPhaseOffsetNs;
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700196int64_t SurfaceFlinger::dispSyncPresentTimeOffset;
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700197bool SurfaceFlinger::useHwcForRgbToYuv;
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800198uint64_t SurfaceFlinger::maxVirtualDisplaySize;
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800199bool SurfaceFlinger::hasSyncFramework;
Steven Thomas050b2c82017-03-06 11:45:16 -0800200bool SurfaceFlinger::useVrFlinger;
Fabien Sanglard1971b632017-03-10 14:50:03 -0800201int64_t SurfaceFlinger::maxFrameBufferAcquiredBuffers;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600202bool SurfaceFlinger::hasWideColorDisplay;
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700203int SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientationDefault;
Peiyong Lin13effd12018-07-24 17:01:47 -0700204bool SurfaceFlinger::useColorManagement;
Peiyong Linb3839ad2018-09-05 15:37:19 -0700205bool SurfaceFlinger::useContextPriority;
Peiyong Linc6780972018-10-28 15:24:08 -0700206Dataspace SurfaceFlinger::defaultCompositionDataspace = Dataspace::V0_SRGB;
207ui::PixelFormat SurfaceFlinger::defaultCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
208Dataspace SurfaceFlinger::wideColorGamutCompositionDataspace = Dataspace::V0_SRGB;
209ui::PixelFormat SurfaceFlinger::wideColorGamutCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
Mathias Agopian99b49842011-06-27 16:05:52 -0700210
Kalle Raitaa099a242017-01-11 11:17:29 -0800211std::string getHwcServiceName() {
212 char value[PROPERTY_VALUE_MAX] = {};
213 property_get("debug.sf.hwc_service_name", value, "default");
214 ALOGI("Using HWComposer service: '%s'", value);
215 return std::string(value);
216}
217
218bool useTrebleTestingOverride() {
219 char value[PROPERTY_VALUE_MAX] = {};
220 property_get("debug.sf.treble_testing_override", value, "false");
221 ALOGI("Treble testing override: '%s'", value);
222 return std::string(value) == "true";
223}
224
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800225std::string decodeDisplayColorSetting(DisplayColorSetting displayColorSetting) {
226 switch(displayColorSetting) {
227 case DisplayColorSetting::MANAGED:
Chia-I Wu0d711262018-05-21 15:19:35 -0700228 return std::string("Managed");
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800229 case DisplayColorSetting::UNMANAGED:
Chia-I Wu0d711262018-05-21 15:19:35 -0700230 return std::string("Unmanaged");
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800231 case DisplayColorSetting::ENHANCED:
Chia-I Wu0d711262018-05-21 15:19:35 -0700232 return std::string("Enhanced");
233 default:
234 return std::string("Unknown ") +
235 std::to_string(static_cast<int>(displayColorSetting));
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800236 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800237}
238
David Sodmanbc815282017-11-05 18:57:52 -0800239SurfaceFlingerBE::SurfaceFlingerBE()
240 : mHwcServiceName(getHwcServiceName()),
241 mRenderEngine(nullptr),
David Sodman4a36e932017-11-07 14:29:47 -0800242 mFrameBuckets(),
243 mTotalTime(0),
244 mLastSwapTime(0),
David Sodmanbc815282017-11-05 18:57:52 -0800245 mComposerSequenceId(0) {
246}
247
Lloyd Pique90c115d2018-09-18 21:39:42 -0700248SurfaceFlinger::SurfaceFlinger(surfaceflinger::Factory& factory,
249 SurfaceFlinger::SkipInitializationTag)
Lloyd Pique12eb4232018-01-17 11:54:43 -0800250 : BnSurfaceComposer(),
Lloyd Pique90c115d2018-09-18 21:39:42 -0700251 mFactory(factory),
Jamie Gennis2d5e2302012-10-15 18:24:43 -0700252 mTransactionPending(false),
253 mAnimTransactionPending(false),
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700254 mLayersRemoved(false),
Robert Carr1f0a16a2016-10-24 16:27:39 -0700255 mLayersAdded(false),
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800256 mBootTime(systemTime()),
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800257 mVisibleRegionsDirty(false),
Dan Stoza9e56aa02015-11-02 13:00:03 -0800258 mGeometryInvalid(false),
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800259 mAnimCompositionPending(false),
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800260 mBootStage(BootStage::BOOTLOADER),
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800261 mDebugRegion(0),
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700262 mDebugDDMS(0),
Mathias Agopian73d3ba92010-09-22 18:58:01 -0700263 mDebugDisableHWC(0),
Mathias Agopiana4583642011-08-23 18:03:18 -0700264 mDebugDisableTransformHint(0),
Mathias Agopian9795c422009-08-26 16:36:26 -0700265 mDebugInTransaction(0),
266 mLastTransactionTime(0),
Dan Stozaee44edd2015-03-23 15:50:23 -0700267 mForceFullDamage(false),
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800268 mTimeStats(factory.createTimeStats()),
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700269 mPrimaryHWVsyncEnabled(false),
Jesse Hall948fe0c2013-10-14 12:56:09 -0700270 mHWVsyncAvailable(false),
David Sodman2b406362017-12-15 13:33:47 -0800271 mRefreshStartTime(0),
Dan Stozab90cf072015-03-05 11:05:59 -0800272 mHasPoweredOff(false),
Steven Thomas050b2c82017-03-06 11:45:16 -0800273 mNumLayers(0),
Steven Thomasb02664d2017-07-26 18:48:28 -0700274 mVrFlingerRequestsDisplay(false),
Lloyd Pique90c115d2018-09-18 21:39:42 -0700275 mMainThreadId(std::this_thread::get_id()) {}
Lloyd Piqueac648ee2018-01-17 13:42:24 -0800276
Lloyd Pique90c115d2018-09-18 21:39:42 -0700277SurfaceFlinger::SurfaceFlinger(surfaceflinger::Factory& factory)
278 : SurfaceFlinger(factory, SkipInitialization) {
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800279 ALOGI("SurfaceFlinger is starting");
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800280
281 vsyncPhaseOffsetNs = getInt64< ISurfaceFlingerConfigs,
282 &ISurfaceFlingerConfigs::vsyncEventPhaseOffsetNs>(1000000);
283
284 sfVsyncPhaseOffsetNs = getInt64< ISurfaceFlingerConfigs,
285 &ISurfaceFlingerConfigs::vsyncSfEventPhaseOffsetNs>(1000000);
286
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800287 hasSyncFramework = getBool< ISurfaceFlingerConfigs,
288 &ISurfaceFlingerConfigs::hasSyncFramework>(true);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800289
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700290 dispSyncPresentTimeOffset = getInt64< ISurfaceFlingerConfigs,
291 &ISurfaceFlingerConfigs::presentTimeOffsetFromVSyncNs>(0);
292
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700293 useHwcForRgbToYuv = getBool< ISurfaceFlingerConfigs,
294 &ISurfaceFlingerConfigs::useHwcForRGBtoYUV>(false);
295
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800296 maxVirtualDisplaySize = getUInt64<ISurfaceFlingerConfigs,
297 &ISurfaceFlingerConfigs::maxVirtualDisplaySize>(0);
298
Steven Thomas050b2c82017-03-06 11:45:16 -0800299 // Vr flinger is only enabled on Daydream ready devices.
300 useVrFlinger = getBool< ISurfaceFlingerConfigs,
301 &ISurfaceFlingerConfigs::useVrFlinger>(false);
302
Fabien Sanglard1971b632017-03-10 14:50:03 -0800303 maxFrameBufferAcquiredBuffers = getInt64< ISurfaceFlingerConfigs,
304 &ISurfaceFlingerConfigs::maxFrameBufferAcquiredBuffers>(2);
305
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600306 hasWideColorDisplay =
307 getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::hasWideColorDisplay>(false);
Peiyong Lin13effd12018-07-24 17:01:47 -0700308 useColorManagement =
Peiyong Lin0256f722018-08-31 15:45:10 -0700309 getBool<V1_2::ISurfaceFlingerConfigs,
310 &V1_2::ISurfaceFlingerConfigs::useColorManagement>(false);
311
312 auto surfaceFlingerConfigsServiceV1_2 = V1_2::ISurfaceFlingerConfigs::getService();
313 if (surfaceFlingerConfigsServiceV1_2) {
314 surfaceFlingerConfigsServiceV1_2->getCompositionPreference(
Peiyong Linc6780972018-10-28 15:24:08 -0700315 [&](auto tmpDefaultDataspace, auto tmpDefaultPixelFormat,
316 auto tmpWideColorGamutDataspace, auto tmpWideColorGamutPixelFormat) {
317 defaultCompositionDataspace = tmpDefaultDataspace;
318 defaultCompositionPixelFormat = tmpDefaultPixelFormat;
319 wideColorGamutCompositionDataspace = tmpWideColorGamutDataspace;
320 wideColorGamutCompositionPixelFormat = tmpWideColorGamutPixelFormat;
321 });
Peiyong Lin0256f722018-08-31 15:45:10 -0700322 }
Peiyong Lin9d846a52018-11-05 13:18:20 -0800323 mDefaultCompositionDataspace = defaultCompositionDataspace;
324 mWideColorGamutCompositionDataspace = wideColorGamutCompositionDataspace;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600325
Peiyong Linb3839ad2018-09-05 15:37:19 -0700326 useContextPriority = getBool<ISurfaceFlingerConfigs,
327 &ISurfaceFlingerConfigs::useContextPriority>(true);
328
Iris Chang7501ed62018-04-30 14:45:42 +0800329 V1_1::DisplayOrientation primaryDisplayOrientation =
Peiyong Lin0256f722018-08-31 15:45:10 -0700330 getDisplayOrientation<V1_1::ISurfaceFlingerConfigs,
331 &V1_1::ISurfaceFlingerConfigs::primaryDisplayOrientation>(
Iris Chang7501ed62018-04-30 14:45:42 +0800332 V1_1::DisplayOrientation::ORIENTATION_0);
333
334 switch (primaryDisplayOrientation) {
335 case V1_1::DisplayOrientation::ORIENTATION_90:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700336 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientation90;
Iris Chang7501ed62018-04-30 14:45:42 +0800337 break;
338 case V1_1::DisplayOrientation::ORIENTATION_180:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700339 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientation180;
Iris Chang7501ed62018-04-30 14:45:42 +0800340 break;
341 case V1_1::DisplayOrientation::ORIENTATION_270:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700342 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientation270;
Iris Chang7501ed62018-04-30 14:45:42 +0800343 break;
344 default:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700345 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientationDefault;
Iris Chang7501ed62018-04-30 14:45:42 +0800346 break;
347 }
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700348 ALOGV("Primary Display Orientation is set to %2d.", SurfaceFlinger::primaryDisplayOrientation);
Iris Chang7501ed62018-04-30 14:45:42 +0800349
Lloyd Pique90c115d2018-09-18 21:39:42 -0700350 mPrimaryDispSync =
351 getFactory().createDispSync("PrimaryDispSync", SurfaceFlinger::hasSyncFramework,
352 SurfaceFlinger::dispSyncPresentTimeOffset);
Saurabh Shahf4174532017-07-13 10:45:07 -0700353
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800354 // debugging stuff...
355 char value[PROPERTY_VALUE_MAX];
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700356
Mathias Agopianb4b17302013-03-20 18:36:41 -0700357 property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");
Mathias Agopian50210b92013-03-21 21:13:21 -0700358 mGpuToCpuSupported = !atoi(value);
Mathias Agopianb4b17302013-03-20 18:36:41 -0700359
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800360 property_get("debug.sf.showupdates", value, "0");
361 mDebugRegion = atoi(value);
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700362
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700363 property_get("debug.sf.ddms", value, "0");
364 mDebugDDMS = atoi(value);
365 if (mDebugDDMS) {
Keun young Park63f165f2012-08-31 10:53:36 -0700366 if (!startDdmConnection()) {
367 // start failed, and DDMS debugging not enabled
368 mDebugDDMS = 0;
369 }
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700370 }
Mathias Agopianc1d359d2012-08-04 20:09:03 -0700371 ALOGI_IF(mDebugRegion, "showupdates enabled");
372 ALOGI_IF(mDebugDDMS, "DDMS debugging enabled");
Dan Stozac5da2712016-07-20 15:38:12 -0700373
374 property_get("debug.sf.disable_backpressure", value, "0");
375 mPropagateBackpressure = !atoi(value);
376 ALOGI_IF(!mPropagateBackpressure, "Disabling backpressure propagation");
Dan Stoza8cf150a2016-08-02 10:27:31 -0700377
Fabien Sanglard642b23d2017-02-09 12:29:39 -0800378 property_get("debug.sf.enable_hwc_vds", value, "0");
379 mUseHwcVirtualDisplays = atoi(value);
Chia-I Wu11d10612018-06-21 15:41:13 +0800380 ALOGI_IF(mUseHwcVirtualDisplays, "Enabling HWC virtual displays");
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800381
Yiwei Zhangb770ed32018-12-17 17:44:28 -0800382 property_get("ro.sf.disable_triple_buffer", value, "0");
Fabien Sanglardc65dafa2017-02-07 14:06:39 -0800383 mLayerTripleBufferingDisabled = atoi(value);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800384 ALOGI_IF(mLayerTripleBufferingDisabled, "Disabling Triple Buffering");
Romain Guy3054f002017-06-05 18:38:53 -0700385
Yiwei Zhang243b3782018-05-15 17:40:04 -0700386 const size_t defaultListSize = MAX_LAYERS;
Dan Stoza0a0158c2018-03-16 13:38:54 -0700387 auto listSize = property_get_int32("debug.sf.max_igbp_list_size", int32_t(defaultListSize));
388 mMaxGraphicBufferProducerListSize = (listSize > 0) ? size_t(listSize) : defaultListSize;
389
Jorim Jaggi22ec38b2018-06-19 15:57:08 +0200390 property_get("debug.sf.early_phase_offset_ns", value, "-1");
391 const int earlySfOffsetNs = atoi(value);
392
393 property_get("debug.sf.early_gl_phase_offset_ns", value, "-1");
394 const int earlyGlSfOffsetNs = atoi(value);
395
396 property_get("debug.sf.early_app_phase_offset_ns", value, "-1");
397 const int earlyAppOffsetNs = atoi(value);
398
399 property_get("debug.sf.early_gl_app_phase_offset_ns", value, "-1");
400 const int earlyGlAppOffsetNs = atoi(value);
401
Ana Krulec98b5b242018-08-10 15:03:23 -0700402 property_get("debug.sf.use_scheduler", value, "0");
403 mUseScheduler = atoi(value);
404
Jorim Jaggi22ec38b2018-06-19 15:57:08 +0200405 const VSyncModulator::Offsets earlyOffsets =
406 {earlySfOffsetNs != -1 ? earlySfOffsetNs : sfVsyncPhaseOffsetNs,
407 earlyAppOffsetNs != -1 ? earlyAppOffsetNs : vsyncPhaseOffsetNs};
408 const VSyncModulator::Offsets earlyGlOffsets =
409 {earlyGlSfOffsetNs != -1 ? earlyGlSfOffsetNs : sfVsyncPhaseOffsetNs,
410 earlyGlAppOffsetNs != -1 ? earlyGlAppOffsetNs : vsyncPhaseOffsetNs};
411 mVsyncModulator.setPhaseOffsets(earlyOffsets, earlyGlOffsets,
412 {sfVsyncPhaseOffsetNs, vsyncPhaseOffsetNs});
Dan Stoza84d619e2018-03-28 17:07:36 -0700413
Romain Guy11d63f42017-07-20 12:47:14 -0700414 // We should be reading 'persist.sys.sf.color_saturation' here
415 // but since /data may be encrypted, we need to wait until after vold
416 // comes online to attempt to read the property. The property is
417 // instead read after the boot animation
Kalle Raitaa099a242017-01-11 11:17:29 -0800418
419 if (useTrebleTestingOverride()) {
420 // Without the override SurfaceFlinger cannot connect to HIDL
421 // services that are not listed in the manifests. Considered
422 // deriving the setting from the set service name, but it
423 // would be brittle if the name that's not 'default' is used
424 // for production purposes later on.
425 setenv("TREBLE_TESTING_OVERRIDE", "true", true);
426 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800427}
428
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800429void SurfaceFlinger::onFirstRef()
430{
Lloyd Pique3fcdef12018-01-22 17:14:00 -0800431 mEventQueue->init(this);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800432}
433
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800434SurfaceFlinger::~SurfaceFlinger()
435{
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800436}
437
Dan Stozac7014012014-02-14 15:03:43 -0800438void SurfaceFlinger::binderDied(const wp<IBinder>& /* who */)
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800439{
440 // the window manager died on us. prepare its eulogy.
441
Andy McFadden13a082e2012-08-24 10:16:42 -0700442 // restore initial conditions (default device unblank, etc)
443 initializeDisplays();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800444
445 // restart the boot-animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700446 startBootAnim();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800447}
448
Robert Carr1db73f62016-12-21 12:58:51 -0800449static sp<ISurfaceComposerClient> initClient(const sp<Client>& client) {
Mathias Agopian96f08192010-06-02 23:28:45 -0700450 status_t err = client->initCheck();
451 if (err == NO_ERROR) {
Robert Carr1db73f62016-12-21 12:58:51 -0800452 return client;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800453 }
Robert Carr1db73f62016-12-21 12:58:51 -0800454 return nullptr;
455}
456
457sp<ISurfaceComposerClient> SurfaceFlinger::createConnection() {
458 return initClient(new Client(this));
459}
460
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700461sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName,
462 bool secure)
Mathias Agopiane57f2922012-08-09 16:29:12 -0700463{
464 class DisplayToken : public BBinder {
465 sp<SurfaceFlinger> flinger;
466 virtual ~DisplayToken() {
467 // no more references, this display must be terminated
468 Mutex::Autolock _l(flinger->mStateLock);
469 flinger->mCurrentState.displays.removeItem(this);
470 flinger->setTransactionFlags(eDisplayTransactionNeeded);
471 }
472 public:
Chih-Hung Hsiehc4067912016-05-03 14:03:27 -0700473 explicit DisplayToken(const sp<SurfaceFlinger>& flinger)
Mathias Agopiane57f2922012-08-09 16:29:12 -0700474 : flinger(flinger) {
475 }
476 };
477
478 sp<BBinder> token = new DisplayToken(this);
479
480 Mutex::Autolock _l(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700481 // Display ID is assigned when virtual display is allocated by HWC.
482 DisplayDeviceState state;
483 state.isSecure = secure;
484 state.displayName = displayName;
485 mCurrentState.displays.add(token, state);
486 mInterceptor->saveDisplayCreation(state);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700487 return token;
488}
489
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700490void SurfaceFlinger::destroyDisplay(const sp<IBinder>& displayToken) {
Jesse Hall6c913be2013-08-08 12:15:49 -0700491 Mutex::Autolock _l(mStateLock);
492
Dominik Laskowski075d3172018-05-24 15:50:06 -0700493 ssize_t index = mCurrentState.displays.indexOfKey(displayToken);
494 if (index < 0) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700495 ALOGE("destroyDisplay: Invalid display token %p", displayToken.get());
Jesse Hall6c913be2013-08-08 12:15:49 -0700496 return;
497 }
498
Dominik Laskowski075d3172018-05-24 15:50:06 -0700499 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
500 if (!state.isVirtual()) {
Jesse Hall6c913be2013-08-08 12:15:49 -0700501 ALOGE("destroyDisplay called for non-virtual display");
502 return;
503 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700504 mInterceptor->saveDisplayDeletion(state.sequenceId);
505 mCurrentState.displays.removeItemsAt(index);
Jesse Hall6c913be2013-08-08 12:15:49 -0700506 setTransactionFlags(eDisplayTransactionNeeded);
507}
508
Mathias Agopiane57f2922012-08-09 16:29:12 -0700509sp<IBinder> SurfaceFlinger::getBuiltInDisplay(int32_t id) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700510 std::optional<DisplayId> displayId;
511
512 if (id == HWC_DISPLAY_PRIMARY) {
513 displayId = getInternalDisplayId();
514 } else if (id == HWC_DISPLAY_EXTERNAL) {
515 displayId = getExternalDisplayId();
516 }
517
518 if (!displayId) {
519 ALOGE("%s: Invalid display %d", __FUNCTION__, id);
Peiyong Lin566a3b42018-01-09 18:22:43 -0800520 return nullptr;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700521 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700522
523 return getPhysicalDisplayToken(*displayId);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700524}
525
Ady Abraham37965d42018-11-01 13:43:32 -0700526status_t SurfaceFlinger::getColorManagement(bool* outGetColorManagement) const {
527 if (!outGetColorManagement) {
528 return BAD_VALUE;
529 }
530 *outGetColorManagement = useColorManagement;
531 return NO_ERROR;
Ady Abraham2a6ab2a2018-10-26 14:25:30 -0700532}
533
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800534void SurfaceFlinger::bootFinished()
535{
Wei Wangf9b05ee2017-07-19 20:59:39 -0700536 if (mStartPropertySetThread->join() != NO_ERROR) {
537 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800538 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800539 const nsecs_t now = systemTime();
540 const nsecs_t duration = now - mBootTime;
Steve Blocka19954a2012-01-04 20:05:49 +0000541 ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700542
543 // wait patiently for the window manager death
544 const String16 name("window");
545 sp<IBinder> window(defaultServiceManager()->getService(name));
546 if (window != 0) {
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700547 window->linkToDeath(static_cast<IBinder::DeathRecipient*>(this));
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700548 }
Robert Carr720e5062018-07-30 17:45:14 -0700549 sp<IBinder> input(defaultServiceManager()->getService(
550 String16("inputflinger")));
551 if (input == nullptr) {
552 ALOGE("Failed to link to input service");
553 } else {
554 mInputFlinger = interface_cast<IInputFlinger>(input);
555 }
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700556
Steven Thomas050b2c82017-03-06 11:45:16 -0800557 if (mVrFlinger) {
558 mVrFlinger->OnBootFinished();
559 }
560
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700561 // stop boot animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700562 // formerly we would just kill the process, but we now ask it to exit so it
563 // can choose where to stop the animation.
564 property_set("service.bootanim.exit", "1");
Yusuke Sato0a688f52015-07-30 23:05:39 -0700565
566 const int LOGTAG_SF_STOP_BOOTANIM = 60110;
567 LOG_EVENT_LONG(LOGTAG_SF_STOP_BOOTANIM,
568 ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
Romain Guy11d63f42017-07-20 12:47:14 -0700569
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800570 postMessageAsync(new LambdaMessage([this] {
571 readPersistentProperties();
572 mBootStage = BootStage::FINISHED;
573 }));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800574}
575
Dan Stoza436ccf32018-06-21 12:10:12 -0700576uint32_t SurfaceFlinger::getNewTexture() {
577 {
578 std::lock_guard lock(mTexturePoolMutex);
579 if (!mTexturePool.empty()) {
580 uint32_t name = mTexturePool.back();
581 mTexturePool.pop_back();
582 ATRACE_INT("TexturePoolSize", mTexturePool.size());
583 return name;
584 }
585
586 // The pool was too small, so increase it for the future
587 ++mTexturePoolSize;
588 }
589
590 // The pool was empty, so we need to get a new texture name directly using a
591 // blocking call to the main thread
592 uint32_t name = 0;
593 postMessageSync(new LambdaMessage([&]() { getRenderEngine().genTextures(1, &name); }));
594 return name;
595}
596
Mathias Agopian3f844832013-08-07 21:24:32 -0700597void SurfaceFlinger::deleteTextureAsync(uint32_t texture) {
Dominik Laskowski8c001672018-05-30 16:52:06 -0700598 postMessageAsync(new LambdaMessage([=] { getRenderEngine().deleteTextures(1, &texture); }));
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700599}
600
Wei Wangf9b05ee2017-07-19 20:59:39 -0700601// Do not call property_set on main thread which will be blocked by init
602// Use StartPropertySetThread instead.
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700603void SurfaceFlinger::init() {
Mathias Agopiana4912602012-07-12 14:25:33 -0700604 ALOGI( "SurfaceFlinger's main thread ready to run. "
605 "Initializing graphics H/W...");
606
Thierry Strudel2924d012017-08-14 15:19:37 -0700607 ALOGI("Phase offest NS: %" PRId64 "", vsyncPhaseOffsetNs);
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900608
Steven Thomasb02664d2017-07-26 18:48:28 -0700609 Mutex::Autolock _l(mStateLock);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800610
Steven Thomasb02664d2017-07-26 18:48:28 -0700611 // start the EventThread
Ana Krulec98b5b242018-08-10 15:03:23 -0700612 if (mUseScheduler) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700613 mScheduler = getFactory().createScheduler([this](bool enabled) {
614 setVsyncEnabled(EventThread::DisplayType::Primary, enabled);
615 });
616
Ana Krulec98b5b242018-08-10 15:03:23 -0700617 mAppConnectionHandle =
Ana Krulece588e312018-09-18 12:32:24 -0700618 mScheduler->createConnection("appConnection", SurfaceFlinger::vsyncPhaseOffsetNs,
Ana Krulec98b5b242018-08-10 15:03:23 -0700619 [this] { resyncWithRateLimit(); },
620 impl::EventThread::InterceptVSyncsCallback());
621 mSfConnectionHandle =
Ana Krulece588e312018-09-18 12:32:24 -0700622 mScheduler->createConnection("sfConnection", SurfaceFlinger::sfVsyncPhaseOffsetNs,
Ana Krulec98b5b242018-08-10 15:03:23 -0700623 [this] { resyncWithRateLimit(); },
624 [this](nsecs_t timestamp) {
625 mInterceptor->saveVSyncEvent(timestamp);
626 });
Lloyd Pique3fcdef12018-01-22 17:14:00 -0800627
Ana Krulec98b5b242018-08-10 15:03:23 -0700628 mEventQueue->setEventConnection(mScheduler->getEventConnection(mSfConnectionHandle));
Ana Krulec12096d02018-09-07 14:54:14 -0700629 mVsyncModulator.setSchedulerAndHandles(mScheduler.get(), mAppConnectionHandle.get(),
630 mSfConnectionHandle.get());
Ana Krulec98b5b242018-08-10 15:03:23 -0700631 } else {
632 mEventThreadSource =
633 std::make_unique<DispSyncSource>(mPrimaryDispSync.get(),
634 SurfaceFlinger::vsyncPhaseOffsetNs, true, "app");
635 mEventThread =
636 std::make_unique<impl::EventThread>(mEventThreadSource.get(),
637 [this] { resyncWithRateLimit(); },
638 impl::EventThread::InterceptVSyncsCallback(),
639 "appEventThread");
640 mSfEventThreadSource =
641 std::make_unique<DispSyncSource>(mPrimaryDispSync.get(),
642 SurfaceFlinger::sfVsyncPhaseOffsetNs, true, "sf");
643
644 mSFEventThread =
645 std::make_unique<impl::EventThread>(mSfEventThreadSource.get(),
646 [this] { resyncWithRateLimit(); },
647 [this](nsecs_t timestamp) {
648 mInterceptor->saveVSyncEvent(timestamp);
649 },
650 "sfEventThread");
651 mEventQueue->setEventThread(mSFEventThread.get());
652 mVsyncModulator.setEventThreads(mSFEventThread.get(), mEventThread.get());
653 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800654
Steven Thomasb02664d2017-07-26 18:48:28 -0700655 // Get a RenderEngine for the given display / config (can't fail)
Peiyong Lin13effd12018-07-24 17:01:47 -0700656 int32_t renderEngineFeature = 0;
Peiyong Lin833074a2018-08-28 11:53:54 -0700657 renderEngineFeature |= (useColorManagement ?
658 renderengine::RenderEngine::USE_COLOR_MANAGEMENT : 0);
Peiyong Linb3839ad2018-09-05 15:37:19 -0700659 renderEngineFeature |= (useContextPriority ?
660 renderengine::RenderEngine::USE_HIGH_PRIORITY_CONTEXT : 0);
Peiyong Lin0256f722018-08-31 15:45:10 -0700661
662 // TODO(b/77156734): We need to stop casting and use HAL types when possible.
663 getBE().mRenderEngine =
Peiyong Linc6780972018-10-28 15:24:08 -0700664 renderengine::RenderEngine::create(static_cast<int32_t>(defaultCompositionPixelFormat),
665 renderEngineFeature);
David Sodmanbc815282017-11-05 18:57:52 -0800666 LOG_ALWAYS_FATAL_IF(getBE().mRenderEngine == nullptr, "couldn't create RenderEngine");
Steven Thomasb02664d2017-07-26 18:48:28 -0700667
668 LOG_ALWAYS_FATAL_IF(mVrFlingerRequestsDisplay,
669 "Starting with vr flinger active is not currently supported.");
Lloyd Pique90c115d2018-09-18 21:39:42 -0700670 getBE().mHwc = getFactory().createHWComposer(getBE().mHwcServiceName);
David Sodman105b7dc2017-11-04 20:28:14 -0700671 getBE().mHwc->registerCallback(this, getBE().mComposerSequenceId);
Lloyd Piqueba04e622017-12-14 17:11:26 -0800672 // Process any initial hotplug and resulting display changes.
673 processDisplayHotplugEventsLocked();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700674 const auto display = getDefaultDisplayDeviceLocked();
675 LOG_ALWAYS_FATAL_IF(!display, "Missing internal display after registering composer callback.");
Dominik Laskowski075d3172018-05-24 15:50:06 -0700676 LOG_ALWAYS_FATAL_IF(!getHwComposer().isConnected(*display->getId()),
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700677 "Internal display is disconnected.");
Jesse Hall692c7232012-11-08 15:41:56 -0800678
Steven Thomas050b2c82017-03-06 11:45:16 -0800679 if (useVrFlinger) {
Dominik Laskowski8c001672018-05-30 16:52:06 -0700680 auto vrFlingerRequestDisplayCallback = [this](bool requestDisplay) {
Steven Thomasbe6cbae2017-09-28 15:30:23 -0700681 // This callback is called from the vr flinger dispatch thread. We
682 // need to call signalTransaction(), which requires holding
683 // mStateLock when we're not on the main thread. Acquiring
684 // mStateLock from the vr flinger dispatch thread might trigger a
685 // deadlock in surface flinger (see b/66916578), so post a message
686 // to be handled on the main thread instead.
Dominik Laskowski8c001672018-05-30 16:52:06 -0700687 postMessageAsync(new LambdaMessage([=] {
Steven Thomasbe6cbae2017-09-28 15:30:23 -0700688 ALOGI("VR request display mode: requestDisplay=%d", requestDisplay);
689 mVrFlingerRequestsDisplay = requestDisplay;
690 signalTransaction();
Dominik Laskowski8c001672018-05-30 16:52:06 -0700691 }));
Steven Thomas050b2c82017-03-06 11:45:16 -0800692 };
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700693 mVrFlinger = dvr::VrFlinger::Create(getHwComposer().getComposer(),
694 getHwComposer()
Dominik Laskowski075d3172018-05-24 15:50:06 -0700695 .fromPhysicalDisplayId(*display->getId())
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700696 .value_or(0),
697 vrFlingerRequestDisplayCallback);
Steven Thomas050b2c82017-03-06 11:45:16 -0800698 if (!mVrFlinger) {
699 ALOGE("Failed to start vrflinger");
700 }
701 }
702
Lloyd Pique90c115d2018-09-18 21:39:42 -0700703 mEventControlThread = getFactory().createEventControlThread(
Dominik Laskowski075d3172018-05-24 15:50:06 -0700704 [this](bool enabled) { setVsyncEnabled(EventThread::DisplayType::Primary, enabled); });
Jamie Gennisd1700752013-10-14 12:22:52 -0700705
Mathias Agopian92a979a2012-08-02 18:32:23 -0700706 // initialize our drawing state
707 mDrawingState = mCurrentState;
Mathias Agopian86303202012-07-24 22:46:10 -0700708
Andy McFadden13a082e2012-08-24 10:16:42 -0700709 // set initial conditions (e.g. unblank default device)
710 initializeDisplays();
711
David Sodmanbc815282017-11-05 18:57:52 -0800712 getBE().mRenderEngine->primeCache();
Dan Stoza4e637772016-07-28 13:31:51 -0700713
Wei Wangf9b05ee2017-07-19 20:59:39 -0700714 // Inform native graphics APIs whether the present timestamp is supported:
Lloyd Pique90c115d2018-09-18 21:39:42 -0700715
716 const bool presentFenceReliable =
717 !getHwComposer().hasCapability(HWC2::Capability::PresentFenceIsNotReliable);
718 mStartPropertySetThread = getFactory().createStartPropertySetThread(presentFenceReliable);
Wei Wangf9b05ee2017-07-19 20:59:39 -0700719
720 if (mStartPropertySetThread->Start() != NO_ERROR) {
721 ALOGE("Run StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800722 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800723
Dan Stoza9e56aa02015-11-02 13:00:03 -0800724 ALOGV("Done initializing");
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700725}
726
Romain Guy11d63f42017-07-20 12:47:14 -0700727void SurfaceFlinger::readPersistentProperties() {
Chia-I Wu28f320b2018-05-03 11:02:56 -0700728 Mutex::Autolock _l(mStateLock);
729
Romain Guy11d63f42017-07-20 12:47:14 -0700730 char value[PROPERTY_VALUE_MAX];
731
732 property_get("persist.sys.sf.color_saturation", value, "1.0");
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800733 mGlobalSaturationFactor = atof(value);
Chia-I Wu28f320b2018-05-03 11:02:56 -0700734 updateColorMatrixLocked();
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800735 ALOGV("Saturation is set to %.2f", mGlobalSaturationFactor);
Romain Guy54f154a2017-10-24 21:40:32 +0100736
737 property_get("persist.sys.sf.native_mode", value, "0");
Chia-I Wu0d711262018-05-21 15:19:35 -0700738 mDisplayColorSetting = static_cast<DisplayColorSetting>(atoi(value));
Romain Guy11d63f42017-07-20 12:47:14 -0700739}
740
Mathias Agopiana67e4182012-06-19 17:26:12 -0700741void SurfaceFlinger::startBootAnim() {
Wei Wangb254fa32017-01-31 17:43:23 -0800742 // Start boot animation service by setting a property mailbox
743 // if property setting thread is already running, Start() will be just a NOP
Wei Wangf9b05ee2017-07-19 20:59:39 -0700744 mStartPropertySetThread->Start();
Wei Wangb254fa32017-01-31 17:43:23 -0800745 // Wait until property was set
Wei Wangf9b05ee2017-07-19 20:59:39 -0700746 if (mStartPropertySetThread->join() != NO_ERROR) {
747 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800748 }
Mathias Agopiana67e4182012-06-19 17:26:12 -0700749}
750
Mathias Agopian875d8e12013-06-07 15:35:48 -0700751size_t SurfaceFlinger::getMaxTextureSize() const {
David Sodmanbc815282017-11-05 18:57:52 -0800752 return getBE().mRenderEngine->getMaxTextureSize();
Mathias Agopiana4912602012-07-12 14:25:33 -0700753}
754
Mathias Agopian875d8e12013-06-07 15:35:48 -0700755size_t SurfaceFlinger::getMaxViewportDims() const {
David Sodmanbc815282017-11-05 18:57:52 -0800756 return getBE().mRenderEngine->getMaxViewportDims();
Mathias Agopiana4912602012-07-12 14:25:33 -0700757}
758
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800759// ----------------------------------------------------------------------------
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800760
Jamie Gennis582270d2011-08-17 18:19:00 -0700761bool SurfaceFlinger::authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800762 const sp<IGraphicBufferProducer>& bufferProducer) const {
Jamie Gennis134f0422011-03-08 12:18:54 -0800763 Mutex::Autolock _l(mStateLock);
Robert Carr0d480722017-01-10 16:42:54 -0800764 return authenticateSurfaceTextureLocked(bufferProducer);
765}
766
767bool SurfaceFlinger::authenticateSurfaceTextureLocked(
768 const sp<IGraphicBufferProducer>& bufferProducer) const {
Marco Nelissen097ca272014-11-14 08:01:01 -0800769 sp<IBinder> surfaceTextureBinder(IInterface::asBinder(bufferProducer));
Dan Stoza101d8dc2018-02-27 15:42:25 -0800770 return mGraphicBufferProducerList.count(surfaceTextureBinder.get()) > 0;
Jamie Gennis134f0422011-03-08 12:18:54 -0800771}
772
Brian Anderson6b376712017-04-04 10:51:39 -0700773status_t SurfaceFlinger::getSupportedFrameTimestamps(
774 std::vector<FrameEvent>* outSupported) const {
775 *outSupported = {
776 FrameEvent::REQUESTED_PRESENT,
777 FrameEvent::ACQUIRE,
778 FrameEvent::LATCH,
779 FrameEvent::FIRST_REFRESH_START,
780 FrameEvent::LAST_REFRESH_START,
781 FrameEvent::GPU_COMPOSITION_DONE,
782 FrameEvent::DEQUEUE_READY,
783 FrameEvent::RELEASE,
784 };
Steven Thomas6d8110b2017-08-31 18:24:21 -0700785 ConditionalLock _l(mStateLock,
786 std::this_thread::get_id() != mMainThreadId);
Brian Anderson6b376712017-04-04 10:51:39 -0700787 if (!getHwComposer().hasCapability(
788 HWC2::Capability::PresentFenceIsNotReliable)) {
789 outSupported->push_back(FrameEvent::DISPLAY_PRESENT);
790 }
791 return NO_ERROR;
792}
793
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700794status_t SurfaceFlinger::getDisplayConfigs(const sp<IBinder>& displayToken,
795 Vector<DisplayInfo>* configs) {
796 if (!displayToken || !configs) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700797 return BAD_VALUE;
798 }
799
Dominik Laskowski075d3172018-05-24 15:50:06 -0700800 const auto displayId = getPhysicalDisplayId(displayToken);
801 if (!displayId) {
802 return NAME_NOT_FOUND;
Mathias Agopianc666cae2012-07-25 18:56:13 -0700803 }
Mathias Agopian8b736f12012-08-13 17:54:26 -0700804
Mathias Agopian8b736f12012-08-13 17:54:26 -0700805 // TODO: Not sure if display density should handled by SF any longer
806 class Density {
Hernan Liatis57568932018-08-16 17:07:08 -0700807 static float getDensityFromProperty(char const* propName) {
Mathias Agopian8b736f12012-08-13 17:54:26 -0700808 char property[PROPERTY_VALUE_MAX];
Hernan Liatis57568932018-08-16 17:07:08 -0700809 float density = 0.0f;
Peiyong Lin566a3b42018-01-09 18:22:43 -0800810 if (property_get(propName, property, nullptr) > 0) {
Hernan Liatis57568932018-08-16 17:07:08 -0700811 density = strtof(property, nullptr);
Mathias Agopian8b736f12012-08-13 17:54:26 -0700812 }
813 return density;
814 }
815 public:
Hernan Liatis57568932018-08-16 17:07:08 -0700816 static float getEmuDensity() {
Mathias Agopian8b736f12012-08-13 17:54:26 -0700817 return getDensityFromProperty("qemu.sf.lcd_density"); }
Hernan Liatis57568932018-08-16 17:07:08 -0700818 static float getBuildDensity() {
Mathias Agopian8b736f12012-08-13 17:54:26 -0700819 return getDensityFromProperty("ro.sf.lcd_density"); }
820 };
Mathias Agopian1604f772012-09-18 21:54:42 -0700821
Dan Stoza7f7da322014-05-02 15:26:25 -0700822 configs->clear();
Mathias Agopian1604f772012-09-18 21:54:42 -0700823
Steven Thomas6d8110b2017-08-31 18:24:21 -0700824 ConditionalLock _l(mStateLock,
825 std::this_thread::get_id() != mMainThreadId);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700826 for (const auto& hwConfig : getHwComposer().getConfigs(*displayId)) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700827 DisplayInfo info = DisplayInfo();
828
Dan Stoza9e56aa02015-11-02 13:00:03 -0800829 float xdpi = hwConfig->getDpiX();
830 float ydpi = hwConfig->getDpiY();
Dan Stoza7f7da322014-05-02 15:26:25 -0700831
Yiwei Zhang27de5df2018-08-23 17:04:51 -0700832 info.w = hwConfig->getWidth();
833 info.h = hwConfig->getHeight();
834 // Default display viewport to display width and height
835 info.viewportW = info.w;
836 info.viewportH = info.h;
837
Dominik Laskowski075d3172018-05-24 15:50:06 -0700838 if (displayId == getInternalDisplayId()) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700839 // The density of the device is provided by a build property
840 float density = Density::getBuildDensity() / 160.0f;
841 if (density == 0) {
842 // the build doesn't provide a density -- this is wrong!
843 // use xdpi instead
844 ALOGE("ro.sf.lcd_density must be defined as a build property");
845 density = xdpi / 160.0f;
846 }
847 if (Density::getEmuDensity()) {
848 // if "qemu.sf.lcd_density" is specified, it overrides everything
849 xdpi = ydpi = density = Density::getEmuDensity();
850 density /= 160.0f;
851 }
852 info.density = density;
853
854 // TODO: this needs to go away (currently needed only by webkit)
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700855 const auto display = getDefaultDisplayDeviceLocked();
856 info.orientation = display ? display->getOrientation() : 0;
Yiwei Zhang27de5df2018-08-23 17:04:51 -0700857
858 // This is for screenrecord
859 const Rect viewport = display->getViewport();
860 if (viewport.isValid()) {
861 info.viewportW = uint32_t(viewport.getWidth());
862 info.viewportH = uint32_t(viewport.getHeight());
863 }
Dan Stoza7f7da322014-05-02 15:26:25 -0700864 } else {
865 // TODO: where should this value come from?
866 static const int TV_DENSITY = 213;
867 info.density = TV_DENSITY / 160.0f;
868 info.orientation = 0;
869 }
870
Dan Stoza7f7da322014-05-02 15:26:25 -0700871 info.xdpi = xdpi;
872 info.ydpi = ydpi;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800873 info.fps = 1e9 / hwConfig->getVsyncPeriod();
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900874 info.appVsyncOffset = vsyncPhaseOffsetNs;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800875
Andy McFadden91b2ca82014-06-13 14:04:23 -0700876 // This is how far in advance a buffer must be queued for
877 // presentation at a given time. If you want a buffer to appear
878 // on the screen at time N, you must submit the buffer before
879 // (N - presentationDeadline).
880 //
881 // Normally it's one full refresh period (to give SF a chance to
882 // latch the buffer), but this can be reduced by configuring a
883 // DispSync offset. Any additional delays introduced by the hardware
884 // composer or panel must be accounted for here.
885 //
886 // We add an additional 1ms to allow for processing time and
887 // differences between the ideal and actual refresh rate.
Dan Stoza9e56aa02015-11-02 13:00:03 -0800888 info.presentationDeadline = hwConfig->getVsyncPeriod() -
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800889 sfVsyncPhaseOffsetNs + 1000000;
Dan Stoza7f7da322014-05-02 15:26:25 -0700890
891 // All non-virtual displays are currently considered secure.
892 info.secure = true;
893
Dominik Laskowski075d3172018-05-24 15:50:06 -0700894 if (displayId == getInternalDisplayId() &&
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700895 primaryDisplayOrientation & DisplayState::eOrientationSwapMask) {
Iris Chang7501ed62018-04-30 14:45:42 +0800896 std::swap(info.w, info.h);
897 }
898
Michael Wright28f24d02016-07-12 13:30:53 -0700899 configs->push_back(info);
Mathias Agopian8b736f12012-08-13 17:54:26 -0700900 }
901
Dan Stoza7f7da322014-05-02 15:26:25 -0700902 return NO_ERROR;
903}
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700904
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700905status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>&, DisplayStatInfo* stats) {
906 if (!stats) {
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700907 return BAD_VALUE;
908 }
909
Ana Krulece588e312018-09-18 12:32:24 -0700910 if (mUseScheduler) {
911 mScheduler->getDisplayStatInfo(stats);
912 } else {
913 stats->vsyncTime = mPrimaryDispSync->computeNextRefresh(0);
914 stats->vsyncPeriod = mPrimaryDispSync->getPeriod();
915 }
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700916 return NO_ERROR;
917}
918
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700919int SurfaceFlinger::getActiveConfig(const sp<IBinder>& displayToken) {
920 const auto display = getDisplayDevice(displayToken);
921 if (!display) {
922 ALOGE("getActiveConfig: Invalid display token %p", displayToken.get());
Jinguang Dong9f8b9ae2016-11-29 13:55:57 +0800923 return BAD_VALUE;
924 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700925
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700926 return display->getActiveConfig();
Dan Stoza7f7da322014-05-02 15:26:25 -0700927}
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700928
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700929void SurfaceFlinger::setActiveConfigInternal(const sp<DisplayDevice>& display, int mode) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700930 if (display->isVirtual()) {
931 ALOGE("%s: Invalid operation on virtual display", __FUNCTION__);
932 return;
933 }
934
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700935 int currentMode = display->getActiveConfig();
Michael Lentine6c9e34a2014-07-14 13:48:55 -0700936 if (mode == currentMode) {
Michael Lentine6c9e34a2014-07-14 13:48:55 -0700937 return;
938 }
939
Dominik Laskowski075d3172018-05-24 15:50:06 -0700940 const auto displayId = display->getId();
941 LOG_ALWAYS_FATAL_IF(!displayId);
Michael Lentine6c9e34a2014-07-14 13:48:55 -0700942
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700943 display->setActiveConfig(mode);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700944 getHwComposer().setActiveConfig(*displayId, mode);
Michael Lentine6c9e34a2014-07-14 13:48:55 -0700945}
946
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700947status_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& displayToken, int mode) {
Dominik Laskowski8c001672018-05-30 16:52:06 -0700948 postMessageSync(new LambdaMessage([&] {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700949 Vector<DisplayInfo> configs;
950 getDisplayConfigs(displayToken, &configs);
951 if (mode < 0 || mode >= static_cast<int>(configs.size())) {
952 ALOGE("Attempt to set active config %d for display with %zu configs", mode,
953 configs.size());
954 return;
Michael Lentine6c9e34a2014-07-14 13:48:55 -0700955 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700956 const auto display = getDisplayDevice(displayToken);
957 if (!display) {
958 ALOGE("Attempt to set active config %d for invalid display token %p", mode,
959 displayToken.get());
960 } else if (display->isVirtual()) {
961 ALOGW("Attempt to set active config %d for virtual display", mode);
962 } else {
963 setActiveConfigInternal(display, mode);
964 }
965 }));
966
Mathias Agopian888c8222012-08-04 21:10:38 -0700967 return NO_ERROR;
Mathias Agopianc666cae2012-07-25 18:56:13 -0700968}
Dominik Laskowski075d3172018-05-24 15:50:06 -0700969
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700970status_t SurfaceFlinger::getDisplayColorModes(const sp<IBinder>& displayToken,
971 Vector<ColorMode>* outColorModes) {
972 if (!displayToken || !outColorModes) {
Michael Wright28f24d02016-07-12 13:30:53 -0700973 return BAD_VALUE;
974 }
975
Dominik Laskowski075d3172018-05-24 15:50:06 -0700976 const auto displayId = getPhysicalDisplayId(displayToken);
977 if (!displayId) {
978 return NAME_NOT_FOUND;
Michael Wright28f24d02016-07-12 13:30:53 -0700979 }
980
Peiyong Lina52f0292018-03-14 17:26:31 -0700981 std::vector<ColorMode> modes;
Steven Thomas6d8110b2017-08-31 18:24:21 -0700982 {
983 ConditionalLock _l(mStateLock,
984 std::this_thread::get_id() != mMainThreadId);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700985 modes = getHwComposer().getColorModes(*displayId);
Steven Thomas6d8110b2017-08-31 18:24:21 -0700986 }
Michael Wright28f24d02016-07-12 13:30:53 -0700987 outColorModes->clear();
988 std::copy(modes.cbegin(), modes.cend(), std::back_inserter(*outColorModes));
989
990 return NO_ERROR;
991}
992
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700993ColorMode SurfaceFlinger::getActiveColorMode(const sp<IBinder>& displayToken) {
994 if (const auto display = getDisplayDevice(displayToken)) {
995 return display->getActiveColorMode();
Michael Wright28f24d02016-07-12 13:30:53 -0700996 }
Peiyong Lina52f0292018-03-14 17:26:31 -0700997 return static_cast<ColorMode>(BAD_VALUE);
Michael Wright28f24d02016-07-12 13:30:53 -0700998}
999
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001000void SurfaceFlinger::setActiveColorModeInternal(const sp<DisplayDevice>& display, ColorMode mode,
1001 Dataspace dataSpace, RenderIntent renderIntent) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07001002 if (display->isVirtual()) {
1003 ALOGE("%s: Invalid operation on virtual display", __FUNCTION__);
1004 return;
1005 }
1006
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001007 ColorMode currentMode = display->getActiveColorMode();
1008 Dataspace currentDataSpace = display->getCompositionDataSpace();
1009 RenderIntent currentRenderIntent = display->getActiveRenderIntent();
Michael Wright28f24d02016-07-12 13:30:53 -07001010
Peiyong Lin38e9a562018-04-10 16:24:20 -07001011 if (mode == currentMode && dataSpace == currentDataSpace &&
1012 renderIntent == currentRenderIntent) {
1013 return;
1014 }
1015
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001016 display->setActiveColorMode(mode);
1017 display->setCompositionDataSpace(dataSpace);
1018 display->setActiveRenderIntent(renderIntent);
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08001019
Dominik Laskowski075d3172018-05-24 15:50:06 -07001020 const auto displayId = display->getId();
1021 LOG_ALWAYS_FATAL_IF(!displayId);
1022 getHwComposer().setActiveColorMode(*displayId, mode, renderIntent);
1023
Dominik Laskowski34157762018-10-31 13:07:19 -07001024 ALOGV("Set active color mode: %s (%d), active render intent: %s (%d), display=%s",
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001025 decodeColorMode(mode).c_str(), mode, decodeRenderIntent(renderIntent).c_str(),
Dominik Laskowski34157762018-10-31 13:07:19 -07001026 renderIntent, to_string(*displayId).c_str());
Michael Wright28f24d02016-07-12 13:30:53 -07001027}
1028
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001029status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& displayToken, ColorMode mode) {
Dominik Laskowski8c001672018-05-30 16:52:06 -07001030 postMessageSync(new LambdaMessage([&] {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001031 Vector<ColorMode> modes;
1032 getDisplayColorModes(displayToken, &modes);
1033 bool exists = std::find(std::begin(modes), std::end(modes), mode) != std::end(modes);
1034 if (mode < ColorMode::NATIVE || !exists) {
1035 ALOGE("Attempt to set invalid active color mode %s (%d) for display token %p",
1036 decodeColorMode(mode).c_str(), mode, displayToken.get());
1037 return;
Michael Wright28f24d02016-07-12 13:30:53 -07001038 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001039 const auto display = getDisplayDevice(displayToken);
1040 if (!display) {
1041 ALOGE("Attempt to set active color mode %s (%d) for invalid display token %p",
1042 decodeColorMode(mode).c_str(), mode, displayToken.get());
1043 } else if (display->isVirtual()) {
1044 ALOGW("Attempt to set active color mode %s (%d) for virtual display",
1045 decodeColorMode(mode).c_str(), mode);
1046 } else {
1047 setActiveColorModeInternal(display, mode, Dataspace::UNKNOWN,
1048 RenderIntent::COLORIMETRIC);
1049 }
1050 }));
1051
Michael Wright28f24d02016-07-12 13:30:53 -07001052 return NO_ERROR;
1053}
Mathias Agopianc666cae2012-07-25 18:56:13 -07001054
Svetoslavd85084b2014-03-20 10:28:31 -07001055status_t SurfaceFlinger::clearAnimationFrameStats() {
1056 Mutex::Autolock _l(mStateLock);
1057 mAnimFrameTracker.clearStats();
1058 return NO_ERROR;
1059}
1060
1061status_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const {
1062 Mutex::Autolock _l(mStateLock);
1063 mAnimFrameTracker.getStats(outStats);
1064 return NO_ERROR;
1065}
1066
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001067status_t SurfaceFlinger::getHdrCapabilities(const sp<IBinder>& displayToken,
1068 HdrCapabilities* outCapabilities) const {
Dan Stozac4f471e2016-03-24 09:31:08 -07001069 Mutex::Autolock _l(mStateLock);
1070
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001071 const auto display = getDisplayDeviceLocked(displayToken);
1072 if (!display) {
1073 ALOGE("getHdrCapabilities: Invalid display token %p", displayToken.get());
Dan Stozac4f471e2016-03-24 09:31:08 -07001074 return BAD_VALUE;
1075 }
1076
Peiyong Linfb069302018-04-25 14:34:31 -07001077 // At this point the DisplayDeivce should already be set up,
1078 // meaning the luminance information is already queried from
1079 // hardware composer and stored properly.
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001080 const HdrCapabilities& capabilities = display->getHdrCapabilities();
Peiyong Linfb069302018-04-25 14:34:31 -07001081 *outCapabilities = HdrCapabilities(capabilities.getSupportedHdrTypes(),
1082 capabilities.getDesiredMaxLuminance(),
1083 capabilities.getDesiredMaxAverageLuminance(),
1084 capabilities.getDesiredMinLuminance());
Dan Stozac4f471e2016-03-24 09:31:08 -07001085
1086 return NO_ERROR;
1087}
1088
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001089status_t SurfaceFlinger::getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
1090 ui::PixelFormat* outFormat,
1091 ui::Dataspace* outDataspace,
1092 uint8_t* outComponentMask) const {
1093 if (!outFormat || !outDataspace || !outComponentMask) {
1094 return BAD_VALUE;
1095 }
Kevin DuBois74e53772018-11-19 10:52:38 -08001096 const auto display = getDisplayDevice(displayToken);
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001097 if (!display || !display->getId()) {
1098 ALOGE("getDisplayedContentSamplingAttributes: Bad display token: %p", display.get());
1099 return BAD_VALUE;
1100 }
1101 return getHwComposer().getDisplayedContentSamplingAttributes(*display->getId(), outFormat,
1102 outDataspace, outComponentMask);
1103}
1104
Kevin DuBois74e53772018-11-19 10:52:38 -08001105status_t SurfaceFlinger::setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken,
1106 bool enable, uint8_t componentMask,
1107 uint64_t maxFrames) const {
1108 const auto display = getDisplayDevice(displayToken);
1109 if (!display || !display->getId()) {
1110 ALOGE("setDisplayContentSamplingEnabled: Bad display token: %p", display.get());
1111 return BAD_VALUE;
1112 }
1113
1114 return getHwComposer().setDisplayContentSamplingEnabled(*display->getId(), enable,
1115 componentMask, maxFrames);
1116}
1117
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001118status_t SurfaceFlinger::getDisplayedContentSample(const sp<IBinder>& displayToken,
1119 uint64_t maxFrames, uint64_t timestamp,
1120 DisplayedFrameStats* outStats) const {
1121 const auto display = getDisplayDevice(displayToken);
1122 if (!display || !display->getId()) {
1123 ALOGE("getDisplayContentSample: Bad display token: %p", displayToken.get());
1124 return BAD_VALUE;
1125 }
1126
1127 return getHwComposer().getDisplayedContentSample(*display->getId(), maxFrames, timestamp,
1128 outStats);
1129}
1130
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001131status_t SurfaceFlinger::enableVSyncInjections(bool enable) {
Dominik Laskowski8c001672018-05-30 16:52:06 -07001132 postMessageSync(new LambdaMessage([&] {
Chia-I Wu90f669f2017-10-05 14:24:41 -07001133 Mutex::Autolock _l(mStateLock);
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001134
Chia-I Wu90f669f2017-10-05 14:24:41 -07001135 if (mInjectVSyncs == enable) {
1136 return;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001137 }
Chia-I Wu90f669f2017-10-05 14:24:41 -07001138
Ana Krulec98b5b242018-08-10 15:03:23 -07001139 // TODO(akrulec): Part of the Injector should be refactored, so that it
1140 // can be passed to Scheduler.
Chia-I Wu90f669f2017-10-05 14:24:41 -07001141 if (enable) {
1142 ALOGV("VSync Injections enabled");
1143 if (mVSyncInjector.get() == nullptr) {
Lloyd Piquee83f9312018-02-01 12:53:17 -08001144 mVSyncInjector = std::make_unique<InjectVSyncSource>();
Lloyd Pique24b0a482018-03-09 18:52:26 -08001145 mInjectorEventThread = std::make_unique<
Dominik Laskowski8c001672018-05-30 16:52:06 -07001146 impl::EventThread>(mVSyncInjector.get(), [this] { resyncWithRateLimit(); },
Lloyd Pique24b0a482018-03-09 18:52:26 -08001147 impl::EventThread::InterceptVSyncsCallback(),
1148 "injEventThread");
Chia-I Wu90f669f2017-10-05 14:24:41 -07001149 }
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001150 mEventQueue->setEventThread(mInjectorEventThread.get());
Chia-I Wu90f669f2017-10-05 14:24:41 -07001151 } else {
1152 ALOGV("VSync Injections disabled");
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001153 mEventQueue->setEventThread(mSFEventThread.get());
Chia-I Wu90f669f2017-10-05 14:24:41 -07001154 }
1155
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001156 mInjectVSyncs = enable;
Dominik Laskowski8c001672018-05-30 16:52:06 -07001157 }));
1158
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001159 return NO_ERROR;
1160}
1161
1162status_t SurfaceFlinger::injectVSync(nsecs_t when) {
Chia-I Wu90f669f2017-10-05 14:24:41 -07001163 Mutex::Autolock _l(mStateLock);
1164
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001165 if (!mInjectVSyncs) {
1166 ALOGE("VSync Injections not enabled");
1167 return BAD_VALUE;
1168 }
1169 if (mInjectVSyncs && mInjectorEventThread.get() != nullptr) {
1170 ALOGV("Injecting VSync inside SurfaceFlinger");
1171 mVSyncInjector->onInjectSyncEvent(when);
1172 }
1173 return NO_ERROR;
1174}
1175
Lloyd Pique755e3192018-01-31 16:46:15 -08001176status_t SurfaceFlinger::getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const
1177 NO_THREAD_SAFETY_ANALYSIS {
Kalle Raitaa099a242017-01-11 11:17:29 -08001178 // Try to acquire a lock for 1s, fail gracefully
1179 const status_t err = mStateLock.timedLock(s2ns(1));
1180 const bool locked = (err == NO_ERROR);
1181 if (!locked) {
1182 ALOGE("LayerDebugInfo: SurfaceFlinger unresponsive (%s [%d]) - exit", strerror(-err), err);
1183 return TIMED_OUT;
1184 }
1185
1186 outLayers->clear();
1187 mCurrentState.traverseInZOrder([&](Layer* layer) {
1188 outLayers->push_back(layer->getLayerDebugInfo());
1189 });
1190
1191 mStateLock.unlock();
1192 return NO_ERROR;
1193}
1194
Peiyong Linc6780972018-10-28 15:24:08 -07001195status_t SurfaceFlinger::getCompositionPreference(
1196 Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
1197 Dataspace* outWideColorGamutDataspace,
1198 ui::PixelFormat* outWideColorGamutPixelFormat) const {
Peiyong Lin9d846a52018-11-05 13:18:20 -08001199 *outDataspace = mDefaultCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001200 *outPixelFormat = defaultCompositionPixelFormat;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001201 *outWideColorGamutDataspace = mWideColorGamutCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001202 *outWideColorGamutPixelFormat = wideColorGamutCompositionPixelFormat;
Peiyong Lin0256f722018-08-31 15:45:10 -07001203 return NO_ERROR;
1204}
1205
Mathias Agopiand0566bc2011-11-17 17:49:17 -08001206// ----------------------------------------------------------------------------
1207
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -07001208sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection(
1209 ISurfaceComposer::VsyncSource vsyncSource) {
Ana Krulec98b5b242018-08-10 15:03:23 -07001210 if (mUseScheduler) {
1211 if (vsyncSource == eVsyncSourceSurfaceFlinger) {
1212 return mScheduler->createDisplayEventConnection(mSfConnectionHandle);
1213 } else {
1214 return mScheduler->createDisplayEventConnection(mAppConnectionHandle);
1215 }
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -07001216 } else {
Ana Krulec98b5b242018-08-10 15:03:23 -07001217 if (vsyncSource == eVsyncSourceSurfaceFlinger) {
1218 return mSFEventThread->createEventConnection();
1219 } else {
1220 return mEventThread->createEventConnection();
1221 }
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -07001222 }
Mathias Agopianbb641242010-05-18 17:06:55 -07001223}
1224
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001225// ----------------------------------------------------------------------------
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001226
1227void SurfaceFlinger::waitForEvent() {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001228 mEventQueue->waitMessage();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001229}
1230
1231void SurfaceFlinger::signalTransaction() {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001232 mEventQueue->invalidate();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001233}
1234
1235void SurfaceFlinger::signalLayerUpdate() {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001236 mEventQueue->invalidate();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001237}
1238
1239void SurfaceFlinger::signalRefresh() {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07001240 mRefreshPending = true;
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001241 mEventQueue->refresh();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001242}
1243
1244status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,
Dan Stozac7014012014-02-14 15:03:43 -08001245 nsecs_t reltime, uint32_t /* flags */) {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001246 return mEventQueue->postMessage(msg, reltime);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001247}
1248
1249status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
Dan Stozac7014012014-02-14 15:03:43 -08001250 nsecs_t reltime, uint32_t /* flags */) {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001251 status_t res = mEventQueue->postMessage(msg, reltime);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001252 if (res == NO_ERROR) {
1253 msg->wait();
1254 }
1255 return res;
1256}
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001257
Mathias Agopian4f4f0942013-08-19 17:26:18 -07001258void SurfaceFlinger::run() {
Mathias Agopian4f4f0942013-08-19 17:26:18 -07001259 do {
1260 waitForEvent();
1261 } while (true);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001262}
1263
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001264void SurfaceFlinger::enableHardwareVsync() {
1265 Mutex::Autolock _l(mHWVsyncLock);
Jesse Hall948fe0c2013-10-14 12:56:09 -07001266 if (!mPrimaryHWVsyncEnabled && mHWVsyncAvailable) {
Lloyd Pique41be5d22018-06-21 13:11:48 -07001267 mPrimaryDispSync->beginResync();
Jamie Gennisd1700752013-10-14 12:22:52 -07001268 mEventControlThread->setVsyncEnabled(true);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001269 mPrimaryHWVsyncEnabled = true;
Andy McFadden43601a22012-09-11 15:15:13 -07001270 }
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001271}
1272
Jesse Hall948fe0c2013-10-14 12:56:09 -07001273void SurfaceFlinger::resyncToHardwareVsync(bool makeAvailable) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001274 Mutex::Autolock _l(mHWVsyncLock);
1275
Jesse Hall948fe0c2013-10-14 12:56:09 -07001276 if (makeAvailable) {
1277 mHWVsyncAvailable = true;
Ana Krulec7ab56032018-11-02 20:51:06 +01001278 // TODO(b/113612090): This is silly, but necessary evil until we turn on the flag for good.
1279 if (mUseScheduler) {
1280 mScheduler->makeHWSyncAvailable(true);
1281 }
Jesse Hall948fe0c2013-10-14 12:56:09 -07001282 } else if (!mHWVsyncAvailable) {
Dan Stoza0a3c4d62016-04-19 11:56:20 -07001283 // Hardware vsync is not currently available, so abort the resync
1284 // attempt for now
Jesse Hall948fe0c2013-10-14 12:56:09 -07001285 return;
1286 }
1287
Dominik Laskowski075d3172018-05-24 15:50:06 -07001288 const auto displayId = getInternalDisplayId();
1289 if (!displayId || !getHwComposer().isConnected(*displayId)) {
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07001290 return;
1291 }
1292
Dominik Laskowski075d3172018-05-24 15:50:06 -07001293 const auto activeConfig = getHwComposer().getActiveConfig(*displayId);
Dan Stoza9e56aa02015-11-02 13:00:03 -08001294 const nsecs_t period = activeConfig->getVsyncPeriod();
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001295
Ana Krulece588e312018-09-18 12:32:24 -07001296 if (mUseScheduler) {
1297 mScheduler->setVsyncPeriod(period);
1298 } else {
1299 mPrimaryDispSync->reset();
1300 mPrimaryDispSync->setPeriod(period);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001301
Ana Krulece588e312018-09-18 12:32:24 -07001302 if (!mPrimaryHWVsyncEnabled) {
1303 mPrimaryDispSync->beginResync();
1304 mEventControlThread->setVsyncEnabled(true);
1305 mPrimaryHWVsyncEnabled = true;
1306 }
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001307 }
1308}
1309
Jesse Hall948fe0c2013-10-14 12:56:09 -07001310void SurfaceFlinger::disableHardwareVsync(bool makeUnavailable) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001311 Mutex::Autolock _l(mHWVsyncLock);
1312 if (mPrimaryHWVsyncEnabled) {
Jamie Gennisd1700752013-10-14 12:22:52 -07001313 mEventControlThread->setVsyncEnabled(false);
Lloyd Pique41be5d22018-06-21 13:11:48 -07001314 mPrimaryDispSync->endResync();
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001315 mPrimaryHWVsyncEnabled = false;
1316 }
Jesse Hall948fe0c2013-10-14 12:56:09 -07001317 if (makeUnavailable) {
1318 mHWVsyncAvailable = false;
1319 }
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001320}
1321
Tim Murray4a4e4a22016-04-19 16:29:23 +00001322void SurfaceFlinger::resyncWithRateLimit() {
1323 static constexpr nsecs_t kIgnoreDelay = ms2ns(500);
Dan Stoza57164302017-05-08 14:03:54 -07001324
1325 // No explicit locking is needed here since EventThread holds a lock while calling this method
1326 static nsecs_t sLastResyncAttempted = 0;
1327 const nsecs_t now = systemTime();
1328 if (now - sLastResyncAttempted > kIgnoreDelay) {
Dan Stoza0a3c4d62016-04-19 11:56:20 -07001329 resyncToHardwareVsync(false);
Tim Murray4a4e4a22016-04-19 16:29:23 +00001330 }
Dan Stoza57164302017-05-08 14:03:54 -07001331 sLastResyncAttempted = now;
Tim Murray4a4e4a22016-04-19 16:29:23 +00001332}
1333
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001334void SurfaceFlinger::onVsyncReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId,
1335 int64_t timestamp) {
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001336 ATRACE_NAME("SF onVsync");
1337
Steven Thomas3cfac282017-02-06 12:29:30 -08001338 Mutex::Autolock lock(mStateLock);
Steven Thomasb02664d2017-07-26 18:48:28 -07001339 // Ignore any vsyncs from a previous hardware composer.
David Sodman105b7dc2017-11-04 20:28:14 -07001340 if (sequenceId != getBE().mComposerSequenceId) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001341 return;
1342 }
1343
Dominik Laskowski075d3172018-05-24 15:50:06 -07001344 if (!getHwComposer().onVsync(hwcDisplayId, timestamp)) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001345 return;
1346 }
1347
Dominik Laskowski075d3172018-05-24 15:50:06 -07001348 if (hwcDisplayId != getHwComposer().getInternalHwcDisplayId()) {
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001349 // For now, we don't do anything with external display vsyncs.
1350 return;
1351 }
1352
Ana Krulece588e312018-09-18 12:32:24 -07001353 if (mUseScheduler) {
1354 mScheduler->addResyncSample(timestamp);
Jamie Gennisd1700752013-10-14 12:22:52 -07001355 } else {
Ana Krulece588e312018-09-18 12:32:24 -07001356 bool needsHwVsync = false;
1357 { // Scope for the lock
1358 Mutex::Autolock _l(mHWVsyncLock);
1359 if (mPrimaryHWVsyncEnabled) {
1360 needsHwVsync = mPrimaryDispSync->addResyncSample(timestamp);
1361 }
1362 }
1363
1364 if (needsHwVsync) {
1365 enableHardwareVsync();
1366 } else {
1367 disableHardwareVsync(false);
1368 }
Jamie Gennisd1700752013-10-14 12:22:52 -07001369 }
Mathias Agopian148994e2012-09-19 17:31:36 -07001370}
1371
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001372void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
David Sodman99974d22017-11-28 12:04:33 -08001373 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
1374 *compositorTiming = getBE().mCompositorTiming;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001375}
1376
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001377void SurfaceFlinger::onHotplugReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId,
Lloyd Pique715a2c12017-12-14 17:18:08 -08001378 HWC2::Connection connection) {
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001379 ALOGV("%s(%d, %" PRIu64 ", %s)", __FUNCTION__, sequenceId, hwcDisplayId,
Lloyd Pique715a2c12017-12-14 17:18:08 -08001380 connection == HWC2::Connection::Connected ? "connected" : "disconnected");
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001381
Lloyd Piqueba04e622017-12-14 17:11:26 -08001382 // Ignore events that do not have the right sequenceId.
1383 if (sequenceId != getBE().mComposerSequenceId) {
1384 return;
1385 }
1386
Steven Thomasb02664d2017-07-26 18:48:28 -07001387 // Only lock if we're not on the main thread. This function is normally
1388 // called on a hwbinder thread, but for the primary display it's called on
1389 // the main thread with the state lock already held, so don't attempt to
1390 // acquire it here.
Lloyd Piqueba04e622017-12-14 17:11:26 -08001391 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
Steven Thomasb02664d2017-07-26 18:48:28 -07001392
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001393 mPendingHotplugEvents.emplace_back(HotplugEvent{hwcDisplayId, connection});
Mathias Agopian9e2463e2012-09-21 18:26:16 -07001394
Jiwen 'Steve' Caiccfd6822018-02-21 16:15:58 -08001395 if (std::this_thread::get_id() == mMainThreadId) {
1396 // Process all pending hot plug events immediately if we are on the main thread.
1397 processDisplayHotplugEventsLocked();
1398 }
1399
Lloyd Piqueba04e622017-12-14 17:11:26 -08001400 setTransactionFlags(eDisplayTransactionNeeded);
Mathias Agopian86303202012-07-24 22:46:10 -07001401}
1402
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001403void SurfaceFlinger::onRefreshReceived(int sequenceId, hwc2_display_t /*hwcDisplayId*/) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001404 Mutex::Autolock lock(mStateLock);
David Sodman105b7dc2017-11-04 20:28:14 -07001405 if (sequenceId != getBE().mComposerSequenceId) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001406 return;
Steven Thomas3cfac282017-02-06 12:29:30 -08001407 }
Dan Stozac7a25ad2018-04-12 11:45:09 -07001408 repaintEverything();
Steven Thomas3cfac282017-02-06 12:29:30 -08001409}
1410
Dominik Laskowski075d3172018-05-24 15:50:06 -07001411void SurfaceFlinger::setVsyncEnabled(EventThread::DisplayType /*displayType*/, bool enabled) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001412 ATRACE_CALL();
Steven Thomasb02664d2017-07-26 18:48:28 -07001413 Mutex::Autolock lock(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -07001414 if (const auto displayId = getInternalDisplayId()) {
1415 getHwComposer().setVsyncEnabled(*displayId,
1416 enabled ? HWC2::Vsync::Enable : HWC2::Vsync::Disable);
1417 }
Mathias Agopian86303202012-07-24 22:46:10 -07001418}
1419
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001420// Note: it is assumed the caller holds |mStateLock| when this is called
Steven Thomasb02664d2017-07-26 18:48:28 -07001421void SurfaceFlinger::resetDisplayState() {
Ana Krulece588e312018-09-18 12:32:24 -07001422 if (mUseScheduler) {
1423 mScheduler->disableHardwareVsync(true);
1424 } else {
1425 disableHardwareVsync(true);
1426 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001427 // Clear the drawing state so that the logic inside of
1428 // handleTransactionLocked will fire. It will determine the delta between
1429 // mCurrentState and mDrawingState and re-apply all changes when we make the
1430 // transition.
1431 mDrawingState.displays.clear();
1432 mDisplays.clear();
1433}
1434
Steven Thomas050b2c82017-03-06 11:45:16 -08001435void SurfaceFlinger::updateVrFlinger() {
1436 if (!mVrFlinger)
1437 return;
1438 bool vrFlingerRequestsDisplay = mVrFlingerRequestsDisplay;
David Sodman105b7dc2017-11-04 20:28:14 -07001439 if (vrFlingerRequestsDisplay == getBE().mHwc->isUsingVrComposer()) {
Mark Urbanus209beca2017-02-23 11:16:04 -08001440 return;
1441 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001442
David Sodman105b7dc2017-11-04 20:28:14 -07001443 if (vrFlingerRequestsDisplay && !getBE().mHwc->getComposer()->isRemote()) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001444 ALOGE("Vr flinger is only supported for remote hardware composer"
1445 " service connections. Ignoring request to transition to vr"
1446 " flinger.");
1447 mVrFlingerRequestsDisplay = false;
1448 return;
Mark Urbanus209beca2017-02-23 11:16:04 -08001449 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001450
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001451 Mutex::Autolock _l(mStateLock);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001452
Steven Thomas0123ac62018-07-12 11:32:34 -07001453 sp<DisplayDevice> display = getDefaultDisplayDeviceLocked();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07001454 LOG_ALWAYS_FATAL_IF(!display);
1455 const int currentDisplayPowerMode = display->getPowerMode();
Steven Thomas0123ac62018-07-12 11:32:34 -07001456 // This DisplayDevice will no longer be relevant once resetDisplayState() is
1457 // called below. Clear the reference now so we don't accidentally use it
1458 // later.
1459 display.clear();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001460
Steven Thomasb02664d2017-07-26 18:48:28 -07001461 if (!vrFlingerRequestsDisplay) {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001462 mVrFlinger->SeizeDisplayOwnership();
Steven Thomasb02664d2017-07-26 18:48:28 -07001463 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001464
Steven Thomasb02664d2017-07-26 18:48:28 -07001465 resetDisplayState();
David Sodman105b7dc2017-11-04 20:28:14 -07001466 getBE().mHwc.reset(); // Delete the current instance before creating the new one
Lloyd Pique90c115d2018-09-18 21:39:42 -07001467 getBE().mHwc = getFactory().createHWComposer(
1468 vrFlingerRequestsDisplay ? "vr" : getBE().mHwcServiceName);
David Sodman105b7dc2017-11-04 20:28:14 -07001469 getBE().mHwc->registerCallback(this, ++getBE().mComposerSequenceId);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001470
David Sodman105b7dc2017-11-04 20:28:14 -07001471 LOG_ALWAYS_FATAL_IF(!getBE().mHwc->getComposer()->isRemote(),
1472 "Switched to non-remote hardware composer");
Steven Thomasb02664d2017-07-26 18:48:28 -07001473
1474 if (vrFlingerRequestsDisplay) {
1475 mVrFlinger->GrantDisplayOwnership();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001476 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001477
1478 mVisibleRegionsDirty = true;
1479 invalidateHwcGeometry();
1480
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001481 // Re-enable default display.
Steven Thomas0123ac62018-07-12 11:32:34 -07001482 display = getDefaultDisplayDeviceLocked();
1483 LOG_ALWAYS_FATAL_IF(!display);
Dominik Laskowskie9774092018-12-11 10:04:24 -08001484 setPowerModeInternal(display, currentDisplayPowerMode);
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001485
Steven Thomasb02664d2017-07-26 18:48:28 -07001486 // Reset the timing values to account for the period of the swapped in HWC
Dominik Laskowski075d3172018-05-24 15:50:06 -07001487 const auto activeConfig = getHwComposer().getActiveConfig(*display->getId());
Steven Thomasb02664d2017-07-26 18:48:28 -07001488 const nsecs_t period = activeConfig->getVsyncPeriod();
1489 mAnimFrameTracker.setDisplayRefreshPeriod(period);
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001490
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001491 // The present fences returned from vr_hwc are not an accurate
1492 // representation of vsync times.
Ana Krulece588e312018-09-18 12:32:24 -07001493 if (mUseScheduler) {
1494 mScheduler->setIgnorePresentFences(getBE().mHwc->isUsingVrComposer() || !hasSyncFramework);
1495 } else {
1496 mPrimaryDispSync->setIgnorePresentFences(getBE().mHwc->isUsingVrComposer() ||
1497 !hasSyncFramework);
1498 }
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001499
Steven Thomasb02664d2017-07-26 18:48:28 -07001500 // Use phase of 0 since phase is not known.
1501 // Use latency of 0, which will snap to the ideal latency.
Ana Krulece588e312018-09-18 12:32:24 -07001502 DisplayStatInfo stats{0 /* vsyncTime */, period /* vsyncPeriod */};
1503 setCompositorTimingSnapped(stats, 0);
Stephen Kiazyk82386cd2017-04-14 13:43:29 -07001504
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001505 resyncToHardwareVsync(false);
1506
Lloyd Piquef1c675b2018-09-12 20:45:39 -07001507 mRepaintEverything = true;
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001508 setTransactionFlags(eDisplayTransactionNeeded);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001509}
1510
Mathias Agopian4fec8732012-06-29 14:12:52 -07001511void SurfaceFlinger::onMessageReceived(int32_t what) {
Jamie Gennis1c8e95c2012-02-23 19:27:23 -08001512 ATRACE_CALL();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001513 switch (what) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08001514 case MessageQueue::INVALIDATE: {
Ana Krulec3084c052018-11-21 20:27:17 +01001515 if (mUseScheduler) {
1516 // This call is made each time SF wakes up and creates a new frame.
1517 mScheduler->incrementFrameCounter();
1518 }
Dan Stoza50182882016-07-08 12:02:20 -07001519 bool frameMissed = !mHadClientComposition &&
1520 mPreviousPresentFence != Fence::NO_FENCE &&
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001521 (mPreviousPresentFence->getSignalTime() ==
1522 Fence::SIGNAL_TIME_PENDING);
Marissa Wallcfcdaa52018-05-21 15:45:59 -07001523 mFrameMissedCount += frameMissed;
Dan Stoza50182882016-07-08 12:02:20 -07001524 ATRACE_INT("FrameMissed", static_cast<int>(frameMissed));
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07001525 if (frameMissed) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08001526 mTimeStats->incrementMissedFrames();
Yiwei Zhang621f9d42018-05-07 10:40:55 -07001527 if (mPropagateBackpressure) {
1528 signalLayerUpdate();
1529 break;
1530 }
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07001531 }
Dan Stoza50182882016-07-08 12:02:20 -07001532
Steven Thomas050b2c82017-03-06 11:45:16 -08001533 // Now that we're going to make it to the handleMessageTransaction()
1534 // call below it's safe to call updateVrFlinger(), which will
1535 // potentially trigger a display handoff.
1536 updateVrFlinger();
1537
Dan Stoza6b9454d2014-11-07 16:00:59 -08001538 bool refreshNeeded = handleMessageTransaction();
1539 refreshNeeded |= handleMessageInvalidate();
Dan Stoza58784442014-12-02 16:58:17 -08001540 refreshNeeded |= mRepaintEverything;
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08001541 if (refreshNeeded && CC_LIKELY(mBootStage != BootStage::BOOTLOADER)) {
Dan Stoza58784442014-12-02 16:58:17 -08001542 // Signal a refresh if a transaction modified the window state,
1543 // a new buffer was latched, or if HWC has requested a full
1544 // repaint
Dan Stoza6b9454d2014-11-07 16:00:59 -08001545 signalRefresh();
1546 }
1547 break;
1548 }
1549 case MessageQueue::REFRESH: {
1550 handleMessageRefresh();
1551 break;
1552 }
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001553 }
1554}
1555
Dan Stoza6b9454d2014-11-07 16:00:59 -08001556bool SurfaceFlinger::handleMessageTransaction() {
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08001557 uint32_t transactionFlags = peekTransactionFlags();
Marissa Wall713b63f2018-10-17 15:42:43 -07001558
1559 // Apply any ready transactions in the queues if there are still transactions that have not been
1560 // applied, wake up during the next vsync period and check again
1561 bool transactionNeeded = false;
1562 if (!flushTransactionQueues()) {
1563 transactionNeeded = true;
1564 }
1565
Mathias Agopian4fec8732012-06-29 14:12:52 -07001566 if (transactionFlags) {
Mathias Agopian87baae12012-07-31 12:38:26 -07001567 handleTransaction(transactionFlags);
Mathias Agopian4fec8732012-06-29 14:12:52 -07001568 }
Marissa Wall713b63f2018-10-17 15:42:43 -07001569
1570 if (transactionNeeded) {
1571 setTransactionFlags(eTransactionNeeded);
1572 }
1573
1574 return transactionFlags;
Mathias Agopian4fec8732012-06-29 14:12:52 -07001575}
1576
Mathias Agopian4fec8732012-06-29 14:12:52 -07001577void SurfaceFlinger::handleMessageRefresh() {
Mathias Agopiancd60f992012-08-16 16:28:27 -07001578 ATRACE_CALL();
Dan Stoza14cd37c2015-07-09 12:43:33 -07001579
Dan Stoza2b6d38e2017-06-01 16:40:30 -07001580 mRefreshPending = false;
1581
Lloyd Piquef1c675b2018-09-12 20:45:39 -07001582 const bool repaintEverything = mRepaintEverything.exchange(false);
David Sodman2b406362017-12-15 13:33:47 -08001583 preComposition();
Lloyd Pique074e8122018-07-26 12:57:23 -07001584 rebuildLayerStacks();
David Sodman79bba0e2018-08-05 18:07:49 -07001585 calculateWorkingSet();
David Sodmanfa9b2af2017-12-24 13:28:59 -08001586 for (const auto& [token, display] : mDisplays) {
1587 beginFrame(display);
1588 prepareFrame(display);
1589 doDebugFlashRegions(display, repaintEverything);
1590 doComposition(display, repaintEverything);
1591 }
1592
Adrian Roos1e1a1282017-11-01 19:05:31 +01001593 doTracing("handleRefresh");
Yiwei Zhang7124ad32018-02-21 13:02:45 -08001594 logLayerStats();
David Sodmanfa9b2af2017-12-24 13:28:59 -08001595
1596 postFrame();
David Sodman2b406362017-12-15 13:33:47 -08001597 postComposition();
Dan Stoza05dacfb2016-07-01 13:33:38 -07001598
Dan Stozabfbffeb2016-07-21 14:49:33 -07001599 mHadClientComposition = false;
Dominik Laskowski9fae1022018-05-29 13:17:40 -07001600 for (const auto& [token, display] : mDisplays) {
Dan Stozabfbffeb2016-07-21 14:49:33 -07001601 mHadClientComposition = mHadClientComposition ||
Dominik Laskowski7e045462018-05-30 13:02:02 -07001602 getBE().mHwc->hasClientComposition(display->getId());
Dan Stozabfbffeb2016-07-21 14:49:33 -07001603 }
David Sodmanfa9b2af2017-12-24 13:28:59 -08001604
Alec Mouri86770e52018-09-24 22:40:58 +00001605 // Setup RenderEngine sync fences if native sync is supported.
1606 if (getBE().mRenderEngine->useNativeFenceSync()) {
1607 if (mHadClientComposition) {
1608 base::unique_fd flushFence(getRenderEngine().flush());
1609 ALOGE_IF(flushFence < 0, "Failed to flush RenderEngine!");
1610 getBE().flushFence = new Fence(std::move(flushFence));
1611 } else {
1612 // Cleanup for hygiene.
1613 getBE().flushFence = Fence::NO_FENCE;
1614 }
1615 }
1616
Jorim Jaggi90535212018-05-23 23:44:06 +02001617 mVsyncModulator.onRefreshed(mHadClientComposition);
Dan Stoza14cd37c2015-07-09 12:43:33 -07001618
David Sodman7e4ae112018-02-09 15:02:28 -08001619 getBE().mEndOfFrameCompositionInfo = std::move(getBE().mCompositionInfo);
David Sodman15fb96e2018-01-07 10:23:24 -08001620 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski05275f12018-11-01 15:03:24 -07001621 for (auto& compositionInfo : getBE().mEndOfFrameCompositionInfo[token]) {
David Sodman15fb96e2018-01-07 10:23:24 -08001622 compositionInfo.hwc.hwcLayer = nullptr;
1623 }
David Sodmanba340492018-08-05 21:51:33 -07001624 }
David Sodman7e4ae112018-02-09 15:02:28 -08001625
1626 mLayersWithQueuedFrames.clear();
Mathias Agopiancd60f992012-08-16 16:28:27 -07001627}
Mathias Agopian4fec8732012-06-29 14:12:52 -07001628
David Sodmanfa9b2af2017-12-24 13:28:59 -08001629
1630bool SurfaceFlinger::handleMessageInvalidate() {
1631 ATRACE_CALL();
1632 return handlePageFlip();
Mathias Agopian4fec8732012-06-29 14:12:52 -07001633}
1634
David Sodman79bba0e2018-08-05 18:07:49 -07001635void SurfaceFlinger::calculateWorkingSet() {
1636 ATRACE_CALL();
1637 ALOGV(__FUNCTION__);
1638
David Sodman79bba0e2018-08-05 18:07:49 -07001639 // build the h/w work list
1640 if (CC_UNLIKELY(mGeometryInvalid)) {
1641 mGeometryInvalid = false;
1642 for (const auto& [token, display] : mDisplays) {
1643 const auto displayId = display->getId();
Dominik Laskowski075d3172018-05-24 15:50:06 -07001644 if (!displayId) {
1645 continue;
1646 }
David Sodman79bba0e2018-08-05 18:07:49 -07001647
Dominik Laskowski075d3172018-05-24 15:50:06 -07001648 const Vector<sp<Layer>>& currentLayers = display->getVisibleLayersSortedByZ();
1649 for (size_t i = 0; i < currentLayers.size(); i++) {
1650 const auto& layer = currentLayers[i];
David Sodman79bba0e2018-08-05 18:07:49 -07001651
Dominik Laskowski075d3172018-05-24 15:50:06 -07001652 if (!layer->hasHwcLayer(*displayId)) {
1653 if (!layer->createHwcLayer(&getHwComposer(), *displayId)) {
1654 layer->forceClientComposition(*displayId);
1655 continue;
David Sodman79bba0e2018-08-05 18:07:49 -07001656 }
1657 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07001658
1659 layer->setGeometry(display, i);
1660 if (mDebugDisableHWC || mDebugRegion) {
1661 layer->forceClientComposition(*displayId);
1662 }
David Sodman79bba0e2018-08-05 18:07:49 -07001663 }
1664 }
1665 }
1666
1667 // Set the per-frame data
1668 for (const auto& [token, display] : mDisplays) {
1669 const auto displayId = display->getId();
Dominik Laskowski075d3172018-05-24 15:50:06 -07001670 if (!displayId) {
David Sodman79bba0e2018-08-05 18:07:49 -07001671 continue;
1672 }
1673
1674 if (mDrawingState.colorMatrixChanged) {
1675 display->setColorTransform(mDrawingState.colorMatrix);
Dominik Laskowski075d3172018-05-24 15:50:06 -07001676 status_t result =
1677 getHwComposer().setColorTransform(*displayId, mDrawingState.colorMatrix);
Dominik Laskowski34157762018-10-31 13:07:19 -07001678 ALOGE_IF(result != NO_ERROR, "Failed to set color transform on display %s: %d",
1679 to_string(*displayId).c_str(), result);
David Sodman79bba0e2018-08-05 18:07:49 -07001680 }
1681 for (auto& layer : display->getVisibleLayersSortedByZ()) {
1682 if (layer->isHdrY410()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07001683 layer->forceClientComposition(*displayId);
David Sodman79bba0e2018-08-05 18:07:49 -07001684 } else if ((layer->getDataSpace() == Dataspace::BT2020_PQ ||
1685 layer->getDataSpace() == Dataspace::BT2020_ITU_PQ) &&
1686 !display->hasHDR10Support()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07001687 layer->forceClientComposition(*displayId);
David Sodman79bba0e2018-08-05 18:07:49 -07001688 } else if ((layer->getDataSpace() == Dataspace::BT2020_HLG ||
1689 layer->getDataSpace() == Dataspace::BT2020_ITU_HLG) &&
1690 !display->hasHLGSupport()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07001691 layer->forceClientComposition(*displayId);
David Sodman79bba0e2018-08-05 18:07:49 -07001692 }
1693
Peiyong Lind3788632018-09-18 16:01:31 -07001694 // TODO(b/111562338) remove when composer 2.3 is shipped.
1695 if (layer->hasColorTransform()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07001696 layer->forceClientComposition(*displayId);
Peiyong Lind3788632018-09-18 16:01:31 -07001697 }
1698
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001699 if (layer->getRoundedCornerState().radius > 0.0f) {
1700 layer->forceClientComposition(*displayId);
1701 }
1702
Dominik Laskowski075d3172018-05-24 15:50:06 -07001703 if (layer->getForceClientComposition(*displayId)) {
David Sodman79bba0e2018-08-05 18:07:49 -07001704 ALOGV("[%s] Requesting Client composition", layer->getName().string());
Dominik Laskowski075d3172018-05-24 15:50:06 -07001705 layer->setCompositionType(*displayId, HWC2::Composition::Client);
David Sodman79bba0e2018-08-05 18:07:49 -07001706 continue;
1707 }
1708
Dominik Laskowski075d3172018-05-24 15:50:06 -07001709 layer->setPerFrameData(*displayId, display->getTransform(), display->getViewport(),
1710 display->getSupportedPerFrameMetadata());
David Sodman79bba0e2018-08-05 18:07:49 -07001711 }
1712
Peiyong Lin13effd12018-07-24 17:01:47 -07001713 if (useColorManagement) {
David Sodman79bba0e2018-08-05 18:07:49 -07001714 ColorMode colorMode;
1715 Dataspace dataSpace;
1716 RenderIntent renderIntent;
1717 pickColorMode(display, &colorMode, &dataSpace, &renderIntent);
1718 setActiveColorModeInternal(display, colorMode, dataSpace, renderIntent);
1719 }
1720 }
1721
1722 mDrawingState.colorMatrixChanged = false;
David Sodmanba340492018-08-05 21:51:33 -07001723
1724 for (const auto& [token, display] : mDisplays) {
1725 for (auto& layer : display->getVisibleLayersSortedByZ()) {
Dominik Laskowski05275f12018-11-01 15:03:24 -07001726 const auto displayId = display->getId();
David Sodmanba340492018-08-05 21:51:33 -07001727 layer->getBE().compositionInfo.compositionType = layer->getCompositionType(displayId);
Dominik Laskowski075d3172018-05-24 15:50:06 -07001728
1729 if (displayId) {
1730 if (!layer->setHwcLayer(*displayId)) {
1731 ALOGV("Need to create HWCLayer for %s", layer->getName().string());
1732 }
1733 layer->getBE().compositionInfo.hwc.displayId = *displayId;
David Sodmanba340492018-08-05 21:51:33 -07001734 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07001735
Dominik Laskowski05275f12018-11-01 15:03:24 -07001736 getBE().mCompositionInfo[token].push_back(layer->getBE().compositionInfo);
David Sodmanba340492018-08-05 21:51:33 -07001737 layer->getBE().compositionInfo.hwc.hwcLayer = nullptr;
1738 }
1739 }
David Sodman79bba0e2018-08-05 18:07:49 -07001740}
1741
David Sodmanfa9b2af2017-12-24 13:28:59 -08001742void SurfaceFlinger::doDebugFlashRegions(const sp<DisplayDevice>& display, bool repaintEverything)
Mathias Agopiancd60f992012-08-16 16:28:27 -07001743{
1744 // is debugging enabled
1745 if (CC_LIKELY(!mDebugRegion))
1746 return;
1747
David Sodmanfa9b2af2017-12-24 13:28:59 -08001748 if (display->isPoweredOn()) {
1749 // transform the dirty region into this screen's coordinate space
1750 const Region dirtyRegion(display->getDirtyRegion(repaintEverything));
1751 if (!dirtyRegion.isEmpty()) {
1752 // redraw the whole screen
1753 doComposeSurfaces(display);
Mathias Agopiancd60f992012-08-16 16:28:27 -07001754
David Sodmanfa9b2af2017-12-24 13:28:59 -08001755 // and draw the dirty region
David Sodmanfa9b2af2017-12-24 13:28:59 -08001756 auto& engine(getRenderEngine());
Chia-I Wu28e3a252018-09-07 12:05:02 -07001757 engine.fillRegionWithColor(dirtyRegion, 1, 0, 1, 1);
Mathias Agopian3f844832013-08-07 21:24:32 -07001758
Alec Mouri0a9c7b82018-11-16 13:05:25 -08001759 display->queueBuffer(getHwComposer());
Mathias Agopiancd60f992012-08-16 16:28:27 -07001760 }
1761 }
1762
David Sodmanfa9b2af2017-12-24 13:28:59 -08001763 postFramebuffer(display);
Mathias Agopiancd60f992012-08-16 16:28:27 -07001764
1765 if (mDebugRegion > 1) {
1766 usleep(mDebugRegion * 1000);
1767 }
Mathias Agopianbb53b0e2012-09-24 21:27:29 -07001768
Dominik Laskowski05275f12018-11-01 15:03:24 -07001769 prepareFrame(display);
Mathias Agopiancd60f992012-08-16 16:28:27 -07001770}
1771
Adrian Roos1e1a1282017-11-01 19:05:31 +01001772void SurfaceFlinger::doTracing(const char* where) {
1773 ATRACE_CALL();
1774 ATRACE_NAME(where);
1775 if (CC_UNLIKELY(mTracing.isEnabled())) {
Jorim Jaggi8e0af362017-11-14 16:28:28 +01001776 mTracing.traceLayers(where, dumpProtoInfo(LayerVector::StateSet::Drawing));
Adrian Roos1e1a1282017-11-01 19:05:31 +01001777 }
1778}
1779
Yiwei Zhang7124ad32018-02-21 13:02:45 -08001780void SurfaceFlinger::logLayerStats() {
1781 ATRACE_CALL();
1782 if (CC_UNLIKELY(mLayerStats.isEnabled())) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07001783 for (const auto& [token, display] : mDisplays) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001784 if (display->isPrimary()) {
1785 mLayerStats.logLayerStats(dumpVisibleLayersProtoInfo(*display));
Dominik Laskowski63165dc2018-05-25 18:36:52 -07001786 return;
Yiwei Zhang7124ad32018-02-21 13:02:45 -08001787 }
1788 }
Dominik Laskowski63165dc2018-05-25 18:36:52 -07001789
1790 ALOGE("logLayerStats: no primary display");
Yiwei Zhang7124ad32018-02-21 13:02:45 -08001791 }
1792}
1793
David Sodman2b406362017-12-15 13:33:47 -08001794void SurfaceFlinger::preComposition()
Mathias Agopiancd60f992012-08-16 16:28:27 -07001795{
Dan Stoza9e56aa02015-11-02 13:00:03 -08001796 ATRACE_CALL();
1797 ALOGV("preComposition");
1798
David Sodman2b406362017-12-15 13:33:47 -08001799 mRefreshStartTime = systemTime(SYSTEM_TIME_MONOTONIC);
1800
Mathias Agopiancd60f992012-08-16 16:28:27 -07001801 bool needExtraInvalidate = false;
Robert Carr2047fae2016-11-28 14:09:09 -08001802 mDrawingState.traverseInZOrder([&](Layer* layer) {
David Sodman2b406362017-12-15 13:33:47 -08001803 if (layer->onPreComposition(mRefreshStartTime)) {
Mathias Agopiancd60f992012-08-16 16:28:27 -07001804 needExtraInvalidate = true;
1805 }
Robert Carr2047fae2016-11-28 14:09:09 -08001806 });
1807
Mathias Agopiancd60f992012-08-16 16:28:27 -07001808 if (needExtraInvalidate) {
1809 signalLayerUpdate();
1810 }
1811}
1812
Ana Krulece588e312018-09-18 12:32:24 -07001813void SurfaceFlinger::updateCompositorTiming(const DisplayStatInfo& stats, nsecs_t compositeTime,
1814 std::shared_ptr<FenceTime>& presentFenceTime) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001815 // Update queue of past composite+present times and determine the
1816 // most recently known composite to present latency.
David Sodman99974d22017-11-28 12:04:33 -08001817 getBE().mCompositePresentTimes.push({compositeTime, presentFenceTime});
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001818 nsecs_t compositeToPresentLatency = -1;
David Sodman99974d22017-11-28 12:04:33 -08001819 while (!getBE().mCompositePresentTimes.empty()) {
1820 SurfaceFlingerBE::CompositePresentTime& cpt = getBE().mCompositePresentTimes.front();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001821 // Cached values should have been updated before calling this method,
1822 // which helps avoid duplicate syscalls.
1823 nsecs_t displayTime = cpt.display->getCachedSignalTime();
1824 if (displayTime == Fence::SIGNAL_TIME_PENDING) {
1825 break;
1826 }
1827 compositeToPresentLatency = displayTime - cpt.composite;
David Sodman99974d22017-11-28 12:04:33 -08001828 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001829 }
1830
1831 // Don't let mCompositePresentTimes grow unbounded, just in case.
David Sodman99974d22017-11-28 12:04:33 -08001832 while (getBE().mCompositePresentTimes.size() > 16) {
1833 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001834 }
1835
Ana Krulece588e312018-09-18 12:32:24 -07001836 setCompositorTimingSnapped(stats, compositeToPresentLatency);
Brian Andersond0010582017-03-07 13:20:31 -08001837}
1838
Ana Krulece588e312018-09-18 12:32:24 -07001839void SurfaceFlinger::setCompositorTimingSnapped(const DisplayStatInfo& stats,
1840 nsecs_t compositeToPresentLatency) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001841 // Integer division and modulo round toward 0 not -inf, so we need to
1842 // treat negative and positive offsets differently.
Ana Krulece588e312018-09-18 12:32:24 -07001843 nsecs_t idealLatency = (sfVsyncPhaseOffsetNs > 0)
1844 ? (stats.vsyncPeriod - (sfVsyncPhaseOffsetNs % stats.vsyncPeriod))
1845 : ((-sfVsyncPhaseOffsetNs) % stats.vsyncPeriod);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001846
Brian Andersond0010582017-03-07 13:20:31 -08001847 // Just in case sfVsyncPhaseOffsetNs == -vsyncInterval.
1848 if (idealLatency <= 0) {
Ana Krulece588e312018-09-18 12:32:24 -07001849 idealLatency = stats.vsyncPeriod;
Brian Andersond0010582017-03-07 13:20:31 -08001850 }
1851
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001852 // Snap the latency to a value that removes scheduling jitter from the
1853 // composition and present times, which often have >1ms of jitter.
1854 // Reducing jitter is important if an app attempts to extrapolate
1855 // something (such as user input) to an accurate diasplay time.
1856 // Snapping also allows an app to precisely calculate sfVsyncPhaseOffsetNs
1857 // with (presentLatency % interval).
Ana Krulece588e312018-09-18 12:32:24 -07001858 nsecs_t bias = stats.vsyncPeriod / 2;
1859 int64_t extraVsyncs = (compositeToPresentLatency - idealLatency + bias) / stats.vsyncPeriod;
1860 nsecs_t snappedCompositeToPresentLatency =
1861 (extraVsyncs > 0) ? idealLatency + (extraVsyncs * stats.vsyncPeriod) : idealLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001862
David Sodman99974d22017-11-28 12:04:33 -08001863 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
Ana Krulece588e312018-09-18 12:32:24 -07001864 getBE().mCompositorTiming.deadline = stats.vsyncTime - idealLatency;
1865 getBE().mCompositorTiming.interval = stats.vsyncPeriod;
David Sodman99974d22017-11-28 12:04:33 -08001866 getBE().mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001867}
1868
David Sodman2b406362017-12-15 13:33:47 -08001869void SurfaceFlinger::postComposition()
Mathias Agopiancd60f992012-08-16 16:28:27 -07001870{
Dan Stoza9e56aa02015-11-02 13:00:03 -08001871 ATRACE_CALL();
1872 ALOGV("postComposition");
1873
Brian Anderson3546a3f2016-07-14 11:51:14 -07001874 // Release any buffers which were replaced this frame
Brian Andersonf6386862016-10-31 16:34:13 -07001875 nsecs_t dequeueReadyTime = systemTime();
Brian Anderson3546a3f2016-07-14 11:51:14 -07001876 for (auto& layer : mLayersWithQueuedFrames) {
Brian Andersonf6386862016-10-31 16:34:13 -07001877 layer->releasePendingBuffer(dequeueReadyTime);
Brian Anderson3546a3f2016-07-14 11:51:14 -07001878 }
1879
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001880 // |mStateLock| not needed as we are on the main thread
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001881 const auto display = getDefaultDisplayDeviceLocked();
Brian Anderson3d4039d2016-09-23 16:31:30 -07001882
David Sodman73beded2017-11-15 11:56:06 -08001883 getBE().mGlCompositionDoneTimeline.updateSignalTimes();
Brian Anderson3d4039d2016-09-23 16:31:30 -07001884 std::shared_ptr<FenceTime> glCompositionDoneFenceTime;
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07001885 if (display && getHwComposer().hasClientComposition(display->getId())) {
Brian Anderson3d4039d2016-09-23 16:31:30 -07001886 glCompositionDoneFenceTime =
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001887 std::make_shared<FenceTime>(display->getClientTargetAcquireFence());
David Sodman73beded2017-11-15 11:56:06 -08001888 getBE().mGlCompositionDoneTimeline.push(glCompositionDoneFenceTime);
Brian Anderson3d4039d2016-09-23 16:31:30 -07001889 } else {
1890 glCompositionDoneFenceTime = FenceTime::NO_FENCE;
1891 }
Brian Anderson3d4039d2016-09-23 16:31:30 -07001892
David Sodman73beded2017-11-15 11:56:06 -08001893 getBE().mDisplayTimeline.updateSignalTimes();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07001894 mPreviousPresentFence =
Dominik Laskowski075d3172018-05-24 15:50:06 -07001895 display ? getHwComposer().getPresentFence(*display->getId()) : Fence::NO_FENCE;
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07001896 auto presentFenceTime = std::make_shared<FenceTime>(mPreviousPresentFence);
David Sodman73beded2017-11-15 11:56:06 -08001897 getBE().mDisplayTimeline.push(presentFenceTime);
Brian Anderson3d4039d2016-09-23 16:31:30 -07001898
Ana Krulece588e312018-09-18 12:32:24 -07001899 DisplayStatInfo stats;
1900 if (mUseScheduler) {
1901 mScheduler->getDisplayStatInfo(&stats);
1902 } else {
1903 stats.vsyncTime = mPrimaryDispSync->computeNextRefresh(0);
1904 stats.vsyncPeriod = mPrimaryDispSync->getPeriod();
1905 }
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001906
David Sodman2b406362017-12-15 13:33:47 -08001907 // We use the mRefreshStartTime which might be sampled a little later than
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001908 // when we started doing work for this frame, but that should be okay
1909 // since updateCompositorTiming has snapping logic.
Ana Krulece588e312018-09-18 12:32:24 -07001910 updateCompositorTiming(stats, mRefreshStartTime, presentFenceTime);
Brian Andersond0010582017-03-07 13:20:31 -08001911 CompositorTiming compositorTiming;
1912 {
David Sodman99974d22017-11-28 12:04:33 -08001913 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
1914 compositorTiming = getBE().mCompositorTiming;
Brian Andersond0010582017-03-07 13:20:31 -08001915 }
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001916
Robert Carr2047fae2016-11-28 14:09:09 -08001917 mDrawingState.traverseInZOrder([&](Layer* layer) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07001918 bool frameLatched = layer->onPostComposition(display->getId(), glCompositionDoneFenceTime,
1919 presentFenceTime, compositorTiming);
Dan Stozae77c7662016-05-13 11:37:28 -07001920 if (frameLatched) {
Robert Carr2047fae2016-11-28 14:09:09 -08001921 recordBufferingStats(layer->getName().string(),
1922 layer->getOccupancyHistory(false));
Dan Stozae77c7662016-05-13 11:37:28 -07001923 }
Robert Carr2047fae2016-11-28 14:09:09 -08001924 });
Jamie Gennis4b0eba92013-02-05 13:30:24 -08001925
Brian Andersonfbc80ae2017-05-26 16:23:54 -07001926 if (presentFenceTime->isValid()) {
Ana Krulece588e312018-09-18 12:32:24 -07001927 if (mUseScheduler) {
1928 mScheduler->addPresentFence(presentFenceTime);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001929 } else {
Ana Krulece588e312018-09-18 12:32:24 -07001930 if (mPrimaryDispSync->addPresentFence(presentFenceTime)) {
1931 enableHardwareVsync();
1932 } else {
1933 disableHardwareVsync(false);
1934 }
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001935 }
1936 }
1937
Fabien Sanglardcbf153b2017-03-10 17:57:12 -08001938 if (!hasSyncFramework) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07001939 if (display && getHwComposer().isConnected(*display->getId()) && display->isPoweredOn()) {
Ana Krulece588e312018-09-18 12:32:24 -07001940 if (mUseScheduler) {
1941 mScheduler->enableHardwareVsync();
1942 } else {
1943 enableHardwareVsync();
1944 }
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001945 }
1946 }
1947
Jamie Gennis4b0eba92013-02-05 13:30:24 -08001948 if (mAnimCompositionPending) {
1949 mAnimCompositionPending = false;
1950
Brian Anderson4e606e32017-03-16 15:34:57 -07001951 if (presentFenceTime->isValid()) {
Brian Anderson3d4039d2016-09-23 16:31:30 -07001952 mAnimFrameTracker.setActualPresentFence(
Brian Anderson4e606e32017-03-16 15:34:57 -07001953 std::move(presentFenceTime));
Dominik Laskowski075d3172018-05-24 15:50:06 -07001954 } else if (display && getHwComposer().isConnected(*display->getId())) {
Jamie Gennis4b0eba92013-02-05 13:30:24 -08001955 // The HWC doesn't support present fences, so use the refresh
1956 // timestamp instead.
Dominik Laskowski075d3172018-05-24 15:50:06 -07001957 const nsecs_t presentTime = getHwComposer().getRefreshTimestamp(*display->getId());
Jamie Gennis4b0eba92013-02-05 13:30:24 -08001958 mAnimFrameTracker.setActualPresentTime(presentTime);
1959 }
1960 mAnimFrameTracker.advanceFrame();
1961 }
Dan Stozab90cf072015-03-05 11:05:59 -08001962
Yiwei Zhang7e666a52018-11-15 13:33:42 -08001963 mTimeStats->incrementTotalFrames();
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07001964 if (mHadClientComposition) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08001965 mTimeStats->incrementClientCompositionFrames();
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07001966 }
1967
Yiwei Zhang7e666a52018-11-15 13:33:42 -08001968 mTimeStats->setPresentFenceGlobal(presentFenceTime);
Yiwei Zhangce6ebc02018-10-20 12:42:38 -07001969
Dominik Laskowski075d3172018-05-24 15:50:06 -07001970 if (display && getHwComposer().isConnected(*display->getId()) && !display->isPoweredOn()) {
Dan Stozab90cf072015-03-05 11:05:59 -08001971 return;
1972 }
1973
1974 nsecs_t currentTime = systemTime();
1975 if (mHasPoweredOff) {
1976 mHasPoweredOff = false;
1977 } else {
David Sodman4a36e932017-11-07 14:29:47 -08001978 nsecs_t elapsedTime = currentTime - getBE().mLastSwapTime;
Ana Krulece588e312018-09-18 12:32:24 -07001979 size_t numPeriods = static_cast<size_t>(elapsedTime / stats.vsyncPeriod);
David Sodman4a36e932017-11-07 14:29:47 -08001980 if (numPeriods < SurfaceFlingerBE::NUM_BUCKETS - 1) {
1981 getBE().mFrameBuckets[numPeriods] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08001982 } else {
David Sodman4a36e932017-11-07 14:29:47 -08001983 getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08001984 }
David Sodman4a36e932017-11-07 14:29:47 -08001985 getBE().mTotalTime += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08001986 }
David Sodman4a36e932017-11-07 14:29:47 -08001987 getBE().mLastSwapTime = currentTime;
Dan Stoza436ccf32018-06-21 12:10:12 -07001988
1989 {
1990 std::lock_guard lock(mTexturePoolMutex);
1991 const size_t refillCount = mTexturePoolSize - mTexturePool.size();
1992 if (refillCount > 0) {
1993 const size_t offset = mTexturePool.size();
1994 mTexturePool.resize(mTexturePoolSize);
1995 getRenderEngine().genTextures(refillCount, mTexturePool.data() + offset);
1996 ATRACE_INT("TexturePoolSize", mTexturePool.size());
1997 }
1998 }
Marissa Walle2ffb422018-10-12 11:33:52 -07001999
Marissa Wallfda30bb2018-10-12 11:34:28 -07002000 mTransactionCompletedThread.addPresentFence(mPreviousPresentFence);
Marissa Walle2ffb422018-10-12 11:33:52 -07002001 mTransactionCompletedThread.sendCallbacks();
Mathias Agopiancd60f992012-08-16 16:28:27 -07002002}
2003
2004void SurfaceFlinger::rebuildLayerStacks() {
Dan Stoza9e56aa02015-11-02 13:00:03 -08002005 ATRACE_CALL();
2006 ALOGV("rebuildLayerStacks");
2007
Lloyd Piquedcec0bc2018-11-16 16:08:10 -08002008 // We need to clear these out now as these may be holding on to a
2009 // HWC2::Layer reference at the same time as the LayerBE::HWCInfo structure
2010 // also holds a reference. When the set of visible layers is recomputed,
2011 // some layers may be destroyed if the only thing keeping them alive was
2012 // that list of visible layers associated with each display. The layer
2013 // destruction code asserts that the HWC2::Layer is properly destroyed, but
2014 // that doesn't happen if SurfaceFlingerBE::mCompositionInfo keeps it alive.
2015 for (const auto& [token, display] : mDisplays) {
2016 getBE().mCompositionInfo[token].clear();
2017 }
2018
Mathias Agopiancd60f992012-08-16 16:28:27 -07002019 // rebuild the visible layer list per screen
Jeff Sharkey76488112017-02-27 14:15:18 -07002020 if (CC_UNLIKELY(mVisibleRegionsDirty)) {
Siarhei Vishniakoufc2589e2017-09-21 15:35:13 -07002021 ATRACE_NAME("rebuildLayerStacks VR Dirty");
Jeff Sharkey76488112017-02-27 14:15:18 -07002022 mVisibleRegionsDirty = false;
2023 invalidateHwcGeometry();
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002024
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002025 for (const auto& pair : mDisplays) {
2026 const auto& display = pair.second;
Jeff Sharkey76488112017-02-27 14:15:18 -07002027 Region opaqueRegion;
2028 Region dirtyRegion;
2029 Vector<sp<Layer>> layersSortedByZ;
Chia-I Wu83806892017-11-16 10:50:20 -08002030 Vector<sp<Layer>> layersNeedingFences;
Peiyong Linefefaac2018-08-17 12:27:51 -07002031 const ui::Transform& tr = display->getTransform();
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002032 const Rect bounds = display->getBounds();
2033 if (display->isPoweredOn()) {
2034 computeVisibleRegions(display, dirtyRegion, opaqueRegion);
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002035
Jeff Sharkey76488112017-02-27 14:15:18 -07002036 mDrawingState.traverseInZOrder([&](Layer* layer) {
Chia-I Wu83806892017-11-16 10:50:20 -08002037 bool hwcLayerDestroyed = false;
Dominik Laskowski075d3172018-05-24 15:50:06 -07002038 const auto displayId = display->getId();
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002039 if (layer->belongsToDisplay(display->getLayerStack(), display->isPrimary())) {
Jeff Sharkey76488112017-02-27 14:15:18 -07002040 Region drawRegion(tr.transform(
2041 layer->visibleNonTransparentRegion));
2042 drawRegion.andSelf(bounds);
2043 if (!drawRegion.isEmpty()) {
2044 layersSortedByZ.add(layer);
2045 } else {
Lloyd Pique074e8122018-07-26 12:57:23 -07002046 // Clear out the HWC layer if this layer was
2047 // previously visible, but no longer is
Dominik Laskowski075d3172018-05-24 15:50:06 -07002048 hwcLayerDestroyed = displayId && layer->destroyHwcLayer(*displayId);
Jeff Sharkey76488112017-02-27 14:15:18 -07002049 }
Chia-I Wu30505fb2018-03-26 16:20:31 -07002050 } else {
Lloyd Pique074e8122018-07-26 12:57:23 -07002051 // WM changes display->layerStack upon sleep/awake.
2052 // Here we make sure we delete the HWC layers even if
2053 // WM changed their layer stack.
Dominik Laskowski075d3172018-05-24 15:50:06 -07002054 hwcLayerDestroyed = displayId && layer->destroyHwcLayer(*displayId);
Chia-I Wu83806892017-11-16 10:50:20 -08002055 }
2056
2057 // If a layer is not going to get a release fence because
2058 // it is invisible, but it is also going to release its
2059 // old buffer, add it to the list of layers needing
2060 // fences.
2061 if (hwcLayerDestroyed) {
2062 auto found = std::find(mLayersWithQueuedFrames.cbegin(),
2063 mLayersWithQueuedFrames.cend(), layer);
2064 if (found != mLayersWithQueuedFrames.cend()) {
2065 layersNeedingFences.add(layer);
2066 }
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002067 }
Jeff Sharkey76488112017-02-27 14:15:18 -07002068 });
2069 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002070 display->setVisibleLayersSortedByZ(layersSortedByZ);
2071 display->setLayersNeedingFences(layersNeedingFences);
2072 display->undefinedRegion.set(bounds);
2073 display->undefinedRegion.subtractSelf(tr.transform(opaqueRegion));
2074 display->dirtyRegion.orSelf(dirtyRegion);
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002075 }
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002076 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07002077}
Mathias Agopian3b1d2b62012-07-11 13:48:17 -07002078
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002079// Returns a data space that fits all visible layers. The returned data space
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002080// can only be one of
Chia-I Wu7a28ecb2018-05-04 10:38:39 -07002081// - Dataspace::SRGB (use legacy dataspace and let HWC saturate when colors are enhanced)
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002082// - Dataspace::DISPLAY_P3
Valerie Hau9758ae02018-10-09 16:05:09 -07002083// - Dataspace::DISPLAY_BT2020
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002084// The returned HDR data space is one of
2085// - Dataspace::UNKNOWN
2086// - Dataspace::BT2020_HLG
2087// - Dataspace::BT2020_PQ
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002088Dataspace SurfaceFlinger::getBestDataspace(const sp<const DisplayDevice>& display,
2089 Dataspace* outHdrDataSpace) const {
Peiyong Lin14724e62018-12-05 07:27:30 -08002090 Dataspace bestDataSpace = Dataspace::V0_SRGB;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002091 *outHdrDataSpace = Dataspace::UNKNOWN;
2092
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002093 for (const auto& layer : display->getVisibleLayersSortedByZ()) {
Chia-I Wu01591c92018-05-22 12:03:00 -07002094 switch (layer->getDataSpace()) {
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002095 case Dataspace::V0_SCRGB:
2096 case Dataspace::V0_SCRGB_LINEAR:
Valerie Hau9758ae02018-10-09 16:05:09 -07002097 case Dataspace::BT2020:
2098 case Dataspace::BT2020_ITU:
2099 case Dataspace::BT2020_LINEAR:
2100 case Dataspace::DISPLAY_BT2020:
2101 bestDataSpace = Dataspace::DISPLAY_BT2020;
2102 break;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002103 case Dataspace::DISPLAY_P3:
Chia-I Wube02ec02018-05-18 10:59:36 -07002104 bestDataSpace = Dataspace::DISPLAY_P3;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002105 break;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002106 case Dataspace::BT2020_PQ:
2107 case Dataspace::BT2020_ITU_PQ:
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002108 *outHdrDataSpace = Dataspace::BT2020_PQ;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002109 break;
Peiyong Linf59a7192018-04-25 11:19:31 -07002110 case Dataspace::BT2020_HLG:
2111 case Dataspace::BT2020_ITU_HLG:
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002112 // When there's mixed PQ content and HLG content, we set the HDR
2113 // data space to be BT2020_PQ and convert HLG to PQ.
2114 if (*outHdrDataSpace == Dataspace::UNKNOWN) {
2115 *outHdrDataSpace = Dataspace::BT2020_HLG;
Peiyong Linf59a7192018-04-25 11:19:31 -07002116 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002117 break;
2118 default:
2119 break;
2120 }
Romain Guy54f154a2017-10-24 21:40:32 +01002121 }
2122
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002123 return bestDataSpace;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06002124}
2125
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002126// Pick the ColorMode / Dataspace for the display device.
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002127void SurfaceFlinger::pickColorMode(const sp<DisplayDevice>& display, ColorMode* outMode,
2128 Dataspace* outDataSpace, RenderIntent* outRenderIntent) const {
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002129 if (mDisplayColorSetting == DisplayColorSetting::UNMANAGED) {
2130 *outMode = ColorMode::NATIVE;
2131 *outDataSpace = Dataspace::UNKNOWN;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002132 *outRenderIntent = RenderIntent::COLORIMETRIC;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002133 return;
Chia-I Wu5c6e4632018-01-11 08:54:38 -08002134 }
Romain Guy88d37dd2017-05-26 17:57:05 -07002135
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002136 Dataspace hdrDataSpace;
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002137 Dataspace bestDataSpace = getBestDataspace(display, &hdrDataSpace);
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002138
Peiyong Lindfde5112018-06-05 10:58:41 -07002139 // respect hdrDataSpace only when there is no legacy HDR support
Chia-I Wuc4b08bd2018-05-29 12:57:23 -07002140 const bool isHdr = hdrDataSpace != Dataspace::UNKNOWN &&
Peiyong Lindfde5112018-06-05 10:58:41 -07002141 !display->hasLegacyHdrSupport(hdrDataSpace);
Chia-I Wuc4b08bd2018-05-29 12:57:23 -07002142 if (isHdr) {
2143 bestDataSpace = hdrDataSpace;
2144 }
2145
Chia-I Wu0d711262018-05-21 15:19:35 -07002146 RenderIntent intent;
2147 switch (mDisplayColorSetting) {
2148 case DisplayColorSetting::MANAGED:
2149 case DisplayColorSetting::UNMANAGED:
Chia-I Wuc4b08bd2018-05-29 12:57:23 -07002150 intent = isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC;
Chia-I Wu0d711262018-05-21 15:19:35 -07002151 break;
2152 case DisplayColorSetting::ENHANCED:
Chia-I Wuc4b08bd2018-05-29 12:57:23 -07002153 intent = isHdr ? RenderIntent::TONE_MAP_ENHANCE : RenderIntent::ENHANCE;
Chia-I Wu0d711262018-05-21 15:19:35 -07002154 break;
2155 default: // vendor display color setting
2156 intent = static_cast<RenderIntent>(mDisplayColorSetting);
2157 break;
2158 }
Chia-I Wube02ec02018-05-18 10:59:36 -07002159
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002160 display->getBestColorMode(bestDataSpace, intent, outDataSpace, outMode, outRenderIntent);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06002161}
2162
David Sodmanfa9b2af2017-12-24 13:28:59 -08002163void SurfaceFlinger::beginFrame(const sp<DisplayDevice>& display)
David Sodman2b406362017-12-15 13:33:47 -08002164{
David Sodmanfa9b2af2017-12-24 13:28:59 -08002165 bool dirty = !display->getDirtyRegion(false).isEmpty();
2166 bool empty = display->getVisibleLayersSortedByZ().size() == 0;
2167 bool wasEmpty = !display->lastCompositionHadVisibleLayers;
David Sodman2b406362017-12-15 13:33:47 -08002168
David Sodmanfa9b2af2017-12-24 13:28:59 -08002169 // If nothing has changed (!dirty), don't recompose.
2170 // If something changed, but we don't currently have any visible layers,
2171 // and didn't when we last did a composition, then skip it this time.
2172 // The second rule does two things:
2173 // - When all layers are removed from a display, we'll emit one black
2174 // frame, then nothing more until we get new layers.
2175 // - When a display is created with a private layer stack, we won't
2176 // emit any black frames until a layer is added to the layer stack.
2177 bool mustRecompose = dirty && !(empty && wasEmpty);
David Sodman2b406362017-12-15 13:33:47 -08002178
Dominik Laskowski075d3172018-05-24 15:50:06 -07002179 const char flagPrefix[] = {'-', '+'};
2180 static_cast<void>(flagPrefix);
2181 ALOGV_IF(display->isVirtual(), "%s: %s composition for %s (%cdirty %cempty %cwasEmpty)",
2182 __FUNCTION__, mustRecompose ? "doing" : "skipping", display->getDebugName().c_str(),
2183 flagPrefix[dirty], flagPrefix[empty], flagPrefix[wasEmpty]);
David Sodman2b406362017-12-15 13:33:47 -08002184
David Sodmanfa9b2af2017-12-24 13:28:59 -08002185 display->beginFrame(mustRecompose);
David Sodman2b406362017-12-15 13:33:47 -08002186
David Sodmanfa9b2af2017-12-24 13:28:59 -08002187 if (mustRecompose) {
2188 display->lastCompositionHadVisibleLayers = !empty;
David Sodman2b406362017-12-15 13:33:47 -08002189 }
2190}
2191
David Sodmanfa9b2af2017-12-24 13:28:59 -08002192void SurfaceFlinger::prepareFrame(const sp<DisplayDevice>& display)
David Sodman2b406362017-12-15 13:33:47 -08002193{
David Sodmanfa9b2af2017-12-24 13:28:59 -08002194 if (!display->isPoweredOn()) {
2195 return;
David Sodman2b406362017-12-15 13:33:47 -08002196 }
David Sodmanfa9b2af2017-12-24 13:28:59 -08002197
Dominik Laskowski05275f12018-11-01 15:03:24 -07002198 status_t result = display->prepareFrame(getHwComposer(),
2199 getBE().mCompositionInfo[display->getDisplayToken()]);
Dominik Laskowski075d3172018-05-24 15:50:06 -07002200 ALOGE_IF(result != NO_ERROR, "prepareFrame failed for %s: %d (%s)",
2201 display->getDebugName().c_str(), result, strerror(-result));
David Sodman2b406362017-12-15 13:33:47 -08002202}
Mathias Agopian52bbb1a2012-07-31 19:01:53 -07002203
David Sodmanfa9b2af2017-12-24 13:28:59 -08002204void SurfaceFlinger::doComposition(const sp<DisplayDevice>& display, bool repaintEverything) {
Mathias Agopiancd60f992012-08-16 16:28:27 -07002205 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08002206 ALOGV("doComposition");
2207
David Sodmanfa9b2af2017-12-24 13:28:59 -08002208 if (display->isPoweredOn()) {
2209 // transform the dirty region into this screen's coordinate space
2210 const Region dirtyRegion(display->getDirtyRegion(repaintEverything));
Mathias Agopian02b95102012-11-05 17:50:57 -08002211
David Sodmanfa9b2af2017-12-24 13:28:59 -08002212 // repaint the framebuffer (if needed)
2213 doDisplayComposition(display, dirtyRegion);
Mathias Agopian02b95102012-11-05 17:50:57 -08002214
David Sodmanfa9b2af2017-12-24 13:28:59 -08002215 display->dirtyRegion.clear();
2216 display->flip();
Mathias Agopian4fec8732012-06-29 14:12:52 -07002217 }
David Sodmanfa9b2af2017-12-24 13:28:59 -08002218 postFramebuffer(display);
Mathias Agopian4fec8732012-06-29 14:12:52 -07002219}
2220
David Sodmanfa9b2af2017-12-24 13:28:59 -08002221void SurfaceFlinger::postFrame()
2222{
2223 // |mStateLock| not needed as we are on the main thread
Dominik Laskowski075d3172018-05-24 15:50:06 -07002224 const auto display = getDefaultDisplayDeviceLocked();
2225 if (display && getHwComposer().isConnected(*display->getId())) {
2226 uint32_t flipCount = display->getPageFlipCount();
David Sodmanfa9b2af2017-12-24 13:28:59 -08002227 if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
2228 logFrameStats();
2229 }
2230 }
2231}
2232
2233void SurfaceFlinger::postFramebuffer(const sp<DisplayDevice>& display)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002234{
Mathias Agopian841cde52012-03-01 15:44:37 -08002235 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08002236 ALOGV("postFramebuffer");
Mathias Agopianb048cef2012-02-04 15:44:04 -08002237
David Sodmanfa9b2af2017-12-24 13:28:59 -08002238 mPostFramebufferTime = systemTime();
Jesse Hallc5c5a142012-07-02 16:49:28 -07002239
David Sodmanfa9b2af2017-12-24 13:28:59 -08002240 if (display->isPoweredOn()) {
Dominik Laskowski7e045462018-05-30 13:02:02 -07002241 const auto displayId = display->getId();
Dominik Laskowski075d3172018-05-24 15:50:06 -07002242 if (displayId) {
2243 getHwComposer().presentAndGetReleaseFences(*displayId);
Mathias Agopian2a231842012-09-24 18:12:35 -07002244 }
Alec Mouri0a9c7b82018-11-16 13:05:25 -08002245 display->onPresentDisplayCompleted();
David Sodman15094112018-10-11 09:39:37 -07002246 for (auto& layer : display->getVisibleLayersSortedByZ()) {
Chia-I Wu0f509fb2018-06-21 15:52:50 +08002247 sp<Fence> releaseFence = Fence::NO_FENCE;
David Sodman15094112018-10-11 09:39:37 -07002248
Chia-I Wu7b549592017-11-15 09:14:57 -08002249 // The layer buffer from the previous frame (if any) is released
2250 // by HWC only when the release fence from this frame (if any) is
2251 // signaled. Always get the release fence from HWC first.
Dominik Laskowski075d3172018-05-24 15:50:06 -07002252 if (displayId && layer->hasHwcLayer(*displayId)) {
2253 releaseFence = getHwComposer().getLayerReleaseFence(*displayId,
2254 layer->getHwcLayer(*displayId));
Chia-I Wu0f509fb2018-06-21 15:52:50 +08002255 }
Chia-I Wu7b549592017-11-15 09:14:57 -08002256
2257 // If the layer was client composited in the previous frame, we
2258 // need to merge with the previous client target acquire fence.
2259 // Since we do not track that, always merge with the current
2260 // client target acquire fence when it is available, even though
2261 // this is suboptimal.
David Sodman15094112018-10-11 09:39:37 -07002262 if (layer->getCompositionType(displayId) == HWC2::Composition::Client) {
Chia-I Wu7b549592017-11-15 09:14:57 -08002263 releaseFence = Fence::merge("LayerRelease", releaseFence,
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002264 display->getClientTargetAcquireFence());
Mathias Agopian52bbb1a2012-07-31 19:01:53 -07002265 }
Chia-I Wu7b549592017-11-15 09:14:57 -08002266
David Sodman15094112018-10-11 09:39:37 -07002267 layer->getBE().onLayerDisplayed(releaseFence);
Dan Stoza9e56aa02015-11-02 13:00:03 -08002268 }
Chia-I Wu83806892017-11-16 10:50:20 -08002269
2270 // We've got a list of layers needing fences, that are disjoint with
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002271 // display->getVisibleLayersSortedByZ. The best we can do is to
Chia-I Wu83806892017-11-16 10:50:20 -08002272 // supply them with the present fence.
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002273 if (!display->getLayersNeedingFences().isEmpty()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002274 sp<Fence> presentFence =
2275 displayId ? getBE().mHwc->getPresentFence(*displayId) : Fence::NO_FENCE;
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002276 for (auto& layer : display->getLayersNeedingFences()) {
David Sodmanb8af7922017-12-21 15:17:55 -08002277 layer->getBE().onLayerDisplayed(presentFence);
Chia-I Wu83806892017-11-16 10:50:20 -08002278 }
2279 }
2280
Dominik Laskowski075d3172018-05-24 15:50:06 -07002281 if (displayId) {
2282 getHwComposer().clearReleaseFences(*displayId);
Jesse Hallef194142012-06-14 14:45:17 -07002283 }
Jamie Gennise8696a42012-01-15 18:54:57 -08002284 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002285}
2286
Mathias Agopian87baae12012-07-31 12:38:26 -07002287void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002288{
Mathias Agopian841cde52012-03-01 15:44:37 -08002289 ATRACE_CALL();
2290
Mathias Agopian7cc6df52013-06-05 14:30:54 -07002291 // here we keep a copy of the drawing state (that is the state that's
2292 // going to be overwritten by handleTransactionLocked()) outside of
2293 // mStateLock so that the side-effects of the State assignment
2294 // don't happen with mStateLock held (which can cause deadlocks).
2295 State drawingState(mDrawingState);
2296
Mathias Agopianca4d3602011-05-19 15:38:14 -07002297 Mutex::Autolock _l(mStateLock);
2298 const nsecs_t now = systemTime();
2299 mDebugInTransaction = now;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002300
Mathias Agopianca4d3602011-05-19 15:38:14 -07002301 // Here we're guaranteed that some transaction flags are set
2302 // so we can call handleTransactionLocked() unconditionally.
2303 // We call getTransactionFlags(), which will also clear the flags,
2304 // with mStateLock held to guarantee that mCurrentState won't change
2305 // until the transaction is committed.
Mathias Agopian4da75192010-08-10 17:19:56 -07002306
Jorim Jaggif15c3be2018-04-12 12:56:58 +01002307 mVsyncModulator.onTransactionHandled();
Mathias Agopiane57f2922012-08-09 16:29:12 -07002308 transactionFlags = getTransactionFlags(eTransactionMask);
Mathias Agopian87baae12012-07-31 12:38:26 -07002309 handleTransactionLocked(transactionFlags);
Mathias Agopiandea20b12011-05-03 17:04:02 -07002310
Mathias Agopianca4d3602011-05-19 15:38:14 -07002311 mLastTransactionTime = systemTime() - now;
2312 mDebugInTransaction = 0;
2313 invalidateHwcGeometry();
2314 // here the transaction has been committed
Mathias Agopian3d579642009-06-04 18:46:21 -07002315}
2316
Lloyd Piqueba04e622017-12-14 17:11:26 -08002317void SurfaceFlinger::processDisplayHotplugEventsLocked() {
2318 for (const auto& event : mPendingHotplugEvents) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002319 const std::optional<DisplayIdentificationInfo> info =
2320 getHwComposer().onHotplug(event.hwcDisplayId, event.connection);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002321
Dominik Laskowski075d3172018-05-24 15:50:06 -07002322 if (!info) {
Lloyd Piqueba04e622017-12-14 17:11:26 -08002323 continue;
2324 }
2325
Lloyd Piqueba04e622017-12-14 17:11:26 -08002326 if (event.connection == HWC2::Connection::Connected) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002327 if (!mPhysicalDisplayTokens.count(info->id)) {
Dominik Laskowski34157762018-10-31 13:07:19 -07002328 ALOGV("Creating display %s", to_string(info->id).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07002329 mPhysicalDisplayTokens[info->id] = new BBinder();
2330 DisplayDeviceState state;
2331 state.displayId = info->id;
2332 state.isSecure = true; // All physical displays are currently considered secure.
2333 state.displayName = info->name;
2334 mCurrentState.displays.add(mPhysicalDisplayTokens[info->id], state);
2335 mInterceptor->saveDisplayCreation(state);
Steven Thomaseb6d2052018-03-20 15:40:48 -07002336 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08002337 } else {
Dominik Laskowski34157762018-10-31 13:07:19 -07002338 ALOGV("Removing display %s", to_string(info->id).c_str());
Lloyd Piqueba04e622017-12-14 17:11:26 -08002339
Dominik Laskowski075d3172018-05-24 15:50:06 -07002340 ssize_t index = mCurrentState.displays.indexOfKey(mPhysicalDisplayTokens[info->id]);
2341 if (index >= 0) {
2342 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
2343 mInterceptor->saveDisplayDeletion(state.sequenceId);
2344 mCurrentState.displays.removeItemsAt(index);
Lloyd Piquefcd86612017-12-14 17:15:36 -08002345 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07002346 mPhysicalDisplayTokens.erase(info->id);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002347 }
2348
2349 processDisplayChangesLocked();
2350 }
2351
2352 mPendingHotplugEvents.clear();
2353}
2354
Lloyd Pique99d3da52018-01-22 17:48:03 -08002355sp<DisplayDevice> SurfaceFlinger::setupNewDisplayDeviceInternal(
Dominik Laskowski075d3172018-05-24 15:50:06 -07002356 const wp<IBinder>& displayToken, const std::optional<DisplayId>& displayId,
2357 const DisplayDeviceState& state, const sp<DisplaySurface>& dispSurface,
2358 const sp<IGraphicBufferProducer>& producer) {
2359 DisplayDeviceCreationArgs creationArgs(this, displayToken, displayId);
Dominik Laskowskie9774092018-12-11 10:04:24 -08002360 creationArgs.sequenceId = state.sequenceId;
Dominik Laskowski075d3172018-05-24 15:50:06 -07002361 creationArgs.isVirtual = state.isVirtual();
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002362 creationArgs.isSecure = state.isSecure;
2363 creationArgs.displaySurface = dispSurface;
2364 creationArgs.hasWideColorGamut = false;
2365 creationArgs.supportedPerFrameMetadata = 0;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002366
Dominik Laskowski075d3172018-05-24 15:50:06 -07002367 const bool isInternalDisplay = displayId && displayId == getInternalDisplayId();
2368 creationArgs.isPrimary = isInternalDisplay;
2369
2370 if (useColorManagement && displayId) {
2371 std::vector<ColorMode> modes = getHwComposer().getColorModes(*displayId);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002372 for (ColorMode colorMode : modes) {
Peiyong Linfca547f2018-07-09 13:03:33 -07002373 if (isWideColorMode(colorMode)) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002374 creationArgs.hasWideColorGamut = true;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002375 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002376
Dominik Laskowski7e045462018-05-30 13:02:02 -07002377 std::vector<RenderIntent> renderIntents =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002378 getHwComposer().getRenderIntents(*displayId, colorMode);
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002379 creationArgs.hwcColorModes.emplace(colorMode, renderIntents);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002380 }
tangrobin6753a022018-08-10 10:58:54 +08002381 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002382
Dominik Laskowski075d3172018-05-24 15:50:06 -07002383 if (displayId) {
2384 getHwComposer().getHdrCapabilities(*displayId, &creationArgs.hdrCapabilities);
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002385 creationArgs.supportedPerFrameMetadata =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002386 getHwComposer().getSupportedPerFrameMetadata(*displayId);
Chia-I Wu0f509fb2018-06-21 15:52:50 +08002387 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002388
Lloyd Pique90c115d2018-09-18 21:39:42 -07002389 auto nativeWindowSurface = getFactory().createNativeWindowSurface(producer);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002390 auto nativeWindow = nativeWindowSurface->getNativeWindow();
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002391 creationArgs.nativeWindow = nativeWindow;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002392
Lloyd Pique99d3da52018-01-22 17:48:03 -08002393 // Make sure that composition can never be stalled by a virtual display
2394 // consumer that isn't processing buffers fast enough. We have to do this
Alec Mouri0a9c7b82018-11-16 13:05:25 -08002395 // here, in case the display is composed entirely by HWC.
Dominik Laskowski281644e2018-04-19 15:47:35 -07002396 if (state.isVirtual()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002397 nativeWindow->setSwapInterval(nativeWindow.get(), 0);
2398 }
2399
Dominik Laskowski075d3172018-05-24 15:50:06 -07002400 creationArgs.displayInstallOrientation =
2401 isInternalDisplay ? primaryDisplayOrientation : DisplayState::eOrientationDefault;
Chia-I Wua02871c2018-08-27 14:38:23 -07002402
Lloyd Pique99d3da52018-01-22 17:48:03 -08002403 // virtual displays are always considered enabled
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002404 creationArgs.initialPowerMode = state.isVirtual() ? HWC_POWER_MODE_NORMAL : HWC_POWER_MODE_OFF;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002405
Lloyd Pique90c115d2018-09-18 21:39:42 -07002406 sp<DisplayDevice> display = getFactory().createDisplayDevice(std::move(creationArgs));
Lloyd Pique99d3da52018-01-22 17:48:03 -08002407
2408 if (maxFrameBufferAcquiredBuffers >= 3) {
2409 nativeWindowSurface->preallocateBuffers();
2410 }
2411
2412 ColorMode defaultColorMode = ColorMode::NATIVE;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002413 Dataspace defaultDataSpace = Dataspace::UNKNOWN;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002414 if (display->hasWideColorGamut()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002415 defaultColorMode = ColorMode::SRGB;
Peiyong Lin14724e62018-12-05 07:27:30 -08002416 defaultDataSpace = Dataspace::V0_SRGB;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002417 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002418 setActiveColorModeInternal(display, defaultColorMode, defaultDataSpace,
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002419 RenderIntent::COLORIMETRIC);
Dominik Laskowski075d3172018-05-24 15:50:06 -07002420 if (!state.isVirtual()) {
2421 LOG_ALWAYS_FATAL_IF(!displayId);
2422 display->setActiveConfig(getHwComposer().getActiveConfigIndex(*displayId));
Lloyd Pique3c085a02018-05-09 19:38:32 -07002423 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07002424
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002425 display->setLayerStack(state.layerStack);
2426 display->setProjection(state.orientation, state.viewport, state.frame);
2427 display->setDisplayName(state.displayName);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002428
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002429 return display;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002430}
2431
Lloyd Pique347200f2017-12-14 17:00:15 -08002432void SurfaceFlinger::processDisplayChangesLocked() {
2433 // here we take advantage of Vector's copy-on-write semantics to
2434 // improve performance by skipping the transaction entirely when
2435 // know that the lists are identical
2436 const KeyedVector<wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
2437 const KeyedVector<wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
2438 if (!curr.isIdenticalTo(draw)) {
2439 mVisibleRegionsDirty = true;
2440 const size_t cc = curr.size();
2441 size_t dc = draw.size();
2442
2443 // find the displays that were removed
2444 // (ie: in drawing state but not in current state)
2445 // also handle displays that changed
2446 // (ie: displays that are in both lists)
2447 for (size_t i = 0; i < dc;) {
2448 const ssize_t j = curr.indexOfKey(draw.keyAt(i));
2449 if (j < 0) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002450 // Save display IDs before disconnecting.
2451 const auto internalDisplayId = getInternalDisplayId();
2452 const auto externalDisplayId = getExternalDisplayId();
2453
Lloyd Pique347200f2017-12-14 17:00:15 -08002454 // in drawing state but not in current state
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002455 if (const auto display = getDisplayDeviceLocked(draw.keyAt(i))) {
2456 display->disconnect(getHwComposer());
2457 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07002458 if (internalDisplayId && internalDisplayId == draw[i].displayId) {
Ana Krulec98b5b242018-08-10 15:03:23 -07002459 if (mUseScheduler) {
2460 mScheduler->hotplugReceived(mAppConnectionHandle,
2461 EventThread::DisplayType::Primary, false);
2462 } else {
2463 mEventThread->onHotplugReceived(EventThread::DisplayType::Primary, false);
2464 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07002465 } else if (externalDisplayId && externalDisplayId == draw[i].displayId) {
Ana Krulec98b5b242018-08-10 15:03:23 -07002466 if (mUseScheduler) {
2467 mScheduler->hotplugReceived(mAppConnectionHandle,
2468 EventThread::DisplayType::External, false);
2469 } else {
2470 mEventThread->onHotplugReceived(EventThread::DisplayType::External, false);
2471 }
Dominik Laskowski00a6fa22018-06-06 16:42:02 -07002472 }
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002473 mDisplays.erase(draw.keyAt(i));
Lloyd Pique347200f2017-12-14 17:00:15 -08002474 } else {
2475 // this display is in both lists. see if something changed.
2476 const DisplayDeviceState& state(curr[j]);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002477 const wp<IBinder>& displayToken = curr.keyAt(j);
Lloyd Pique347200f2017-12-14 17:00:15 -08002478 const sp<IBinder> state_binder = IInterface::asBinder(state.surface);
2479 const sp<IBinder> draw_binder = IInterface::asBinder(draw[i].surface);
2480 if (state_binder != draw_binder) {
2481 // changing the surface is like destroying and
2482 // recreating the DisplayDevice, so we just remove it
2483 // from the drawing state, so that it get re-added
2484 // below.
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002485 if (const auto display = getDisplayDeviceLocked(displayToken)) {
2486 display->disconnect(getHwComposer());
2487 }
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002488 mDisplays.erase(displayToken);
Lloyd Pique347200f2017-12-14 17:00:15 -08002489 mDrawingState.displays.removeItemsAt(i);
2490 dc--;
2491 // at this point we must loop to the next item
2492 continue;
2493 }
2494
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002495 if (const auto display = getDisplayDeviceLocked(displayToken)) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002496 if (state.layerStack != draw[i].layerStack) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002497 display->setLayerStack(state.layerStack);
Lloyd Pique347200f2017-12-14 17:00:15 -08002498 }
2499 if ((state.orientation != draw[i].orientation) ||
2500 (state.viewport != draw[i].viewport) || (state.frame != draw[i].frame)) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002501 display->setProjection(state.orientation, state.viewport, state.frame);
Lloyd Pique347200f2017-12-14 17:00:15 -08002502 }
2503 if (state.width != draw[i].width || state.height != draw[i].height) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002504 display->setDisplaySize(state.width, state.height);
Lloyd Pique347200f2017-12-14 17:00:15 -08002505 }
2506 }
2507 }
2508 ++i;
2509 }
2510
2511 // find displays that were added
2512 // (ie: in current state but not in drawing state)
2513 for (size_t i = 0; i < cc; i++) {
2514 if (draw.indexOfKey(curr.keyAt(i)) < 0) {
2515 const DisplayDeviceState& state(curr[i]);
2516
2517 sp<DisplaySurface> dispSurface;
2518 sp<IGraphicBufferProducer> producer;
2519 sp<IGraphicBufferProducer> bqProducer;
2520 sp<IGraphicBufferConsumer> bqConsumer;
Lloyd Pique90c115d2018-09-18 21:39:42 -07002521 getFactory().createBufferQueue(&bqProducer, &bqConsumer, false);
Lloyd Pique347200f2017-12-14 17:00:15 -08002522
Dominik Laskowski075d3172018-05-24 15:50:06 -07002523 std::optional<DisplayId> displayId;
Dominik Laskowski663bd282018-04-19 15:26:54 -07002524 if (state.isVirtual()) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002525 // Virtual displays without a surface are dormant:
2526 // they have external state (layer stack, projection,
2527 // etc.) but no internal state (i.e. a DisplayDevice).
2528 if (state.surface != nullptr) {
2529 // Allow VR composer to use virtual displays.
Dominik Laskowski075d3172018-05-24 15:50:06 -07002530 if (mUseHwcVirtualDisplays || getHwComposer().isUsingVrComposer()) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002531 int width = 0;
2532 int status = state.surface->query(NATIVE_WINDOW_WIDTH, &width);
2533 ALOGE_IF(status != NO_ERROR, "Unable to query width (%d)", status);
2534 int height = 0;
2535 status = state.surface->query(NATIVE_WINDOW_HEIGHT, &height);
2536 ALOGE_IF(status != NO_ERROR, "Unable to query height (%d)", status);
2537 int intFormat = 0;
2538 status = state.surface->query(NATIVE_WINDOW_FORMAT, &intFormat);
2539 ALOGE_IF(status != NO_ERROR, "Unable to query format (%d)", status);
Peiyong Lin34beb7a2018-03-28 11:57:12 -07002540 auto format = static_cast<ui::PixelFormat>(intFormat);
Lloyd Pique347200f2017-12-14 17:00:15 -08002541
Dominik Laskowski075d3172018-05-24 15:50:06 -07002542 displayId =
2543 getHwComposer().allocateVirtualDisplay(width, height, &format);
Lloyd Pique347200f2017-12-14 17:00:15 -08002544 }
2545
2546 // TODO: Plumb requested format back up to consumer
2547
2548 sp<VirtualDisplaySurface> vds =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002549 new VirtualDisplaySurface(getHwComposer(), displayId, state.surface,
Lloyd Pique347200f2017-12-14 17:00:15 -08002550 bqProducer, bqConsumer,
2551 state.displayName);
2552
2553 dispSurface = vds;
2554 producer = vds;
2555 }
2556 } else {
2557 ALOGE_IF(state.surface != nullptr,
2558 "adding a supported display, but rendering "
2559 "surface is provided (%p), ignoring it",
2560 state.surface.get());
2561
Dominik Laskowski075d3172018-05-24 15:50:06 -07002562 displayId = state.displayId;
2563 LOG_ALWAYS_FATAL_IF(!displayId);
2564 dispSurface = new FramebufferSurface(getHwComposer(), *displayId, bqConsumer);
Lloyd Pique347200f2017-12-14 17:00:15 -08002565 producer = bqProducer;
2566 }
2567
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002568 const wp<IBinder>& displayToken = curr.keyAt(i);
Lloyd Pique347200f2017-12-14 17:00:15 -08002569 if (dispSurface != nullptr) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002570 mDisplays.emplace(displayToken,
Dominik Laskowski7e045462018-05-30 13:02:02 -07002571 setupNewDisplayDeviceInternal(displayToken, displayId, state,
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002572 dispSurface, producer));
Dominik Laskowski663bd282018-04-19 15:26:54 -07002573 if (!state.isVirtual()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002574 LOG_ALWAYS_FATAL_IF(!displayId);
2575
2576 if (displayId == getInternalDisplayId()) {
Ana Krulec98b5b242018-08-10 15:03:23 -07002577 if (mUseScheduler) {
2578 mScheduler->hotplugReceived(mAppConnectionHandle,
2579 EventThread::DisplayType::Primary,
Dominik Laskowski00a6fa22018-06-06 16:42:02 -07002580 true);
Ana Krulec98b5b242018-08-10 15:03:23 -07002581 } else {
2582 mEventThread->onHotplugReceived(EventThread::DisplayType::Primary,
2583 true);
2584 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07002585 } else if (displayId == getExternalDisplayId()) {
Ana Krulec98b5b242018-08-10 15:03:23 -07002586 if (mUseScheduler) {
2587 mScheduler->hotplugReceived(mAppConnectionHandle,
2588 EventThread::DisplayType::External,
Dominik Laskowski00a6fa22018-06-06 16:42:02 -07002589 true);
Ana Krulec98b5b242018-08-10 15:03:23 -07002590 } else {
2591 mEventThread->onHotplugReceived(EventThread::DisplayType::External,
2592 true);
2593 }
Dominik Laskowski00a6fa22018-06-06 16:42:02 -07002594 }
Lloyd Pique347200f2017-12-14 17:00:15 -08002595 }
2596 }
2597 }
2598 }
2599 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08002600
2601 mDrawingState.displays = mCurrentState.displays;
Lloyd Pique347200f2017-12-14 17:00:15 -08002602}
2603
Mathias Agopian87baae12012-07-31 12:38:26 -07002604void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
Mathias Agopian3d579642009-06-04 18:46:21 -07002605{
Dan Stoza7dde5992015-05-22 09:51:44 -07002606 // Notify all layers of available frames
Robert Carr2047fae2016-11-28 14:09:09 -08002607 mCurrentState.traverseInZOrder([](Layer* layer) {
2608 layer->notifyAvailableFrames();
2609 });
Dan Stoza7dde5992015-05-22 09:51:44 -07002610
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002611 /*
2612 * Traversal of the children
2613 * (perform the transaction for each of them if needed)
2614 */
2615
Robert Carr720e5062018-07-30 17:45:14 -07002616 bool inputChanged = false;
Mathias Agopian3559b072012-08-15 13:46:03 -07002617 if (transactionFlags & eTraversalNeeded) {
Robert Carr2047fae2016-11-28 14:09:09 -08002618 mCurrentState.traverseInZOrder([&](Layer* layer) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002619 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
Robert Carr2047fae2016-11-28 14:09:09 -08002620 if (!trFlags) return;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002621
2622 const uint32_t flags = layer->doTransaction(0);
2623 if (flags & Layer::eVisibleRegion)
2624 mVisibleRegionsDirty = true;
Robert Carr720e5062018-07-30 17:45:14 -07002625
2626 if (flags & Layer::eInputInfoChanged) {
2627 inputChanged = true;
2628 }
Robert Carr2047fae2016-11-28 14:09:09 -08002629 });
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002630 }
2631
2632 /*
Mathias Agopian3559b072012-08-15 13:46:03 -07002633 * Perform display own transactions if needed
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002634 */
2635
Mathias Agopiane57f2922012-08-09 16:29:12 -07002636 if (transactionFlags & eDisplayTransactionNeeded) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002637 processDisplayChangesLocked();
Lloyd Piqueba04e622017-12-14 17:11:26 -08002638 processDisplayHotplugEventsLocked();
Mathias Agopian3559b072012-08-15 13:46:03 -07002639 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002640
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002641 if (transactionFlags & (eDisplayLayerStackChanged|eDisplayTransactionNeeded)) {
Mathias Agopian84300952012-11-21 16:02:13 -08002642 // The transform hint might have changed for some layers
2643 // (either because a display has changed, or because a layer
2644 // as changed).
2645 //
2646 // Walk through all the layers in currentLayers,
2647 // and update their transform hint.
2648 //
2649 // If a layer is visible only on a single display, then that
2650 // display is used to calculate the hint, otherwise we use the
2651 // default display.
2652 //
2653 // NOTE: we do this here, rather than in rebuildLayerStacks() so that
2654 // the hint is set before we acquire a buffer from the surface texture.
2655 //
2656 // NOTE: layer transactions have taken place already, so we use their
2657 // drawing state. However, SurfaceFlinger's own transaction has not
2658 // happened yet, so we must use the current state layer list
2659 // (soon to become the drawing state list).
2660 //
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002661 sp<const DisplayDevice> hintDisplay;
Mathias Agopian84300952012-11-21 16:02:13 -08002662 uint32_t currentlayerStack = 0;
Robert Carr2047fae2016-11-28 14:09:09 -08002663 bool first = true;
2664 mCurrentState.traverseInZOrder([&](Layer* layer) {
Mathias Agopian84300952012-11-21 16:02:13 -08002665 // NOTE: we rely on the fact that layers are sorted by
2666 // layerStack first (so we don't have to traverse the list
2667 // of displays for every layer).
Robert Carr1f0a16a2016-10-24 16:27:39 -07002668 uint32_t layerStack = layer->getLayerStack();
Robert Carr2047fae2016-11-28 14:09:09 -08002669 if (first || currentlayerStack != layerStack) {
Mathias Agopian84300952012-11-21 16:02:13 -08002670 currentlayerStack = layerStack;
2671 // figure out if this layerstack is mirrored
2672 // (more than one display) if so, pick the default display,
2673 // if not, pick the only display it's on.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002674 hintDisplay = nullptr;
2675 for (const auto& [token, display] : mDisplays) {
2676 if (layer->belongsToDisplay(display->getLayerStack(), display->isPrimary())) {
2677 if (hintDisplay) {
2678 hintDisplay = nullptr;
Mathias Agopian84300952012-11-21 16:02:13 -08002679 break;
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002680 } else {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002681 hintDisplay = display;
Mathias Agopian84300952012-11-21 16:02:13 -08002682 }
2683 }
2684 }
2685 }
Chet Haase91d25932013-04-11 15:24:55 -07002686
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002687 if (!hintDisplay) {
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002688 // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
2689 // redraw after transform hint changes. See bug 8508397.
Robert Carr56a0b9a2017-12-04 16:06:13 -08002690
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002691 // could be null when this layer is using a layerStack
2692 // that is not visible on any display. Also can occur at
2693 // screen off/on times.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002694 hintDisplay = getDefaultDisplayDeviceLocked();
Mathias Agopian84300952012-11-21 16:02:13 -08002695 }
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002696
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002697 // could be null if there is no display available at all to get
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002698 // the transform hint from.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002699 if (hintDisplay) {
2700 layer->updateTransformHint(hintDisplay);
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08002701 }
Robert Carr2047fae2016-11-28 14:09:09 -08002702
2703 first = false;
2704 });
Mathias Agopian84300952012-11-21 16:02:13 -08002705 }
2706
2707
Mathias Agopian3559b072012-08-15 13:46:03 -07002708 /*
2709 * Perform our own transaction if needed
2710 */
Robert Carr1f0a16a2016-10-24 16:27:39 -07002711
2712 if (mLayersAdded) {
2713 mLayersAdded = false;
2714 // Layers have been added.
Mathias Agopian3559b072012-08-15 13:46:03 -07002715 mVisibleRegionsDirty = true;
2716 }
2717
2718 // some layers might have been removed, so
2719 // we need to update the regions they're exposing.
2720 if (mLayersRemoved) {
2721 mLayersRemoved = false;
2722 mVisibleRegionsDirty = true;
Robert Carr2047fae2016-11-28 14:09:09 -08002723 mDrawingState.traverseInZOrder([&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07002724 if (mLayersPendingRemoval.indexOf(layer) >= 0) {
Mathias Agopian3559b072012-08-15 13:46:03 -07002725 // this layer is not visible anymore
2726 // TODO: we could traverse the tree from front to back and
2727 // compute the actual visible region
2728 // TODO: we could cache the transformed region
Robert Carr1f0a16a2016-10-24 16:27:39 -07002729 Region visibleReg;
2730 visibleReg.set(layer->computeScreenBounds());
Chia-I Wuab0c3192017-08-01 11:29:00 -07002731 invalidateLayerStack(layer, visibleReg);
Mathias Agopian0aa758d2009-04-22 15:23:34 -07002732 }
Robert Carr2047fae2016-11-28 14:09:09 -08002733 });
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002734 }
2735
2736 commitTransaction();
Riley Andrews03414a12014-07-01 14:22:59 -07002737
Vishnu Nairde19f852018-12-18 16:11:53 -08002738 if (inputChanged || mVisibleRegionsDirty) {
Robert Carr720e5062018-07-30 17:45:14 -07002739 updateInputWindows();
2740 }
2741
Riley Andrews03414a12014-07-01 14:22:59 -07002742 updateCursorAsync();
2743}
2744
Robert Carr720e5062018-07-30 17:45:14 -07002745void SurfaceFlinger::updateInputWindows() {
2746 ATRACE_CALL();
2747
Vishnu Nairde19f852018-12-18 16:11:53 -08002748 if (mInputFlinger == nullptr) {
2749 return;
2750 }
2751
Robert Carr720e5062018-07-30 17:45:14 -07002752 Vector<InputWindowInfo> inputHandles;
2753
2754 mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
2755 if (layer->hasInput()) {
Vishnu Nair51625fa2018-12-06 13:54:33 -08002756 // When calculating the screen bounds we ignore the transparent region since it may
2757 // result in an unwanted offset.
2758 inputHandles.add(layer->fillInputInfo(
2759 layer->computeScreenBounds(false /* reduceTransparentRegion */)));
Robert Carr720e5062018-07-30 17:45:14 -07002760 }
2761 });
2762 mInputFlinger->setInputWindows(inputHandles);
2763}
2764
Riley Andrews03414a12014-07-01 14:22:59 -07002765void SurfaceFlinger::updateCursorAsync()
2766{
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002767 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002768 if (!display->getId()) {
Riley Andrews03414a12014-07-01 14:22:59 -07002769 continue;
2770 }
Dan Stoza9e56aa02015-11-02 13:00:03 -08002771
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002772 for (auto& layer : display->getVisibleLayersSortedByZ()) {
2773 layer->updateCursorPosition(display);
Riley Andrews03414a12014-07-01 14:22:59 -07002774 }
2775 }
Mathias Agopian4fec8732012-06-29 14:12:52 -07002776}
2777
chaviw61626f22018-11-15 16:26:27 -08002778void SurfaceFlinger::latchAndReleaseBuffer(const sp<Layer>& layer) {
2779 if (layer->hasReadyFrame()) {
2780 const nsecs_t expectedPresentTime = mPrimaryDispSync->expectedPresentTime();
2781 if (layer->shouldPresentNow(expectedPresentTime)) {
2782 bool ignored = false;
2783 layer->latchBuffer(ignored, systemTime(), Fence::NO_FENCE);
2784 }
2785 }
2786 layer->releasePendingBuffer(systemTime());
2787}
2788
Mathias Agopian4fec8732012-06-29 14:12:52 -07002789void SurfaceFlinger::commitTransaction()
2790{
Steve Pfetsch598f6d52016-10-25 21:47:58 +00002791 if (!mLayersPendingRemoval.isEmpty()) {
Mathias Agopian4fec8732012-06-29 14:12:52 -07002792 // Notify removed layers now that they can't be drawn from
Robert Carr1f0a16a2016-10-24 16:27:39 -07002793 for (const auto& l : mLayersPendingRemoval) {
2794 recordBufferingStats(l->getName().string(),
2795 l->getOccupancyHistory(true));
Robert Carr2e102c92018-10-23 12:11:15 -07002796
2797 // We need to release the HWC layers when the Layer is removed
2798 // from the current state otherwise the HWC layer just continues
2799 // showing at its last configured state until we eventually
2800 // abandon the buffer queue.
2801 if (l->isRemovedFromCurrentState()) {
Robert Carr3aee9892018-11-07 12:53:41 -08002802 l->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* child) {
chaviw61626f22018-11-15 16:26:27 -08002803 child->destroyHwcLayersForAllDisplays();
2804 latchAndReleaseBuffer(child);
Robert Carr3aee9892018-11-07 12:53:41 -08002805 });
Robert Carr2e102c92018-10-23 12:11:15 -07002806 }
Mathias Agopian4fec8732012-06-29 14:12:52 -07002807 }
2808 mLayersPendingRemoval.clear();
2809 }
2810
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002811 // If this transaction is part of a window animation then the next frame
2812 // we composite should be considered an animation as well.
2813 mAnimCompositionPending = mAnimTransactionPending;
2814
Mathias Agopian4fec8732012-06-29 14:12:52 -07002815 mDrawingState = mCurrentState;
Chia-I Wu28f320b2018-05-03 11:02:56 -07002816 // clear the "changed" flags in current state
2817 mCurrentState.colorMatrixChanged = false;
2818
Robert Carr1f0a16a2016-10-24 16:27:39 -07002819 mDrawingState.traverseInZOrder([](Layer* layer) {
2820 layer->commitChildList();
2821 });
Jamie Gennis2d5e2302012-10-15 18:24:43 -07002822 mTransactionPending = false;
2823 mAnimTransactionPending = false;
Mathias Agopian4fec8732012-06-29 14:12:52 -07002824 mTransactionCV.broadcast();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002825}
2826
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002827void SurfaceFlinger::computeVisibleRegions(const sp<const DisplayDevice>& display,
2828 Region& outDirtyRegion, Region& outOpaqueRegion) {
Mathias Agopian841cde52012-03-01 15:44:37 -08002829 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08002830 ALOGV("computeVisibleRegions");
Mathias Agopian841cde52012-03-01 15:44:37 -08002831
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002832 Region aboveOpaqueLayers;
2833 Region aboveCoveredLayers;
2834 Region dirty;
2835
Mathias Agopian87baae12012-07-31 12:38:26 -07002836 outDirtyRegion.clear();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002837
Robert Carr2047fae2016-11-28 14:09:09 -08002838 mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
Jesse Hall01e29052013-02-19 16:13:35 -08002839 // only consider the layers on the given layer stack
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002840 if (!layer->belongsToDisplay(display->getLayerStack(), display->isPrimary())) {
Robert Carr2047fae2016-11-28 14:09:09 -08002841 return;
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002842 }
Mathias Agopian87baae12012-07-31 12:38:26 -07002843
Mathias Agopianab028732010-03-16 16:41:46 -07002844 /*
2845 * opaqueRegion: area of a surface that is fully opaque.
2846 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002847 Region opaqueRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07002848
2849 /*
2850 * visibleRegion: area of a surface that is visible on screen
2851 * and not fully transparent. This is essentially the layer's
2852 * footprint minus the opaque regions above it.
2853 * Areas covered by a translucent surface are considered visible.
2854 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002855 Region visibleRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07002856
2857 /*
2858 * coveredRegion: area of a surface that is covered by all
2859 * visible regions above it (which includes the translucent areas).
2860 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002861 Region coveredRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07002862
Jesse Halla8026d22012-09-25 13:25:04 -07002863 /*
2864 * transparentRegion: area of a surface that is hinted to be completely
2865 * transparent. This is only used to tell when the layer has no visible
2866 * non-transparent regions and can be removed from the layer list. It
2867 * does not affect the visibleRegion of this layer or any layers
2868 * beneath it. The hint may not be correct if apps don't respect the
2869 * SurfaceView restrictions (which, sadly, some don't).
2870 */
2871 Region transparentRegion;
2872
Mathias Agopianab028732010-03-16 16:41:46 -07002873
2874 // handle hidden surfaces by setting the visible region to empty
Mathias Agopianda27af92012-09-13 18:17:13 -07002875 if (CC_LIKELY(layer->isVisible())) {
Ady Abraham83729882018-12-07 12:26:48 -08002876 const bool translucent = !layer->isDrawingOpaque();
Robert Carr1f0a16a2016-10-24 16:27:39 -07002877 Rect bounds(layer->computeScreenBounds());
Robert Carr720e5062018-07-30 17:45:14 -07002878
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002879 visibleRegion.set(bounds);
Peiyong Linefefaac2018-08-17 12:27:51 -07002880 ui::Transform tr = layer->getTransform();
Mathias Agopianab028732010-03-16 16:41:46 -07002881 if (!visibleRegion.isEmpty()) {
2882 // Remove the transparent area from the visible region
2883 if (translucent) {
Dan Stoza22f7fc42016-05-10 16:19:53 -07002884 if (tr.preserveRects()) {
2885 // transform the transparent region
Ady Abraham83729882018-12-07 12:26:48 -08002886 transparentRegion =
2887 tr.transform(layer->getDrawingActiveTransparentRegion());
Mathias Agopian4fec8732012-06-29 14:12:52 -07002888 } else {
Dan Stoza22f7fc42016-05-10 16:19:53 -07002889 // transformation too complex, can't do the
2890 // transparent region optimization.
2891 transparentRegion.clear();
Mathias Agopian4fec8732012-06-29 14:12:52 -07002892 }
Mathias Agopianab028732010-03-16 16:41:46 -07002893 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002894
Mathias Agopianab028732010-03-16 16:41:46 -07002895 // compute the opaque region
Robert Carr1f0a16a2016-10-24 16:27:39 -07002896 const int32_t layerOrientation = tr.getOrientation();
Jorim Jaggi039bbb82017-09-06 18:12:05 +02002897 if (layer->getAlpha() == 1.0f && !translucent &&
Lucas Dupin1b6531c2018-07-05 17:18:21 -07002898 layer->getRoundedCornerState().radius == 0.0f &&
Peiyong Linefefaac2018-08-17 12:27:51 -07002899 ((layerOrientation & ui::Transform::ROT_INVALID) == false)) {
Mathias Agopianab028732010-03-16 16:41:46 -07002900 // the opaque region is the layer's footprint
2901 opaqueRegion = visibleRegion;
2902 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002903 }
2904 }
2905
Robert Carre5f4f692018-01-12 13:12:28 -08002906 if (visibleRegion.isEmpty()) {
2907 layer->clearVisibilityRegions();
2908 return;
2909 }
2910
Mathias Agopianab028732010-03-16 16:41:46 -07002911 // Clip the covered region to the visible region
2912 coveredRegion = aboveCoveredLayers.intersect(visibleRegion);
2913
2914 // Update aboveCoveredLayers for next (lower) layer
2915 aboveCoveredLayers.orSelf(visibleRegion);
2916
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002917 // subtract the opaque region covered by the layers above us
2918 visibleRegion.subtractSelf(aboveOpaqueLayers);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002919
2920 // compute this layer's dirty region
2921 if (layer->contentDirty) {
2922 // we need to invalidate the whole region
2923 dirty = visibleRegion;
2924 // as well, as the old visible region
Mathias Agopian4fec8732012-06-29 14:12:52 -07002925 dirty.orSelf(layer->visibleRegion);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002926 layer->contentDirty = false;
2927 } else {
Mathias Agopiana8d44f72009-06-28 02:54:16 -07002928 /* compute the exposed region:
Mathias Agopianab028732010-03-16 16:41:46 -07002929 * the exposed region consists of two components:
2930 * 1) what's VISIBLE now and was COVERED before
2931 * 2) what's EXPOSED now less what was EXPOSED before
2932 *
2933 * note that (1) is conservative, we start with the whole
2934 * visible region but only keep what used to be covered by
2935 * something -- which mean it may have been exposed.
2936 *
2937 * (2) handles areas that were not covered by anything but got
2938 * exposed because of a resize.
Mathias Agopiana8d44f72009-06-28 02:54:16 -07002939 */
Mathias Agopianab028732010-03-16 16:41:46 -07002940 const Region newExposed = visibleRegion - coveredRegion;
Mathias Agopian4fec8732012-06-29 14:12:52 -07002941 const Region oldVisibleRegion = layer->visibleRegion;
2942 const Region oldCoveredRegion = layer->coveredRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07002943 const Region oldExposed = oldVisibleRegion - oldCoveredRegion;
2944 dirty = (visibleRegion&oldCoveredRegion) | (newExposed-oldExposed);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002945 }
2946 dirty.subtractSelf(aboveOpaqueLayers);
2947
2948 // accumulate to the screen dirty region
Mathias Agopian87baae12012-07-31 12:38:26 -07002949 outDirtyRegion.orSelf(dirty);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002950
Mathias Agopianab028732010-03-16 16:41:46 -07002951 // Update aboveOpaqueLayers for next (lower) layer
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002952 aboveOpaqueLayers.orSelf(opaqueRegion);
Andreas Huber8b42e8a2010-08-16 08:49:37 -07002953
Jesse Halla8026d22012-09-25 13:25:04 -07002954 // Store the visible region in screen space
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002955 layer->setVisibleRegion(visibleRegion);
2956 layer->setCoveredRegion(coveredRegion);
Jesse Halla8026d22012-09-25 13:25:04 -07002957 layer->setVisibleNonTransparentRegion(
2958 visibleRegion.subtract(transparentRegion));
Robert Carr2047fae2016-11-28 14:09:09 -08002959 });
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002960
Mathias Agopian87baae12012-07-31 12:38:26 -07002961 outOpaqueRegion = aboveOpaqueLayers;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002962}
2963
Chia-I Wuab0c3192017-08-01 11:29:00 -07002964void SurfaceFlinger::invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002965 for (const auto& [token, display] : mDisplays) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002966 if (layer->belongsToDisplay(display->getLayerStack(), display->isPrimary())) {
2967 display->dirtyRegion.orSelf(dirty);
Mathias Agopian92a979a2012-08-02 18:32:23 -07002968 }
2969 }
Mathias Agopian87baae12012-07-31 12:38:26 -07002970}
2971
Dan Stoza6b9454d2014-11-07 16:00:59 -08002972bool SurfaceFlinger::handlePageFlip()
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002973{
Dan Stoza9e56aa02015-11-02 13:00:03 -08002974 ALOGV("handlePageFlip");
2975
Brian Andersond6927fb2016-07-23 23:37:30 -07002976 nsecs_t latchTime = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002977
Mathias Agopian4fec8732012-06-29 14:12:52 -07002978 bool visibleRegions = false;
Dan Stoza6b9454d2014-11-07 16:00:59 -08002979 bool frameQueued = false;
Mike Stroyan0cd76192017-04-20 12:10:48 -06002980 bool newDataLatched = false;
Eric Penner51c59cd2014-07-28 19:51:58 -07002981
2982 // Store the set of layers that need updates. This set must not change as
2983 // buffers are being latched, as this could result in a deadlock.
2984 // Example: Two producers share the same command stream and:
2985 // 1.) Layer 0 is latched
2986 // 2.) Layer 0 gets a new frame
2987 // 2.) Layer 1 gets a new frame
2988 // 3.) Layer 1 is latched.
2989 // Display is now waiting on Layer 1's frame, which is behind layer 0's
2990 // second frame. But layer 0's second frame could be waiting on display.
Robert Carr2047fae2016-11-28 14:09:09 -08002991 mDrawingState.traverseInZOrder([&](Layer* layer) {
Marissa Wallfd668622018-05-10 10:21:13 -07002992 if (layer->hasReadyFrame()) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08002993 frameQueued = true;
Ana Krulec010d2192018-10-08 06:29:54 -07002994 const nsecs_t expectedPresentTime = mPrimaryDispSync->expectedPresentTime();
2995 if (layer->shouldPresentNow(expectedPresentTime)) {
Robert Carr2047fae2016-11-28 14:09:09 -08002996 mLayersWithQueuedFrames.push_back(layer);
Dan Stozaee44edd2015-03-23 15:50:23 -07002997 } else {
2998 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08002999 }
Dan Stozaee44edd2015-03-23 15:50:23 -07003000 } else {
3001 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08003002 }
Robert Carr2047fae2016-11-28 14:09:09 -08003003 });
3004
Lloyd Piquef2c79392018-12-20 16:23:33 -08003005 if (!mLayersWithQueuedFrames.empty()) {
3006 // mStateLock is needed for latchBuffer as LayerRejecter::reject()
3007 // writes to Layer current state. See also b/119481871
3008 Mutex::Autolock lock(mStateLock);
3009
3010 for (auto& layer : mLayersWithQueuedFrames) {
3011 const Region dirty(layer->latchBuffer(visibleRegions, latchTime, getBE().flushFence));
3012 layer->useSurfaceDamage();
3013 invalidateLayerStack(layer, dirty);
3014 if (layer->isBufferLatched()) {
3015 newDataLatched = true;
3016 }
Mike Stroyan0cd76192017-04-20 12:10:48 -06003017 }
Mathias Agopian4fec8732012-06-29 14:12:52 -07003018 }
Mathias Agopian4da75192010-08-10 17:19:56 -07003019
Alec Mouri86770e52018-09-24 22:40:58 +00003020 // Clear the renderengine fence here...
3021 // downstream code assumes that a cleared fence == NO_FENCE, so reassign to
3022 // clear instead of sp::clear.
3023 getBE().flushFence = Fence::NO_FENCE;
3024
Mathias Agopian3b1d2b62012-07-11 13:48:17 -07003025 mVisibleRegionsDirty |= visibleRegions;
Dan Stoza6b9454d2014-11-07 16:00:59 -08003026
Vishnu Nairde19f852018-12-18 16:11:53 -08003027 if (visibleRegions) {
3028 // Update input window info if the layer receives its first buffer.
3029 updateInputWindows();
3030 }
3031
Dan Stoza6b9454d2014-11-07 16:00:59 -08003032 // If we will need to wake up at some time in the future to deal with a
3033 // queued frame that shouldn't be displayed during this vsync period, wake
3034 // up during the next vsync period to check again.
Chia-I Wua36bf922017-06-30 12:51:05 -07003035 if (frameQueued && (mLayersWithQueuedFrames.empty() || !newDataLatched)) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08003036 signalLayerUpdate();
3037 }
3038
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08003039 // enter boot animation on first buffer latch
3040 if (CC_UNLIKELY(mBootStage == BootStage::BOOTLOADER && newDataLatched)) {
3041 ALOGI("Enter boot animation");
3042 mBootStage = BootStage::BOOTANIMATION;
3043 }
3044
Dan Stoza6b9454d2014-11-07 16:00:59 -08003045 // Only continue with the refresh if there is actually new work to do
Mike Stroyan0cd76192017-04-20 12:10:48 -06003046 return !mLayersWithQueuedFrames.empty() && newDataLatched;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003047}
3048
Mathias Agopianad456f92011-01-13 17:53:01 -08003049void SurfaceFlinger::invalidateHwcGeometry()
3050{
Dan Stoza9e56aa02015-11-02 13:00:03 -08003051 mGeometryInvalid = true;
Mathias Agopianad456f92011-01-13 17:53:01 -08003052}
3053
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003054void SurfaceFlinger::doDisplayComposition(const sp<DisplayDevice>& display,
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003055 const Region& inDirtyRegion) {
Dan Stoza71433162014-02-04 16:22:36 -08003056 // We only need to actually compose the display if:
3057 // 1) It is being handled by hardware composer, which may need this to
3058 // keep its virtual display state machine in sync, or
3059 // 2) There is work to be done (the dirty region isn't empty)
Dominik Laskowski34157762018-10-31 13:07:19 -07003060 if (!display->getId() && inDirtyRegion.isEmpty()) {
Dan Stoza9e56aa02015-11-02 13:00:03 -08003061 ALOGV("Skipping display composition");
Dan Stoza71433162014-02-04 16:22:36 -08003062 return;
3063 }
3064
Dan Stoza9e56aa02015-11-02 13:00:03 -08003065 ALOGV("doDisplayComposition");
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003066 if (!doComposeSurfaces(display)) return;
Mathias Agopianda27af92012-09-13 18:17:13 -07003067
3068 // swap buffers (presentation)
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003069 display->queueBuffer(getHwComposer());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003070}
3071
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003072bool SurfaceFlinger::doComposeSurfaces(const sp<DisplayDevice>& display) {
Dan Stoza9e56aa02015-11-02 13:00:03 -08003073 ALOGV("doComposeSurfaces");
Mathias Agopiancd20eb02011-09-22 20:57:04 -07003074
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003075 const Region bounds(display->bounds());
3076 const DisplayRenderArea renderArea(display);
Dominik Laskowski7e045462018-05-30 13:02:02 -07003077 const auto displayId = display->getId();
3078 const bool hasClientComposition = getBE().mHwc->hasClientComposition(displayId);
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08003079 ATRACE_INT("hasClientComposition", hasClientComposition);
Dan Stoza9f26a9c2016-06-22 14:51:09 -07003080
Peiyong Lind3788632018-09-18 16:01:31 -07003081 mat4 colorMatrix;
Chia-I Wu8e50e692018-05-04 10:12:37 -07003082 bool applyColorMatrix = false;
Dan Stoza9f26a9c2016-06-22 14:51:09 -07003083
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003084 // Framebuffer will live in this scope for GPU composition.
3085 std::unique_ptr<renderengine::BindNativeBufferAsFramebuffer> fbo;
3086
Dan Stoza9e56aa02015-11-02 13:00:03 -08003087 if (hasClientComposition) {
3088 ALOGV("hasClientComposition");
3089
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003090 sp<GraphicBuffer> buf = display->dequeueBuffer();
3091
3092 if (buf == nullptr) {
3093 ALOGW("Dequeuing buffer for display [%s] failed, bailing out of "
3094 "client composition for this frame",
3095 display->getDisplayName().c_str());
3096 return false;
3097 }
3098
3099 // Bind the framebuffer in this scope.
3100 fbo = std::make_unique<renderengine::BindNativeBufferAsFramebuffer>(getRenderEngine(),
3101 buf->getNativeBuffer());
3102
3103 if (fbo->getStatus() != NO_ERROR) {
3104 ALOGW("Binding buffer for display [%s] failed with status: %d",
3105 display->getDisplayName().c_str(), fbo->getStatus());
3106 return false;
3107 }
3108
Peiyong Lin34beb7a2018-03-28 11:57:12 -07003109 Dataspace outputDataspace = Dataspace::UNKNOWN;
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003110 if (display->hasWideColorGamut()) {
3111 outputDataspace = display->getCompositionDataSpace();
Chia-I Wu69bf10f2018-02-20 13:04:50 -08003112 }
3113 getBE().mRenderEngine->setOutputDataSpace(outputDataspace);
Peiyong Linfb069302018-04-25 14:34:31 -07003114 getBE().mRenderEngine->setDisplayMaxLuminance(
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003115 display->getHdrCapabilities().getDesiredMaxLuminance());
Chia-I Wu69bf10f2018-02-20 13:04:50 -08003116
Dominik Laskowski7e045462018-05-30 13:02:02 -07003117 const bool hasDeviceComposition = getBE().mHwc->hasDeviceComposition(displayId);
Peiyong Lined531a32018-10-26 18:27:56 -07003118 const bool skipClientColorTransform =
3119 getBE().mHwc
3120 ->hasDisplayCapability(displayId,
3121 HWC2::DisplayCapability::SkipClientColorTransform);
Chia-I Wu8e50e692018-05-04 10:12:37 -07003122
Peiyong Lind3788632018-09-18 16:01:31 -07003123 // Compute the global color transform matrix.
Chia-I Wu8e50e692018-05-04 10:12:37 -07003124 applyColorMatrix = !hasDeviceComposition && !skipClientColorTransform;
3125 if (applyColorMatrix) {
Chia-I Wud49d6692018-06-27 07:17:41 +08003126 colorMatrix = mDrawingState.colorMatrix;
Chia-I Wu8e50e692018-05-04 10:12:37 -07003127 }
3128
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003129 display->setViewportAndProjection();
Mathias Agopian52bbb1a2012-07-31 19:01:53 -07003130
Mathias Agopian52bbb1a2012-07-31 19:01:53 -07003131 // Never touch the framebuffer if we don't have any framebuffer layers
Dan Stoza9e56aa02015-11-02 13:00:03 -08003132 if (hasDeviceComposition) {
Mathias Agopianb9494d52012-04-18 02:28:45 -07003133 // when using overlays, we assume a fully transparent framebuffer
3134 // NOTE: we could reduce how much we need to clear, for instance
3135 // remove where there are opaque FB layers. however, on some
Mathias Agopian3f844832013-08-07 21:24:32 -07003136 // GPUs doing a "clean slate" clear might be more efficient.
Mathias Agopianb9494d52012-04-18 02:28:45 -07003137 // We'll revisit later if needed.
David Sodmanbc815282017-11-05 18:57:52 -08003138 getBE().mRenderEngine->clearWithColor(0, 0, 0, 0);
Mathias Agopianb9494d52012-04-18 02:28:45 -07003139 } else {
Chia-I Wub02087d2017-11-09 10:19:54 -08003140 // we start with the whole screen area and remove the scissor part
Mathias Agopian766dc492012-10-30 18:08:06 -07003141 // we're left with the letterbox region
3142 // (common case is that letterbox ends-up being empty)
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003143 const Region letterbox = bounds.subtract(display->getScissor());
Mathias Agopian766dc492012-10-30 18:08:06 -07003144
3145 // compute the area to clear
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003146 const Region region = display->undefinedRegion.merge(letterbox);
Mathias Agopian766dc492012-10-30 18:08:06 -07003147
Mathias Agopianb9494d52012-04-18 02:28:45 -07003148 // screen is already cleared here
Mathias Agopian87baae12012-07-31 12:38:26 -07003149 if (!region.isEmpty()) {
Mathias Agopianb9494d52012-04-18 02:28:45 -07003150 // can happen with SurfaceView
Chia-I Wu28e3a252018-09-07 12:05:02 -07003151 drawWormhole(region);
Mathias Agopianb9494d52012-04-18 02:28:45 -07003152 }
Mathias Agopiana2f4e562012-04-15 23:34:59 -07003153 }
Mathias Agopianf45c5102012-10-24 16:29:17 -07003154
Yiwei Zhange4e26c02018-08-22 13:59:12 -07003155 const Rect& bounds = display->getBounds();
3156 const Rect& scissor = display->getScissor();
3157 if (scissor != bounds) {
3158 // scissor doesn't match the screen's dimensions, so we
3159 // need to clear everything outside of it and enable
3160 // the GL scissor so we don't draw anything where we shouldn't
Mathias Agopian3f844832013-08-07 21:24:32 -07003161
Yiwei Zhange4e26c02018-08-22 13:59:12 -07003162 // enable scissor for this frame
Alec Mouri05483a02018-09-10 21:03:42 +00003163 getBE().mRenderEngine->setScissor(scissor);
Mathias Agopianf45c5102012-10-24 16:29:17 -07003164 }
Mathias Agopian85d751c2012-08-29 16:59:24 -07003165 }
Mathias Agopian4b2ba532012-03-29 12:23:51 -07003166
Mathias Agopian85d751c2012-08-29 16:59:24 -07003167 /*
3168 * and then, render the layers targeted at the framebuffer
3169 */
Mathias Agopian4b2ba532012-03-29 12:23:51 -07003170
Dan Stoza9e56aa02015-11-02 13:00:03 -08003171 ALOGV("Rendering client layers");
Peiyong Linefefaac2018-08-17 12:27:51 -07003172 const ui::Transform& displayTransform = display->getTransform();
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003173 bool firstLayer = true;
David Sodmanc1498e62018-09-12 14:36:26 -07003174 for (auto& layer : display->getVisibleLayersSortedByZ()) {
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003175 const Region clip(bounds.intersect(
David Sodmanc1498e62018-09-12 14:36:26 -07003176 displayTransform.transform(layer->visibleRegion)));
3177 ALOGV("Layer: %s", layer->getName().string());
3178 ALOGV(" Composition type: %s", to_string(layer->getCompositionType(displayId)).c_str());
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003179 if (!clip.isEmpty()) {
David Sodmanc1498e62018-09-12 14:36:26 -07003180 switch (layer->getCompositionType(displayId)) {
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003181 case HWC2::Composition::Cursor:
3182 case HWC2::Composition::Device:
3183 case HWC2::Composition::Sideband:
3184 case HWC2::Composition::SolidColor: {
Dominik Laskowski075d3172018-05-24 15:50:06 -07003185 LOG_ALWAYS_FATAL_IF(!displayId);
Dominik Laskowski075d3172018-05-24 15:50:06 -07003186 if (layer->getClearClientTarget(*displayId) && !firstLayer &&
Ady Abraham83729882018-12-07 12:26:48 -08003187 layer->isDrawingOpaque() && (layer->getAlpha() == 1.0f) &&
Lucas Dupin1b6531c2018-07-05 17:18:21 -07003188 layer->getRoundedCornerState().radius == 0.0f && hasClientComposition) {
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003189 // never clear the very first layer since we're
3190 // guaranteed the FB is already cleared
David Sodmanc1498e62018-09-12 14:36:26 -07003191 layer->clearWithOpenGL(renderArea);
Mathias Agopiancd60f992012-08-16 16:28:27 -07003192 }
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003193 break;
Mathias Agopiancd60f992012-08-16 16:28:27 -07003194 }
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003195 case HWC2::Composition::Client: {
Peiyong Lind3788632018-09-18 16:01:31 -07003196 if (layer->hasColorTransform()) {
3197 mat4 tmpMatrix;
3198 if (applyColorMatrix) {
3199 tmpMatrix = mDrawingState.colorMatrix;
3200 }
3201 tmpMatrix *= layer->getColorTransform();
Peiyong Lind3788632018-09-18 16:01:31 -07003202 getRenderEngine().setColorTransform(tmpMatrix);
3203 } else {
3204 getRenderEngine().setColorTransform(colorMatrix);
3205 }
David Sodmanc1498e62018-09-12 14:36:26 -07003206 layer->draw(renderArea, clip);
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003207 break;
3208 }
3209 default:
3210 break;
Mathias Agopian85d751c2012-08-29 16:59:24 -07003211 }
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003212 } else {
3213 ALOGV(" Skipping for empty clip");
Mathias Agopian85d751c2012-08-29 16:59:24 -07003214 }
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003215 firstLayer = false;
Mathias Agopian4b2ba532012-03-29 12:23:51 -07003216 }
Mathias Agopianf45c5102012-10-24 16:29:17 -07003217
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003218 // Perform some cleanup steps if we used client composition.
3219 if (hasClientComposition) {
3220 getRenderEngine().setColorTransform(mat4());
3221 getBE().mRenderEngine->disableScissor();
3222 display->finishBuffer();
3223 // Clear out error flags here so that we don't wait until next
3224 // composition to log.
3225 getRenderEngine().checkErrors();
3226 }
Michael Lentine3f121fc2014-10-01 11:17:28 -07003227 return true;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003228}
3229
Chia-I Wu28e3a252018-09-07 12:05:02 -07003230void SurfaceFlinger::drawWormhole(const Region& region) const {
Lloyd Pique144e1162017-12-20 16:44:52 -08003231 auto& engine(getRenderEngine());
Chia-I Wu28e3a252018-09-07 12:05:02 -07003232 engine.fillRegionWithColor(region, 0, 0, 0, 0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003233}
3234
Dan Stoza7d89d062015-04-30 13:29:25 -07003235status_t SurfaceFlinger::addClientLayer(const sp<Client>& client,
Mathias Agopianac9fa422013-02-11 16:40:36 -08003236 const sp<IBinder>& handle,
Mathias Agopian67106042013-03-14 19:18:13 -07003237 const sp<IGraphicBufferProducer>& gbc,
Robert Carr1f0a16a2016-10-24 16:27:39 -07003238 const sp<Layer>& lbc,
Robert Carrb89ea9d2018-12-10 13:01:14 -08003239 const sp<Layer>& parent,
3240 bool addToCurrentState)
Mathias Agopian96f08192010-06-02 23:28:45 -07003241{
Dan Stoza7d89d062015-04-30 13:29:25 -07003242 // add this layer to the current state list
3243 {
3244 Mutex::Autolock _l(mStateLock);
Robert Carr1f0a16a2016-10-24 16:27:39 -07003245 if (mNumLayers >= MAX_LAYERS) {
Courtney Goeltzenleuchterab702f52017-04-19 15:14:02 -06003246 ALOGE("AddClientLayer failed, mNumLayers (%zu) >= MAX_LAYERS (%zu)", mNumLayers,
3247 MAX_LAYERS);
Dan Stoza7d89d062015-04-30 13:29:25 -07003248 return NO_MEMORY;
3249 }
Robert Carrb89ea9d2018-12-10 13:01:14 -08003250 if (parent == nullptr && addToCurrentState) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003251 mCurrentState.layersSortedByZ.add(lbc);
Robert Carrb89ea9d2018-12-10 13:01:14 -08003252 } else if (parent == nullptr || parent->isRemovedFromCurrentState()) {
Jorim Jaggi10c985e2018-10-23 11:17:45 +00003253 ALOGE("addClientLayer called with a removed parent");
chaviw61626f22018-11-15 16:26:27 -08003254 lbc->onRemovedFromCurrentState();
Robert Carrb89ea9d2018-12-10 13:01:14 -08003255 } else {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003256 parent->addChild(lbc);
3257 }
Chia-I Wu98f1c102017-05-30 14:54:08 -07003258
Yiwei Zhang243b3782018-05-15 17:40:04 -07003259 if (gbc != nullptr) {
3260 mGraphicBufferProducerList.insert(IInterface::asBinder(gbc).get());
3261 LOG_ALWAYS_FATAL_IF(mGraphicBufferProducerList.size() >
3262 mMaxGraphicBufferProducerListSize,
3263 "Suspected IGBP leak: %zu IGBPs (%zu max), %zu Layers",
3264 mGraphicBufferProducerList.size(),
3265 mMaxGraphicBufferProducerListSize, mNumLayers);
3266 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07003267 mLayersAdded = true;
Dan Stoza7d89d062015-04-30 13:29:25 -07003268 }
3269
Mathias Agopian96f08192010-06-02 23:28:45 -07003270 // attach this layer to the client
Mathias Agopianac9fa422013-02-11 16:40:36 -08003271 client->attachLayer(handle, lbc);
Mathias Agopian4f113742011-05-03 16:21:41 -07003272
Dan Stoza7d89d062015-04-30 13:29:25 -07003273 return NO_ERROR;
Mathias Agopian96f08192010-06-02 23:28:45 -07003274}
3275
Robert Carr8d2711b2018-11-14 16:36:18 -08003276status_t SurfaceFlinger::removeLayer(const sp<Layer>& layer) {
Robert Carr7f9b8992017-03-10 11:08:39 -08003277 Mutex::Autolock _l(mStateLock);
Robert Carr8d2711b2018-11-14 16:36:18 -08003278 return removeLayerLocked(mStateLock, layer);
chaviwca27f252018-02-06 16:46:39 -08003279}
Robert Carr7f9b8992017-03-10 11:08:39 -08003280
Robert Carr8d2711b2018-11-14 16:36:18 -08003281status_t SurfaceFlinger::removeLayerLocked(const Mutex& lock, const sp<Layer>& layer) {
chaviw5aedec92018-10-22 10:40:38 -07003282 if (layer->isLayerDetached()) {
3283 return NO_ERROR;
3284 }
3285
Robert Carr1f0a16a2016-10-24 16:27:39 -07003286 const auto& p = layer->getParent();
Chia-I Wu515dc9c2017-06-15 12:53:59 -07003287 ssize_t index;
Chia-I Wu98f1c102017-05-30 14:54:08 -07003288 if (p != nullptr) {
Chia-I Wufae51c42017-06-15 12:53:59 -07003289 index = p->removeChild(layer);
Chia-I Wu515dc9c2017-06-15 12:53:59 -07003290 } else {
3291 index = mCurrentState.layersSortedByZ.remove(layer);
Chia-I Wu98f1c102017-05-30 14:54:08 -07003292 }
3293
Jorim Jaggi10c985e2018-10-23 11:17:45 +00003294 layer->onRemovedFromCurrentState();
Robert Carr2e102c92018-10-23 12:11:15 -07003295
3296 markLayerPendingRemovalLocked(lock, layer);
Robert Carr1f0a16a2016-10-24 16:27:39 -07003297 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003298}
3299
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08003300uint32_t SurfaceFlinger::peekTransactionFlags() {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003301 return mTransactionFlags;
Mathias Agopiandea20b12011-05-03 17:04:02 -07003302}
3303
Mathias Agopian3f844832013-08-07 21:24:32 -07003304uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003305 return mTransactionFlags.fetch_and(~flags) & flags;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003306}
3307
Mathias Agopian3f844832013-08-07 21:24:32 -07003308uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) {
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003309 return setTransactionFlags(flags, Scheduler::TransactionStart::NORMAL);
Dan Stoza84d619e2018-03-28 17:07:36 -07003310}
3311
3312uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags,
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003313 Scheduler::TransactionStart transactionStart) {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003314 uint32_t old = mTransactionFlags.fetch_or(flags);
Dan Stoza84d619e2018-03-28 17:07:36 -07003315 mVsyncModulator.setTransactionStart(transactionStart);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003316 if ((old & flags)==0) { // wake the server up
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08003317 signalTransaction();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003318 }
3319 return old;
3320}
3321
Marissa Wall713b63f2018-10-17 15:42:43 -07003322bool SurfaceFlinger::flushTransactionQueues() {
3323 Mutex::Autolock _l(mStateLock);
3324 auto it = mTransactionQueues.begin();
3325 while (it != mTransactionQueues.end()) {
3326 auto& [applyToken, transactionQueue] = *it;
3327
3328 while (!transactionQueue.empty()) {
3329 const auto& [states, displays, flags] = transactionQueue.front();
3330 if (composerStateContainsUnsignaledFences(states)) {
3331 break;
3332 }
chaviw273171b2018-12-26 11:46:30 -08003333 applyTransactionState(states, displays, flags, mInputWindowCommands);
Marissa Wall713b63f2018-10-17 15:42:43 -07003334 transactionQueue.pop();
3335 }
3336
3337 it = (transactionQueue.empty()) ? mTransactionQueues.erase(it) : std::next(it, 1);
3338 }
3339 return mTransactionQueues.empty();
3340}
3341
chaviwca27f252018-02-06 16:46:39 -08003342bool SurfaceFlinger::containsAnyInvalidClientState(const Vector<ComposerState>& states) {
3343 for (const ComposerState& state : states) {
3344 // Here we need to check that the interface we're given is indeed
3345 // one of our own. A malicious client could give us a nullptr
3346 // IInterface, or one of its own or even one of our own but a
3347 // different type. All these situations would cause us to crash.
3348 if (state.client == nullptr) {
3349 return true;
3350 }
3351
3352 sp<IBinder> binder = IInterface::asBinder(state.client);
3353 if (binder == nullptr) {
3354 return true;
3355 }
3356
3357 if (binder->queryLocalInterface(ISurfaceComposerClient::descriptor) == nullptr) {
3358 return true;
3359 }
3360 }
3361 return false;
3362}
3363
Marissa Wall713b63f2018-10-17 15:42:43 -07003364bool SurfaceFlinger::composerStateContainsUnsignaledFences(const Vector<ComposerState>& states) {
3365 for (const ComposerState& state : states) {
3366 const layer_state_t& s = state.state;
3367 if (!(s.what & layer_state_t::eAcquireFenceChanged)) {
3368 continue;
3369 }
3370 if (s.acquireFence && s.acquireFence->getStatus() == Fence::Status::Unsignaled) {
3371 return true;
3372 }
3373 }
3374 return false;
3375}
3376
3377void SurfaceFlinger::setTransactionState(const Vector<ComposerState>& states,
3378 const Vector<DisplayState>& displays, uint32_t flags,
chaviw273171b2018-12-26 11:46:30 -08003379 const sp<IBinder>& applyToken,
3380 const InputWindowCommands& inputWindowCommands) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003381 ATRACE_CALL();
Mathias Agopian698c0872011-06-28 19:09:31 -07003382 Mutex::Autolock _l(mStateLock);
Mathias Agopiane57f2922012-08-09 16:29:12 -07003383
chaviwca27f252018-02-06 16:46:39 -08003384 if (containsAnyInvalidClientState(states)) {
3385 return;
3386 }
3387
Marissa Wall713b63f2018-10-17 15:42:43 -07003388 // If its TransactionQueue already has a pending TransactionState or if it is pending
3389 if (mTransactionQueues.find(applyToken) != mTransactionQueues.end() ||
3390 composerStateContainsUnsignaledFences(states)) {
3391 mTransactionQueues[applyToken].emplace(states, displays, flags);
3392 setTransactionFlags(eTransactionNeeded);
3393 return;
3394 }
3395
chaviw273171b2018-12-26 11:46:30 -08003396 applyTransactionState(states, displays, flags, inputWindowCommands);
Marissa Wall713b63f2018-10-17 15:42:43 -07003397}
3398
3399void SurfaceFlinger::applyTransactionState(const Vector<ComposerState>& states,
chaviw273171b2018-12-26 11:46:30 -08003400 const Vector<DisplayState>& displays, uint32_t flags,
3401 const InputWindowCommands& inputWindowCommands) {
Marissa Wall713b63f2018-10-17 15:42:43 -07003402 uint32_t transactionFlags = 0;
3403
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003404 if (flags & eAnimation) {
3405 // For window updates that are part of an animation we must wait for
3406 // previous animation "frames" to be handled.
3407 while (mAnimTransactionPending) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003408 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003409 if (CC_UNLIKELY(err != NO_ERROR)) {
3410 // just in case something goes wrong in SF, return to the
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003411 // caller after a few seconds.
3412 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out "
3413 "waiting for previous animation frame");
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003414 mAnimTransactionPending = false;
3415 break;
3416 }
3417 }
3418 }
3419
chaviwca27f252018-02-06 16:46:39 -08003420 for (const DisplayState& display : displays) {
3421 transactionFlags |= setDisplayStateLocked(display);
Jamie Gennisb8d69a52011-10-10 15:48:06 -07003422 }
3423
Marissa Walle2ffb422018-10-12 11:33:52 -07003424 uint32_t clientStateFlags = 0;
chaviwca27f252018-02-06 16:46:39 -08003425 for (const ComposerState& state : states) {
Marissa Walle2ffb422018-10-12 11:33:52 -07003426 clientStateFlags |= setClientStateLocked(state);
chaviwca27f252018-02-06 16:46:39 -08003427 }
Marissa Walle2ffb422018-10-12 11:33:52 -07003428 // If the state doesn't require a traversal and there are callbacks, send them now
3429 if (!(clientStateFlags & eTraversalNeeded)) {
3430 mTransactionCompletedThread.sendCallbacks();
3431 }
3432 transactionFlags |= clientStateFlags;
chaviwca27f252018-02-06 16:46:39 -08003433
3434 // Iterate through all layers again to determine if any need to be destroyed. Marking layers
3435 // as destroyed should only occur after setting all other states. This is to allow for a
3436 // child re-parent to happen before marking its original parent as destroyed (which would
3437 // then mark the child as destroyed).
3438 for (const ComposerState& state : states) {
3439 setDestroyStateLocked(state);
Mathias Agopian698c0872011-06-28 19:09:31 -07003440 }
Mathias Agopian698c0872011-06-28 19:09:31 -07003441
chaviw273171b2018-12-26 11:46:30 -08003442 transactionFlags |= addInputWindowCommands(inputWindowCommands);
3443
Jorim Jaggibdcf09c2017-08-08 15:22:08 +02003444 // If a synchronous transaction is explicitly requested without any changes, force a transaction
3445 // anyway. This can be used as a flush mechanism for previous async transactions.
3446 // Empty animation transaction can be used to simulate back-pressure, so also force a
3447 // transaction for empty animation transactions.
3448 if (transactionFlags == 0 &&
3449 ((flags & eSynchronous) || (flags & eAnimation))) {
Robert Carr2a7dbb42016-05-24 11:41:28 -07003450 transactionFlags = eTransactionNeeded;
3451 }
3452
Mathias Agopian386aa982011-11-07 21:58:03 -08003453 if (transactionFlags) {
Lloyd Pique4dccc412018-01-22 17:21:36 -08003454 if (mInterceptor->isEnabled()) {
3455 mInterceptor->saveTransaction(states, mCurrentState.displays, displays, flags);
Irvelffc9efc2016-07-27 15:16:37 -07003456 }
Irvel468051e2016-06-13 16:44:44 -07003457
Mathias Agopian386aa982011-11-07 21:58:03 -08003458 // this triggers the transaction
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003459 const auto start = (flags & eEarlyWakeup) ? Scheduler::TransactionStart::EARLY
3460 : Scheduler::TransactionStart::NORMAL;
Dan Stoza84d619e2018-03-28 17:07:36 -07003461 setTransactionFlags(transactionFlags, start);
Mathias Agopian386aa982011-11-07 21:58:03 -08003462
3463 // if this is a synchronous transaction, wait for it to take effect
3464 // before returning.
3465 if (flags & eSynchronous) {
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003466 mTransactionPending = true;
Mathias Agopian386aa982011-11-07 21:58:03 -08003467 }
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003468 if (flags & eAnimation) {
3469 mAnimTransactionPending = true;
3470 }
3471 while (mTransactionPending) {
Mathias Agopian386aa982011-11-07 21:58:03 -08003472 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
3473 if (CC_UNLIKELY(err != NO_ERROR)) {
3474 // just in case something goes wrong in SF, return to the
3475 // called after a few seconds.
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003476 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");
3477 mTransactionPending = false;
Mathias Agopian386aa982011-11-07 21:58:03 -08003478 break;
3479 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -07003480 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003481 }
3482}
3483
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003484uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s) {
3485 const ssize_t index = mCurrentState.displays.indexOfKey(s.token);
3486 if (index < 0) return 0;
Jesse Hall9a143922012-10-04 16:29:19 -07003487
Mathias Agopiane57f2922012-08-09 16:29:12 -07003488 uint32_t flags = 0;
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003489 DisplayDeviceState& state = mCurrentState.displays.editValueAt(index);
3490
3491 const uint32_t what = s.what;
3492 if (what & DisplayState::eSurfaceChanged) {
3493 if (IInterface::asBinder(state.surface) != IInterface::asBinder(s.surface)) {
3494 state.surface = s.surface;
3495 flags |= eDisplayTransactionNeeded;
Michael Lentine47e45402014-07-18 15:34:25 -07003496 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07003497 }
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003498 if (what & DisplayState::eLayerStackChanged) {
3499 if (state.layerStack != s.layerStack) {
3500 state.layerStack = s.layerStack;
3501 flags |= eDisplayTransactionNeeded;
3502 }
3503 }
3504 if (what & DisplayState::eDisplayProjectionChanged) {
3505 if (state.orientation != s.orientation) {
3506 state.orientation = s.orientation;
3507 flags |= eDisplayTransactionNeeded;
3508 }
3509 if (state.frame != s.frame) {
3510 state.frame = s.frame;
3511 flags |= eDisplayTransactionNeeded;
3512 }
3513 if (state.viewport != s.viewport) {
3514 state.viewport = s.viewport;
3515 flags |= eDisplayTransactionNeeded;
3516 }
3517 }
3518 if (what & DisplayState::eDisplaySizeChanged) {
3519 if (state.width != s.width) {
3520 state.width = s.width;
3521 flags |= eDisplayTransactionNeeded;
3522 }
3523 if (state.height != s.height) {
3524 state.height = s.height;
3525 flags |= eDisplayTransactionNeeded;
3526 }
3527 }
3528
Mathias Agopiane57f2922012-08-09 16:29:12 -07003529 return flags;
3530}
3531
Robert Carrd4ae7f32018-06-07 16:10:57 -07003532bool callingThreadHasUnscopedSurfaceFlingerAccess() {
3533 IPCThreadState* ipc = IPCThreadState::self();
3534 const int pid = ipc->getCallingPid();
3535 const int uid = ipc->getCallingUid();
Robert Carrd4ae7f32018-06-07 16:10:57 -07003536 if ((uid != AID_GRAPHICS && uid != AID_SYSTEM) &&
Ana Krulec13be8ad2018-08-21 02:43:56 +00003537 !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003538 return false;
3539 }
3540 return true;
3541}
3542
chaviwca27f252018-02-06 16:46:39 -08003543uint32_t SurfaceFlinger::setClientStateLocked(const ComposerState& composerState) {
3544 const layer_state_t& s = composerState.state;
3545 sp<Client> client(static_cast<Client*>(composerState.client.get()));
3546
Mathias Agopian13127d82013-03-05 17:47:11 -08003547 sp<Layer> layer(client->getLayerUser(s.surface));
chaviw8b3871a2017-11-01 17:41:01 -07003548 if (layer == nullptr) {
3549 return 0;
3550 }
3551
chaviw8b3871a2017-11-01 17:41:01 -07003552 uint32_t flags = 0;
3553
Garfield Tan8a3083e2018-12-03 13:21:07 -08003554 const uint64_t what = s.what;
chaviw8b3871a2017-11-01 17:41:01 -07003555 bool geometryAppliesWithResize =
3556 what & layer_state_t::eGeometryAppliesWithResize;
Jorim Jaggidba32732018-05-28 17:43:52 +02003557
3558 // If we are deferring transaction, make sure to push the pending state, as otherwise the
3559 // pending state will also be deferred.
Marissa Wallf58c14b2018-07-24 10:50:43 -07003560 if (what & layer_state_t::eDeferTransaction_legacy) {
Jorim Jaggidba32732018-05-28 17:43:52 +02003561 layer->pushPendingState();
3562 }
3563
chaviw8b3871a2017-11-01 17:41:01 -07003564 if (what & layer_state_t::ePositionChanged) {
3565 if (layer->setPosition(s.x, s.y, !geometryAppliesWithResize)) {
3566 flags |= eTraversalNeeded;
Mathias Agopiane57f2922012-08-09 16:29:12 -07003567 }
chaviw8b3871a2017-11-01 17:41:01 -07003568 }
3569 if (what & layer_state_t::eLayerChanged) {
3570 // NOTE: index needs to be calculated before we update the state
3571 const auto& p = layer->getParent();
3572 if (p == nullptr) {
chaviw64f7b422017-07-12 10:31:58 -07003573 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
chaviw8b3871a2017-11-01 17:41:01 -07003574 if (layer->setLayer(s.z) && idx >= 0) {
Mathias Agopiane57f2922012-08-09 16:29:12 -07003575 mCurrentState.layersSortedByZ.removeAt(idx);
3576 mCurrentState.layersSortedByZ.add(layer);
3577 // we need traversal (state changed)
3578 // AND transaction (list changed)
3579 flags |= eTransactionNeeded|eTraversalNeeded;
3580 }
chaviw8b3871a2017-11-01 17:41:01 -07003581 } else {
3582 if (p->setChildLayer(layer, s.z)) {
chaviw06178942017-07-27 10:25:59 -07003583 flags |= eTransactionNeeded|eTraversalNeeded;
3584 }
3585 }
chaviw8b3871a2017-11-01 17:41:01 -07003586 }
3587 if (what & layer_state_t::eRelativeLayerChanged) {
Robert Carr503c7042017-09-27 15:06:08 -07003588 // NOTE: index needs to be calculated before we update the state
3589 const auto& p = layer->getParent();
3590 if (p == nullptr) {
3591 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
3592 if (layer->setRelativeLayer(s.relativeLayerHandle, s.z) && idx >= 0) {
3593 mCurrentState.layersSortedByZ.removeAt(idx);
3594 mCurrentState.layersSortedByZ.add(layer);
3595 // we need traversal (state changed)
3596 // AND transaction (list changed)
3597 flags |= eTransactionNeeded|eTraversalNeeded;
3598 }
3599 } else {
3600 if (p->setChildRelativeLayer(layer, s.relativeLayerHandle, s.z)) {
3601 flags |= eTransactionNeeded|eTraversalNeeded;
3602 }
chaviw8b3871a2017-11-01 17:41:01 -07003603 }
3604 }
3605 if (what & layer_state_t::eSizeChanged) {
3606 if (layer->setSize(s.w, s.h)) {
3607 flags |= eTraversalNeeded;
3608 }
3609 }
3610 if (what & layer_state_t::eAlphaChanged) {
3611 if (layer->setAlpha(s.alpha))
3612 flags |= eTraversalNeeded;
3613 }
3614 if (what & layer_state_t::eColorChanged) {
3615 if (layer->setColor(s.color))
3616 flags |= eTraversalNeeded;
3617 }
Peiyong Lind3788632018-09-18 16:01:31 -07003618 if (what & layer_state_t::eColorTransformChanged) {
3619 if (layer->setColorTransform(s.colorTransform)) {
3620 flags |= eTraversalNeeded;
3621 }
3622 }
chaviw8b3871a2017-11-01 17:41:01 -07003623 if (what & layer_state_t::eMatrixChanged) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003624 // TODO: b/109894387
3625 //
3626 // SurfaceFlinger's renderer is not prepared to handle cropping in the face of arbitrary
3627 // rotation. To see the problem observe that if we have a square parent, and a child
3628 // of the same size, then we rotate the child 45 degrees around it's center, the child
3629 // must now be cropped to a non rectangular 8 sided region.
3630 //
3631 // Of course we can fix this in the future. For now, we are lucky, SurfaceControl is
3632 // private API, and the WindowManager only uses rotation in one case, which is on a top
3633 // level layer in which cropping is not an issue.
3634 //
3635 // However given that abuse of rotation matrices could lead to surfaces extending outside
3636 // of cropped areas, we need to prevent non-root clients without permission ACCESS_SURFACE_FLINGER
3637 // (a.k.a. everyone except WindowManager and tests) from setting non rectangle preserving
3638 // transformations.
3639 if (layer->setMatrix(s.matrix, callingThreadHasUnscopedSurfaceFlingerAccess()))
chaviw8b3871a2017-11-01 17:41:01 -07003640 flags |= eTraversalNeeded;
3641 }
3642 if (what & layer_state_t::eTransparentRegionChanged) {
3643 if (layer->setTransparentRegionHint(s.transparentRegion))
3644 flags |= eTraversalNeeded;
3645 }
3646 if (what & layer_state_t::eFlagsChanged) {
3647 if (layer->setFlags(s.flags, s.mask))
3648 flags |= eTraversalNeeded;
3649 }
Marissa Wallf58c14b2018-07-24 10:50:43 -07003650 if (what & layer_state_t::eCropChanged_legacy) {
3651 if (layer->setCrop_legacy(s.crop_legacy, !geometryAppliesWithResize))
chaviw8b3871a2017-11-01 17:41:01 -07003652 flags |= eTraversalNeeded;
3653 }
Lucas Dupin1b6531c2018-07-05 17:18:21 -07003654 if (what & layer_state_t::eCornerRadiusChanged) {
3655 if (layer->setCornerRadius(s.cornerRadius))
3656 flags |= eTraversalNeeded;
3657 }
chaviw8b3871a2017-11-01 17:41:01 -07003658 if (what & layer_state_t::eLayerStackChanged) {
3659 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
3660 // We only allow setting layer stacks for top level layers,
3661 // everything else inherits layer stack from its parent.
3662 if (layer->hasParent()) {
3663 ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
3664 layer->getName().string());
3665 } else if (idx < 0) {
3666 ALOGE("Attempt to set layer stack on layer without parent (%s) that "
3667 "that also does not appear in the top level layer list. Something"
3668 " has gone wrong.", layer->getName().string());
3669 } else if (layer->setLayerStack(s.layerStack)) {
3670 mCurrentState.layersSortedByZ.removeAt(idx);
3671 mCurrentState.layersSortedByZ.add(layer);
3672 // we need traversal (state changed)
3673 // AND transaction (list changed)
Lloyd Piqued432a7c2018-03-23 16:05:31 -07003674 flags |= eTransactionNeeded|eTraversalNeeded|eDisplayLayerStackChanged;
chaviw8b3871a2017-11-01 17:41:01 -07003675 }
3676 }
Marissa Wallf58c14b2018-07-24 10:50:43 -07003677 if (what & layer_state_t::eDeferTransaction_legacy) {
3678 if (s.barrierHandle_legacy != nullptr) {
3679 layer->deferTransactionUntil_legacy(s.barrierHandle_legacy, s.frameNumber_legacy);
3680 } else if (s.barrierGbp_legacy != nullptr) {
3681 const sp<IGraphicBufferProducer>& gbp = s.barrierGbp_legacy;
chaviw8b3871a2017-11-01 17:41:01 -07003682 if (authenticateSurfaceTextureLocked(gbp)) {
3683 const auto& otherLayer =
3684 (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
Marissa Wallf58c14b2018-07-24 10:50:43 -07003685 layer->deferTransactionUntil_legacy(otherLayer, s.frameNumber_legacy);
chaviw8b3871a2017-11-01 17:41:01 -07003686 } else {
3687 ALOGE("Attempt to defer transaction to to an"
3688 " unrecognized GraphicBufferProducer");
Robert Carr1db73f62016-12-21 12:58:51 -08003689 }
3690 }
chaviw8b3871a2017-11-01 17:41:01 -07003691 // We don't trigger a traversal here because if no other state is
3692 // changed, we don't want this to cause any more work
3693 }
3694 if (what & layer_state_t::eReparent) {
chaviw8ea97bb2017-11-29 10:05:15 -08003695 bool hadParent = layer->hasParent();
chaviw8b3871a2017-11-01 17:41:01 -07003696 if (layer->reparent(s.parentHandleForChild)) {
chaviw8ea97bb2017-11-29 10:05:15 -08003697 if (!hadParent) {
3698 mCurrentState.layersSortedByZ.remove(layer);
3699 }
chaviw8b3871a2017-11-01 17:41:01 -07003700 flags |= eTransactionNeeded|eTraversalNeeded;
Robert Carr9524cb32017-02-13 11:32:32 -08003701 }
chaviw8b3871a2017-11-01 17:41:01 -07003702 }
3703 if (what & layer_state_t::eReparentChildren) {
3704 if (layer->reparentChildren(s.reparentHandle)) {
3705 flags |= eTransactionNeeded|eTraversalNeeded;
Robert Carrc3574f72016-03-24 12:19:32 -07003706 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07003707 }
chaviw8b3871a2017-11-01 17:41:01 -07003708 if (what & layer_state_t::eDetachChildren) {
3709 layer->detachChildren();
3710 }
3711 if (what & layer_state_t::eOverrideScalingModeChanged) {
3712 layer->setOverrideScalingMode(s.overrideScalingMode);
3713 // We don't trigger a traversal here because if no other state is
3714 // changed, we don't want this to cause any more work
3715 }
Marissa Wall61c58622018-07-18 10:12:20 -07003716 if (what & layer_state_t::eTransformChanged) {
3717 if (layer->setTransform(s.transform)) flags |= eTraversalNeeded;
3718 }
3719 if (what & layer_state_t::eTransformToDisplayInverseChanged) {
3720 if (layer->setTransformToDisplayInverse(s.transformToDisplayInverse))
3721 flags |= eTraversalNeeded;
3722 }
3723 if (what & layer_state_t::eCropChanged) {
3724 if (layer->setCrop(s.crop)) flags |= eTraversalNeeded;
3725 }
Marissa Wall861616d2018-10-22 12:52:23 -07003726 if (what & layer_state_t::eFrameChanged) {
3727 if (layer->setFrame(s.frame)) flags |= eTraversalNeeded;
3728 }
Marissa Wall61c58622018-07-18 10:12:20 -07003729 if (what & layer_state_t::eBufferChanged) {
3730 if (layer->setBuffer(s.buffer)) flags |= eTraversalNeeded;
3731 }
3732 if (what & layer_state_t::eAcquireFenceChanged) {
3733 if (layer->setAcquireFence(s.acquireFence)) flags |= eTraversalNeeded;
3734 }
3735 if (what & layer_state_t::eDataspaceChanged) {
3736 if (layer->setDataspace(s.dataspace)) flags |= eTraversalNeeded;
3737 }
3738 if (what & layer_state_t::eHdrMetadataChanged) {
3739 if (layer->setHdrMetadata(s.hdrMetadata)) flags |= eTraversalNeeded;
3740 }
3741 if (what & layer_state_t::eSurfaceDamageRegionChanged) {
3742 if (layer->setSurfaceDamageRegion(s.surfaceDamageRegion)) flags |= eTraversalNeeded;
3743 }
3744 if (what & layer_state_t::eApiChanged) {
3745 if (layer->setApi(s.api)) flags |= eTraversalNeeded;
3746 }
3747 if (what & layer_state_t::eSidebandStreamChanged) {
3748 if (layer->setSidebandStream(s.sidebandStream)) flags |= eTraversalNeeded;
3749 }
Robert Carr720e5062018-07-30 17:45:14 -07003750 if (what & layer_state_t::eInputInfoChanged) {
3751 layer->setInputInfo(s.inputInfo);
3752 flags |= eTraversalNeeded;
3753 }
Marissa Walle2ffb422018-10-12 11:33:52 -07003754 std::vector<sp<CallbackHandle>> callbackHandles;
3755 if ((what & layer_state_t::eListenerCallbacksChanged) && (!s.listenerCallbacks.empty())) {
3756 mTransactionCompletedThread.run();
3757 for (const auto& [listener, callbackIds] : s.listenerCallbacks) {
3758 callbackHandles.emplace_back(new CallbackHandle(listener, callbackIds, s.surface));
3759 }
3760 }
3761 if (layer->setTransactionCompletedListeners(callbackHandles)) flags |= eTraversalNeeded;
3762 // Do not put anything that updates layer state or modifies flags after
3763 // setTransactionCompletedListener
Mathias Agopiane57f2922012-08-09 16:29:12 -07003764 return flags;
3765}
3766
chaviwca27f252018-02-06 16:46:39 -08003767void SurfaceFlinger::setDestroyStateLocked(const ComposerState& composerState) {
3768 const layer_state_t& state = composerState.state;
3769 sp<Client> client(static_cast<Client*>(composerState.client.get()));
3770
3771 sp<Layer> layer(client->getLayerUser(state.surface));
3772 if (layer == nullptr) {
3773 return;
3774 }
3775
chaviwca27f252018-02-06 16:46:39 -08003776 if (state.what & layer_state_t::eDestroySurface) {
3777 removeLayerLocked(mStateLock, layer);
3778 }
3779}
3780
chaviw273171b2018-12-26 11:46:30 -08003781uint32_t SurfaceFlinger::addInputWindowCommands(const InputWindowCommands& inputWindowCommands) {
3782 uint32_t flags = 0;
3783 if (!inputWindowCommands.transferTouchFocusCommands.empty()) {
3784 flags |= eTraversalNeeded;
3785 }
3786
3787 mInputWindowCommands.merge(inputWindowCommands);
3788 return flags;
3789}
3790
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003791status_t SurfaceFlinger::createLayer(
Mathias Agopian0ef4e152011-04-20 14:19:32 -07003792 const String8& name,
3793 const sp<Client>& client,
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003794 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
rongliucfb187b2018-03-14 12:26:23 -07003795 int32_t windowType, int32_t ownerUid, sp<IBinder>* handle,
Albert Chaulk479c60c2017-01-27 14:21:34 -05003796 sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003797{
Mathias Agopian6e2d6482009-07-09 18:16:43 -07003798 if (int32_t(w|h) < 0) {
Mathias Agopian921e6ac2012-07-23 23:11:29 -07003799 ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
Mathias Agopian6e2d6482009-07-09 18:16:43 -07003800 int(w), int(h));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003801 return BAD_VALUE;
Mathias Agopian6e2d6482009-07-09 18:16:43 -07003802 }
Andreas Huber8b42e8a2010-08-16 08:49:37 -07003803
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003804 status_t result = NO_ERROR;
3805
3806 sp<Layer> layer;
3807
Cody Northropbc755282017-03-31 12:00:08 -06003808 String8 uniqueName = getUniqueLayerName(name);
3809
Mathias Agopian3165cc22012-08-08 19:42:09 -07003810 switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
Marissa Wall61c58622018-07-18 10:12:20 -07003811 case ISurfaceComposerClient::eFXSurfaceBufferQueue:
Marissa Wallfd668622018-05-10 10:21:13 -07003812 result = createBufferQueueLayer(client, uniqueName, w, h, flags, format, handle, gbp,
3813 &layer);
David Sodman0c69cad2017-08-21 12:12:51 -07003814
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003815 break;
Marissa Wall61c58622018-07-18 10:12:20 -07003816 case ISurfaceComposerClient::eFXSurfaceBufferState:
3817 result = createBufferStateLayer(client, uniqueName, w, h, flags, handle, &layer);
3818 break;
chaviw13fdc492017-06-27 12:40:18 -07003819 case ISurfaceComposerClient::eFXSurfaceColor:
Vishnu Nair88a11f22018-11-28 18:30:57 -08003820 // check if buffer size is set for color layer.
3821 if (w > 0 || h > 0) {
3822 ALOGE("createLayer() failed, w or h cannot be set for color layer (w=%d, h=%d)",
3823 int(w), int(h));
3824 return BAD_VALUE;
3825 }
3826
chaviw13fdc492017-06-27 12:40:18 -07003827 result = createColorLayer(client,
Cody Northropbc755282017-03-31 12:00:08 -06003828 uniqueName, w, h, flags,
David Sodman0c69cad2017-08-21 12:12:51 -07003829 handle, &layer);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003830 break;
Robert Carr6b3f6c52018-08-13 13:05:17 -07003831 case ISurfaceComposerClient::eFXSurfaceContainer:
Vishnu Nair88a11f22018-11-28 18:30:57 -08003832 // check if buffer size is set for container layer.
3833 if (w > 0 || h > 0) {
3834 ALOGE("createLayer() failed, w or h cannot be set for container layer (w=%d, h=%d)",
3835 int(w), int(h));
3836 return BAD_VALUE;
3837 }
Robert Carr6b3f6c52018-08-13 13:05:17 -07003838 result = createContainerLayer(client,
3839 uniqueName, w, h, flags,
3840 handle, &layer);
3841 break;
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003842 default:
3843 result = BAD_VALUE;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003844 break;
3845 }
3846
Dan Stoza7d89d062015-04-30 13:29:25 -07003847 if (result != NO_ERROR) {
3848 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003849 }
Dan Stoza7d89d062015-04-30 13:29:25 -07003850
Chia-I Wuab0c3192017-08-01 11:29:00 -07003851 // window type is WINDOW_TYPE_DONT_SCREENSHOT from SurfaceControl.java
3852 // TODO b/64227542
3853 if (windowType == 441731) {
3854 windowType = 2024; // TYPE_NAVIGATION_BAR_PANEL
3855 layer->setPrimaryDisplayOnly();
3856 }
3857
Albert Chaulk479c60c2017-01-27 14:21:34 -05003858 layer->setInfo(windowType, ownerUid);
3859
Robert Carrb89ea9d2018-12-10 13:01:14 -08003860 bool addToCurrentState = callingThreadHasUnscopedSurfaceFlingerAccess();
3861 result = addClientLayer(client, *handle, *gbp, layer, *parent,
3862 addToCurrentState);
Dan Stoza7d89d062015-04-30 13:29:25 -07003863 if (result != NO_ERROR) {
3864 return result;
3865 }
Lloyd Pique4dccc412018-01-22 17:21:36 -08003866 mInterceptor->saveSurfaceCreation(layer);
Dan Stoza7d89d062015-04-30 13:29:25 -07003867
3868 setTransactionFlags(eTransactionNeeded);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003869 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003870}
3871
Cody Northropbc755282017-03-31 12:00:08 -06003872String8 SurfaceFlinger::getUniqueLayerName(const String8& name)
3873{
3874 bool matchFound = true;
3875 uint32_t dupeCounter = 0;
3876
3877 // Tack on our counter whether there is a hit or not, so everyone gets a tag
3878 String8 uniqueName = name + "#" + String8(std::to_string(dupeCounter).c_str());
3879
Dan Stoza436ccf32018-06-21 12:10:12 -07003880 // Grab the state lock since we're accessing mCurrentState
3881 Mutex::Autolock lock(mStateLock);
3882
Cody Northropbc755282017-03-31 12:00:08 -06003883 // Loop over layers until we're sure there is no matching name
3884 while (matchFound) {
3885 matchFound = false;
Dan Stoza436ccf32018-06-21 12:10:12 -07003886 mCurrentState.traverseInZOrder([&](Layer* layer) {
Cody Northropbc755282017-03-31 12:00:08 -06003887 if (layer->getName() == uniqueName) {
3888 matchFound = true;
3889 uniqueName = name + "#" + String8(std::to_string(++dupeCounter).c_str());
3890 }
3891 });
3892 }
3893
Marissa Wallf1de4bd2018-05-22 13:05:01 -07003894 ALOGV_IF(dupeCounter > 0, "duplicate layer name: changing %s to %s", name.c_str(),
3895 uniqueName.c_str());
Cody Northropbc755282017-03-31 12:00:08 -06003896
3897 return uniqueName;
3898}
3899
Marissa Wallfd668622018-05-10 10:21:13 -07003900status_t SurfaceFlinger::createBufferQueueLayer(const sp<Client>& client, const String8& name,
3901 uint32_t w, uint32_t h, uint32_t flags,
3902 PixelFormat& format, sp<IBinder>* handle,
3903 sp<IGraphicBufferProducer>* gbp,
3904 sp<Layer>* outLayer) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003905 // initialize the surfaces
Mathias Agopian92a979a2012-08-02 18:32:23 -07003906 switch (format) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003907 case PIXEL_FORMAT_TRANSPARENT:
3908 case PIXEL_FORMAT_TRANSLUCENT:
3909 format = PIXEL_FORMAT_RGBA_8888;
3910 break;
3911 case PIXEL_FORMAT_OPAQUE:
Mathias Agopian8f105402010-04-05 18:01:24 -07003912 format = PIXEL_FORMAT_RGBX_8888;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003913 break;
3914 }
3915
Lloyd Pique42ab75e2018-09-12 20:46:03 -07003916 sp<BufferQueueLayer> layer =
Lloyd Pique90c115d2018-09-18 21:39:42 -07003917 getFactory().createBufferQueueLayer(LayerCreationArgs(this, client, name, w, h, flags));
Marissa Wallfd668622018-05-10 10:21:13 -07003918 status_t err = layer->setDefaultBufferProperties(w, h, format);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003919 if (err == NO_ERROR) {
David Sodman0c69cad2017-08-21 12:12:51 -07003920 *handle = layer->getHandle();
3921 *gbp = layer->getProducer();
3922 *outLayer = layer;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003923 }
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003924
Marissa Wallfd668622018-05-10 10:21:13 -07003925 ALOGE_IF(err, "createBufferQueueLayer() failed (%s)", strerror(-err));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003926 return err;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003927}
3928
Marissa Wall61c58622018-07-18 10:12:20 -07003929status_t SurfaceFlinger::createBufferStateLayer(const sp<Client>& client, const String8& name,
3930 uint32_t w, uint32_t h, uint32_t flags,
3931 sp<IBinder>* handle, sp<Layer>* outLayer) {
Lloyd Pique42ab75e2018-09-12 20:46:03 -07003932 sp<BufferStateLayer> layer =
Lloyd Pique90c115d2018-09-18 21:39:42 -07003933 getFactory().createBufferStateLayer(LayerCreationArgs(this, client, name, w, h, flags));
Marissa Wall61c58622018-07-18 10:12:20 -07003934 *handle = layer->getHandle();
3935 *outLayer = layer;
3936
3937 return NO_ERROR;
3938}
3939
chaviw13fdc492017-06-27 12:40:18 -07003940status_t SurfaceFlinger::createColorLayer(const sp<Client>& client,
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003941 const String8& name, uint32_t w, uint32_t h, uint32_t flags,
David Sodman0c69cad2017-08-21 12:12:51 -07003942 sp<IBinder>* handle, sp<Layer>* outLayer)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003943{
Lloyd Pique90c115d2018-09-18 21:39:42 -07003944 *outLayer = getFactory().createColorLayer(LayerCreationArgs(this, client, name, w, h, flags));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003945 *handle = (*outLayer)->getHandle();
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003946 return NO_ERROR;
Mathias Agopian118d0242011-10-13 16:02:48 -07003947}
3948
Robert Carr6b3f6c52018-08-13 13:05:17 -07003949status_t SurfaceFlinger::createContainerLayer(const sp<Client>& client,
3950 const String8& name, uint32_t w, uint32_t h, uint32_t flags,
3951 sp<IBinder>* handle, sp<Layer>* outLayer)
3952{
Lloyd Pique90c115d2018-09-18 21:39:42 -07003953 *outLayer =
3954 getFactory().createContainerLayer(LayerCreationArgs(this, client, name, w, h, flags));
Robert Carr6b3f6c52018-08-13 13:05:17 -07003955 *handle = (*outLayer)->getHandle();
3956 return NO_ERROR;
3957}
3958
3959
Mathias Agopianac9fa422013-02-11 16:40:36 -08003960status_t SurfaceFlinger::onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003961{
Robert Carr9524cb32017-02-13 11:32:32 -08003962 // called by a client when it wants to remove a Layer
Mathias Agopian67106042013-03-14 19:18:13 -07003963 status_t err = NO_ERROR;
3964 sp<Layer> l(client->getLayerUser(handle));
Peiyong Lin566a3b42018-01-09 18:22:43 -08003965 if (l != nullptr) {
Lloyd Pique4dccc412018-01-22 17:21:36 -08003966 mInterceptor->saveSurfaceDeletion(l);
Mathias Agopian67106042013-03-14 19:18:13 -07003967 err = removeLayer(l);
3968 ALOGE_IF(err<0 && err != NAME_NOT_FOUND,
3969 "error removing layer=%p (%s)", l.get(), strerror(-err));
Mathias Agopian9a112062009-04-17 19:36:26 -07003970 }
3971 return err;
3972}
3973
Robert Carr2e102c92018-10-23 12:11:15 -07003974void SurfaceFlinger::markLayerPendingRemovalLocked(const Mutex&, const sp<Layer>& layer) {
3975 mLayersPendingRemoval.add(layer);
3976 mLayersRemoved = true;
3977 setTransactionFlags(eTransactionNeeded);
3978}
3979
Robert Carr695d5282018-12-18 15:27:58 -08003980void SurfaceFlinger::onHandleDestroyed(sp<Layer>& layer)
Rob Carr4bba3702018-10-08 21:53:30 +00003981{
Robert Carr2e102c92018-10-23 12:11:15 -07003982 Mutex::Autolock lock(mStateLock);
3983 markLayerPendingRemovalLocked(mStateLock, layer);
Robert Carr695d5282018-12-18 15:27:58 -08003984 layer.clear();
Rob Carr4bba3702018-10-08 21:53:30 +00003985}
3986
Mathias Agopianb60314a2012-04-10 22:09:54 -07003987// ---------------------------------------------------------------------------
3988
Andy McFadden13a082e2012-08-24 10:16:42 -07003989void SurfaceFlinger::onInitializeDisplays() {
Dominik Laskowski075d3172018-05-24 15:50:06 -07003990 const auto displayToken = getInternalDisplayToken();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07003991 if (!displayToken) return;
3992
Jesse Hall01e29052013-02-19 16:13:35 -08003993 // reset screen orientation and use primary layer stack
Andy McFadden13a082e2012-08-24 10:16:42 -07003994 Vector<ComposerState> state;
3995 Vector<DisplayState> displays;
3996 DisplayState d;
Jesse Hall01e29052013-02-19 16:13:35 -08003997 d.what = DisplayState::eDisplayProjectionChanged |
3998 DisplayState::eLayerStackChanged;
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07003999 d.token = displayToken;
Jesse Hall01e29052013-02-19 16:13:35 -08004000 d.layerStack = 0;
Andy McFadden13a082e2012-08-24 10:16:42 -07004001 d.orientation = DisplayState::eOrientationDefault;
Jeff Brown4c05dd12012-09-09 00:07:17 -07004002 d.frame.makeInvalid();
4003 d.viewport.makeInvalid();
Michael Lentine47e45402014-07-18 15:34:25 -07004004 d.width = 0;
4005 d.height = 0;
Andy McFadden13a082e2012-08-24 10:16:42 -07004006 displays.add(d);
chaviw273171b2018-12-26 11:46:30 -08004007 setTransactionState(state, displays, 0, nullptr, mInputWindowCommands);
Jamie Gennis6547ff42013-07-16 20:12:42 -07004008
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004009 const auto display = getDisplayDevice(displayToken);
4010 if (!display) return;
4011
Dominik Laskowskie9774092018-12-11 10:04:24 -08004012 setPowerModeInternal(display, HWC_POWER_MODE_NORMAL);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004013
Dominik Laskowski075d3172018-05-24 15:50:06 -07004014 const auto activeConfig = getHwComposer().getActiveConfig(*display->getId());
Dan Stoza9e56aa02015-11-02 13:00:03 -08004015 const nsecs_t period = activeConfig->getVsyncPeriod();
Jamie Gennis6547ff42013-07-16 20:12:42 -07004016 mAnimFrameTracker.setDisplayRefreshPeriod(period);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08004017
Brian Andersond0010582017-03-07 13:20:31 -08004018 // Use phase of 0 since phase is not known.
4019 // Use latency of 0, which will snap to the ideal latency.
Ana Krulece588e312018-09-18 12:32:24 -07004020 DisplayStatInfo stats{0 /* vsyncTime */, period /* vsyncPeriod */};
4021 setCompositorTimingSnapped(stats, 0);
Andy McFadden13a082e2012-08-24 10:16:42 -07004022}
4023
4024void SurfaceFlinger::initializeDisplays() {
Dominik Laskowski8c001672018-05-30 16:52:06 -07004025 // Async since we may be called from the main thread.
4026 postMessageAsync(new LambdaMessage([this] { onInitializeDisplays(); }));
Andy McFadden13a082e2012-08-24 10:16:42 -07004027}
4028
Dominik Laskowskie9774092018-12-11 10:04:24 -08004029void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& display, int mode) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004030 if (display->isVirtual()) {
4031 ALOGE("%s: Invalid operation on virtual display", __FUNCTION__);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004032 return;
4033 }
4034
Dominik Laskowski075d3172018-05-24 15:50:06 -07004035 const auto displayId = display->getId();
4036 LOG_ALWAYS_FATAL_IF(!displayId);
4037
Dominik Laskowski34157762018-10-31 13:07:19 -07004038 ALOGD("Setting power mode %d on display %s", mode, to_string(*displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004039
4040 int currentMode = display->getPowerMode();
4041 if (mode == currentMode) {
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004042 return;
4043 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004044
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004045 display->setPowerMode(mode);
4046
Lloyd Pique4dccc412018-01-22 17:21:36 -08004047 if (mInterceptor->isEnabled()) {
Dominik Laskowskie9774092018-12-11 10:04:24 -08004048 mInterceptor->savePowerModeUpdate(display->getSequenceId(), mode);
Irvelffc9efc2016-07-27 15:16:37 -07004049 }
4050
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004051 if (currentMode == HWC_POWER_MODE_OFF) {
Tim Murrayf9d4e442016-08-02 15:43:59 -07004052 // Turn on the display
Dominik Laskowski075d3172018-05-24 15:50:06 -07004053 getHwComposer().setPowerMode(*displayId, mode);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004054 if (display->isPrimary() && mode != HWC_POWER_MODE_DOZE_SUSPEND) {
Ana Krulec98b5b242018-08-10 15:03:23 -07004055 if (mUseScheduler) {
4056 mScheduler->onScreenAcquired(mAppConnectionHandle);
4057 } else {
4058 mEventThread->onScreenAcquired();
4059 }
Jesse Hall948fe0c2013-10-14 12:56:09 -07004060 resyncToHardwareVsync(true);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004061 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004062
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004063 mVisibleRegionsDirty = true;
Dan Stozab90cf072015-03-05 11:05:59 -08004064 mHasPoweredOff = true;
Dan Stozac7a25ad2018-04-12 11:45:09 -07004065 repaintEverything();
Tim Murrayf9d4e442016-08-02 15:43:59 -07004066
4067 struct sched_param param = {0};
4068 param.sched_priority = 1;
4069 if (sched_setscheduler(0, SCHED_FIFO, &param) != 0) {
4070 ALOGW("Couldn't set SCHED_FIFO on display on");
4071 }
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004072 } else if (mode == HWC_POWER_MODE_OFF) {
Tim Murrayf9d4e442016-08-02 15:43:59 -07004073 // Turn off the display
4074 struct sched_param param = {0};
4075 if (sched_setscheduler(0, SCHED_OTHER, &param) != 0) {
4076 ALOGW("Couldn't set SCHED_OTHER on display off");
4077 }
4078
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004079 if (display->isPrimary() && currentMode != HWC_POWER_MODE_DOZE_SUSPEND) {
Ana Krulece588e312018-09-18 12:32:24 -07004080 if (mUseScheduler) {
4081 mScheduler->disableHardwareVsync(true);
4082 } else {
4083 disableHardwareVsync(true); // also cancels any in-progress resync
4084 }
Ana Krulec98b5b242018-08-10 15:03:23 -07004085 if (mUseScheduler) {
4086 mScheduler->onScreenReleased(mAppConnectionHandle);
4087 } else {
4088 mEventThread->onScreenReleased();
4089 }
Mathias Agopiancde87a32012-09-13 14:09:01 -07004090 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004091
Dominik Laskowski075d3172018-05-24 15:50:06 -07004092 getHwComposer().setPowerMode(*displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004093 mVisibleRegionsDirty = true;
4094 // from this point on, SF will stop drawing on this display
Matthew Bouyack38d49612017-05-12 12:49:32 -07004095 } else if (mode == HWC_POWER_MODE_DOZE ||
4096 mode == HWC_POWER_MODE_NORMAL) {
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004097 // Update display while dozing
Dominik Laskowski075d3172018-05-24 15:50:06 -07004098 getHwComposer().setPowerMode(*displayId, mode);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004099 if (display->isPrimary() && currentMode == HWC_POWER_MODE_DOZE_SUSPEND) {
Ana Krulec98b5b242018-08-10 15:03:23 -07004100 if (mUseScheduler) {
4101 mScheduler->onScreenAcquired(mAppConnectionHandle);
4102 } else {
4103 mEventThread->onScreenAcquired();
4104 }
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004105 resyncToHardwareVsync(true);
4106 }
4107 } else if (mode == HWC_POWER_MODE_DOZE_SUSPEND) {
4108 // Leave display going to doze
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004109 if (display->isPrimary()) {
Ana Krulece588e312018-09-18 12:32:24 -07004110 if (mUseScheduler) {
4111 mScheduler->disableHardwareVsync(true);
4112 } else {
4113 disableHardwareVsync(true); // also cancels any in-progress resync
4114 }
Ana Krulec98b5b242018-08-10 15:03:23 -07004115 if (mUseScheduler) {
4116 mScheduler->onScreenReleased(mAppConnectionHandle);
4117 } else {
4118 mEventThread->onScreenReleased();
4119 }
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004120 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07004121 getHwComposer().setPowerMode(*displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004122 } else {
Matthew Bouyack38d49612017-05-12 12:49:32 -07004123 ALOGE("Attempting to set unknown power mode: %d\n", mode);
Dominik Laskowski075d3172018-05-24 15:50:06 -07004124 getHwComposer().setPowerMode(*displayId, mode);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004125 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004126
Yiwei Zhang3a226d22018-10-16 09:23:03 -07004127 if (display->isPrimary()) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08004128 mTimeStats->setPowerMode(mode);
Yiwei Zhang3a226d22018-10-16 09:23:03 -07004129 }
4130
Dominik Laskowski34157762018-10-31 13:07:19 -07004131 ALOGD("Finished setting power mode %d on display %s", mode, to_string(*displayId).c_str());
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004132}
4133
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004134void SurfaceFlinger::setPowerMode(const sp<IBinder>& displayToken, int mode) {
Dominik Laskowski8c001672018-05-30 16:52:06 -07004135 postMessageSync(new LambdaMessage([&] {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004136 const auto display = getDisplayDevice(displayToken);
4137 if (!display) {
4138 ALOGE("Attempt to set power mode %d for invalid display token %p", mode,
4139 displayToken.get());
4140 } else if (display->isVirtual()) {
4141 ALOGW("Attempt to set power mode %d for virtual display", mode);
4142 } else {
Dominik Laskowskie9774092018-12-11 10:04:24 -08004143 setPowerModeInternal(display, mode);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004144 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004145 }));
Mathias Agopianb60314a2012-04-10 22:09:54 -07004146}
4147
4148// ---------------------------------------------------------------------------
4149
Lloyd Pique755e3192018-01-31 16:46:15 -08004150status_t SurfaceFlinger::doDump(int fd, const Vector<String16>& args, bool asProto)
4151 NO_THREAD_SAFETY_ANALYSIS {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004152 std::string result;
Mathias Agopian99b49842011-06-27 16:05:52 -07004153
Mathias Agopianbd115332013-04-18 16:41:04 -07004154 IPCThreadState* ipc = IPCThreadState::self();
4155 const int pid = ipc->getCallingPid();
4156 const int uid = ipc->getCallingUid();
Vishnu Nair6a408532017-10-24 09:11:27 -07004157
Mathias Agopianbd115332013-04-18 16:41:04 -07004158 if ((uid != AID_SHELL) &&
4159 !PermissionCache::checkPermission(sDump, pid, uid)) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004160 StringAppendF(&result, "Permission Denial: can't dump SurfaceFlinger from pid=%d, uid=%d\n",
4161 pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004162 } else {
Jesse Hallfcd15b42014-12-23 13:57:23 -08004163 // Try to get the main lock, but give up after one second
Mathias Agopian9795c422009-08-26 16:36:26 -07004164 // (this would indicate SF is stuck, but we want to be able to
4165 // print something in dumpsys).
Jesse Hallfcd15b42014-12-23 13:57:23 -08004166 status_t err = mStateLock.timedLock(s2ns(1));
4167 bool locked = (err == NO_ERROR);
Mathias Agopian9795c422009-08-26 16:36:26 -07004168 if (!locked) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004169 StringAppendF(&result,
4170 "SurfaceFlinger appears to be unresponsive (%s [%d]), dumping anyways "
4171 "(no locks held)\n",
4172 strerror(-err), err);
Mathias Agopian9795c422009-08-26 16:36:26 -07004173 }
4174
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004175 bool dumpAll = true;
4176 size_t index = 0;
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004177 size_t numArgs = args.size();
chaviwa3d7bd32017-11-03 09:41:53 -07004178
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004179 if (numArgs) {
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004180 if ((index < numArgs) &&
4181 (args[index] == String16("--list"))) {
4182 index++;
Mathias Agopian74d211a2013-04-22 16:55:35 +02004183 listLayersLocked(args, index, result);
Mathias Agopian35aadd62012-03-08 22:01:51 -08004184 dumpAll = false;
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004185 }
4186
4187 if ((index < numArgs) &&
4188 (args[index] == String16("--latency"))) {
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004189 index++;
Mathias Agopian74d211a2013-04-22 16:55:35 +02004190 dumpStatsLocked(args, index, result);
Mathias Agopian35aadd62012-03-08 22:01:51 -08004191 dumpAll = false;
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004192 }
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004193
4194 if ((index < numArgs) &&
4195 (args[index] == String16("--latency-clear"))) {
4196 index++;
Mathias Agopian74d211a2013-04-22 16:55:35 +02004197 clearStatsLocked(args, index, result);
Mathias Agopian35aadd62012-03-08 22:01:51 -08004198 dumpAll = false;
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004199 }
Andy McFaddenc751e922014-05-08 14:53:26 -07004200
4201 if ((index < numArgs) &&
4202 (args[index] == String16("--dispsync"))) {
4203 index++;
Lloyd Pique41be5d22018-06-21 13:11:48 -07004204 mPrimaryDispSync->dump(result);
Andy McFaddenc751e922014-05-08 14:53:26 -07004205 dumpAll = false;
4206 }
Dan Stozab90cf072015-03-05 11:05:59 -08004207
4208 if ((index < numArgs) &&
4209 (args[index] == String16("--static-screen"))) {
4210 index++;
4211 dumpStaticScreenStats(result);
4212 dumpAll = false;
4213 }
Pablo Ceballos40845df2016-01-25 17:41:15 -08004214
4215 if ((index < numArgs) &&
Brian Andersond6927fb2016-07-23 23:37:30 -07004216 (args[index] == String16("--frame-events"))) {
Pablo Ceballos40845df2016-01-25 17:41:15 -08004217 index++;
Brian Andersond6927fb2016-07-23 23:37:30 -07004218 dumpFrameEventsLocked(result);
Pablo Ceballos40845df2016-01-25 17:41:15 -08004219 dumpAll = false;
4220 }
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004221
4222 if ((index < numArgs) && (args[index] == String16("--wide-color"))) {
4223 index++;
4224 dumpWideColorInfo(result);
4225 dumpAll = false;
4226 }
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004227
4228 if ((index < numArgs) &&
4229 (args[index] == String16("--enable-layer-stats"))) {
4230 index++;
4231 mLayerStats.enable();
4232 dumpAll = false;
4233 }
4234
4235 if ((index < numArgs) &&
4236 (args[index] == String16("--disable-layer-stats"))) {
4237 index++;
4238 mLayerStats.disable();
4239 dumpAll = false;
4240 }
4241
4242 if ((index < numArgs) &&
4243 (args[index] == String16("--clear-layer-stats"))) {
4244 index++;
4245 mLayerStats.clear();
4246 dumpAll = false;
4247 }
4248
4249 if ((index < numArgs) &&
4250 (args[index] == String16("--dump-layer-stats"))) {
4251 index++;
4252 mLayerStats.dump(result);
4253 dumpAll = false;
4254 }
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004255
4256 if ((index < numArgs) &&
David Sodman7e4ae112018-02-09 15:02:28 -08004257 (args[index] == String16("--frame-composition"))) {
4258 index++;
4259 dumpFrameCompositionInfo(result);
4260 dumpAll = false;
4261 }
4262
4263 if ((index < numArgs) &&
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004264 (args[index] == String16("--display-identification"))) {
4265 index++;
4266 dumpDisplayIdentificationData(result);
4267 dumpAll = false;
4268 }
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07004269
4270 if ((index < numArgs) && (args[index] == String16("--timestats"))) {
4271 index++;
Yiwei Zhang7e666a52018-11-15 13:33:42 -08004272 mTimeStats->parseArgs(asProto, args, index, result);
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07004273 dumpAll = false;
4274 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004275 }
Mathias Agopian1b5e1022010-04-20 17:55:49 -07004276
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004277 if (dumpAll) {
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07004278 if (asProto) {
4279 LayersProto layersProto = dumpProtoInfo(LayerVector::StateSet::Current);
4280 result.append(layersProto.SerializeAsString().c_str(), layersProto.ByteSize());
4281 } else {
4282 dumpAllLocked(args, index, result);
4283 }
Mathias Agopian48b888a2011-01-19 16:15:53 -08004284 }
4285
Mathias Agopian9795c422009-08-26 16:36:26 -07004286 if (locked) {
4287 mStateLock.unlock();
4288 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004289 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08004290 write(fd, result.c_str(), result.size());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004291 return NO_ERROR;
4292}
4293
Yiwei Zhang5434a782018-12-05 18:06:32 -08004294void SurfaceFlinger::listLayersLocked(const Vector<String16>& /* args */, size_t& /* index */,
4295 std::string& result) const {
4296 mCurrentState.traverseInZOrder(
4297 [&](Layer* layer) { StringAppendF(&result, "%s\n", layer->getName().string()); });
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004298}
4299
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004300void SurfaceFlinger::dumpStatsLocked(const Vector<String16>& args, size_t& index,
Yiwei Zhang5434a782018-12-05 18:06:32 -08004301 std::string& result) const {
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004302 String8 name;
4303 if (index < args.size()) {
4304 name = String8(args[index]);
4305 index++;
4306 }
4307
Dominik Laskowski075d3172018-05-24 15:50:06 -07004308 if (const auto displayId = getInternalDisplayId();
4309 displayId && getHwComposer().isConnected(*displayId)) {
4310 const auto activeConfig = getHwComposer().getActiveConfig(*displayId);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004311 const nsecs_t period = activeConfig->getVsyncPeriod();
Yiwei Zhang5434a782018-12-05 18:06:32 -08004312 StringAppendF(&result, "%" PRId64 "\n", period);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004313 }
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004314
4315 if (name.isEmpty()) {
Svetoslavd85084b2014-03-20 10:28:31 -07004316 mAnimFrameTracker.dumpStats(result);
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004317 } else {
Robert Carr2047fae2016-11-28 14:09:09 -08004318 mCurrentState.traverseInZOrder([&](Layer* layer) {
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004319 if (name == layer->getName()) {
Svetoslavd85084b2014-03-20 10:28:31 -07004320 layer->dumpFrameStats(result);
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004321 }
Robert Carr2047fae2016-11-28 14:09:09 -08004322 });
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004323 }
4324}
4325
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004326void SurfaceFlinger::clearStatsLocked(const Vector<String16>& args, size_t& index,
Yiwei Zhang5434a782018-12-05 18:06:32 -08004327 std::string& /* result */) {
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004328 String8 name;
4329 if (index < args.size()) {
4330 name = String8(args[index]);
4331 index++;
4332 }
4333
Robert Carr2047fae2016-11-28 14:09:09 -08004334 mCurrentState.traverseInZOrder([&](Layer* layer) {
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004335 if (name.isEmpty() || (name == layer->getName())) {
Svetoslavd85084b2014-03-20 10:28:31 -07004336 layer->clearFrameStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004337 }
Robert Carr2047fae2016-11-28 14:09:09 -08004338 });
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004339
Svetoslavd85084b2014-03-20 10:28:31 -07004340 mAnimFrameTracker.clearStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004341}
4342
Jamie Gennis6547ff42013-07-16 20:12:42 -07004343// This should only be called from the main thread. Otherwise it would need
4344// the lock and should use mCurrentState rather than mDrawingState.
4345void SurfaceFlinger::logFrameStats() {
Robert Carr2047fae2016-11-28 14:09:09 -08004346 mDrawingState.traverseInZOrder([&](Layer* layer) {
Jamie Gennis6547ff42013-07-16 20:12:42 -07004347 layer->logFrameStats();
Robert Carr2047fae2016-11-28 14:09:09 -08004348 });
Jamie Gennis6547ff42013-07-16 20:12:42 -07004349
4350 mAnimFrameTracker.logAndResetStats(String8("<win-anim>"));
4351}
4352
Yiwei Zhang5434a782018-12-05 18:06:32 -08004353void SurfaceFlinger::appendSfConfigString(std::string& result) const {
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004354 result.append(" [sf");
Fabien Sanglardc93afd52017-03-13 13:02:42 -07004355
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004356 if (isLayerTripleBufferingDisabled())
4357 result.append(" DISABLE_TRIPLE_BUFFERING");
Fabien Sanglardc45a7d92017-03-14 13:24:22 -07004358
Yiwei Zhang5434a782018-12-05 18:06:32 -08004359 StringAppendF(&result, " PRESENT_TIME_OFFSET=%" PRId64, dispSyncPresentTimeOffset);
4360 StringAppendF(&result, " FORCE_HWC_FOR_RBG_TO_YUV=%d", useHwcForRgbToYuv);
4361 StringAppendF(&result, " MAX_VIRT_DISPLAY_DIM=%" PRIu64, maxVirtualDisplaySize);
4362 StringAppendF(&result, " RUNNING_WITHOUT_SYNC_FRAMEWORK=%d", !hasSyncFramework);
4363 StringAppendF(&result, " NUM_FRAMEBUFFER_SURFACE_BUFFERS=%" PRId64,
4364 maxFrameBufferAcquiredBuffers);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004365 result.append("]");
Andy McFadden4803b742012-09-24 19:07:20 -07004366}
4367
Yiwei Zhang5434a782018-12-05 18:06:32 -08004368void SurfaceFlinger::dumpStaticScreenStats(std::string& result) const {
4369 result.append("Static screen stats:\n");
David Sodman4a36e932017-11-07 14:29:47 -08004370 for (size_t b = 0; b < SurfaceFlingerBE::NUM_BUCKETS - 1; ++b) {
4371 float bucketTimeSec = getBE().mFrameBuckets[b] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08004372 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08004373 static_cast<float>(getBE().mFrameBuckets[b]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004374 StringAppendF(&result, " < %zd frames: %.3f s (%.1f%%)\n", b + 1, bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08004375 }
David Sodman4a36e932017-11-07 14:29:47 -08004376 float bucketTimeSec = getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08004377 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08004378 static_cast<float>(getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004379 StringAppendF(&result, " %zd+ frames: %.3f s (%.1f%%)\n", SurfaceFlingerBE::NUM_BUCKETS - 1,
4380 bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08004381}
4382
Dan Stozae77c7662016-05-13 11:37:28 -07004383void SurfaceFlinger::recordBufferingStats(const char* layerName,
4384 std::vector<OccupancyTracker::Segment>&& history) {
David Sodmancbaf0832017-11-07 14:21:36 -08004385 Mutex::Autolock lock(getBE().mBufferingStatsMutex);
4386 auto& stats = getBE().mBufferingStats[layerName];
Dan Stozae77c7662016-05-13 11:37:28 -07004387 for (const auto& segment : history) {
4388 if (!segment.usedThirdBuffer) {
4389 stats.twoBufferTime += segment.totalTime;
4390 }
4391 if (segment.occupancyAverage < 1.0f) {
4392 stats.doubleBufferedTime += segment.totalTime;
4393 } else if (segment.occupancyAverage < 2.0f) {
4394 stats.tripleBufferedTime += segment.totalTime;
4395 }
4396 ++stats.numSegments;
4397 stats.totalTime += segment.totalTime;
4398 }
4399}
4400
Yiwei Zhang5434a782018-12-05 18:06:32 -08004401void SurfaceFlinger::dumpFrameEventsLocked(std::string& result) {
4402 result.append("Layer frame timestamps:\n");
Brian Andersond6927fb2016-07-23 23:37:30 -07004403
4404 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
4405 const size_t count = currentLayers.size();
4406 for (size_t i=0 ; i<count ; i++) {
4407 currentLayers[i]->dumpFrameEvents(result);
4408 }
4409}
4410
Yiwei Zhang5434a782018-12-05 18:06:32 -08004411void SurfaceFlinger::dumpBufferingStats(std::string& result) const {
Dan Stozae77c7662016-05-13 11:37:28 -07004412 result.append("Buffering stats:\n");
4413 result.append(" [Layer name] <Active time> <Two buffer> "
4414 "<Double buffered> <Triple buffered>\n");
David Sodmancbaf0832017-11-07 14:21:36 -08004415 Mutex::Autolock lock(getBE().mBufferingStatsMutex);
Dan Stozae77c7662016-05-13 11:37:28 -07004416 typedef std::tuple<std::string, float, float, float> BufferTuple;
4417 std::map<float, BufferTuple, std::greater<float>> sorted;
David Sodmancbaf0832017-11-07 14:21:36 -08004418 for (const auto& statsPair : getBE().mBufferingStats) {
Dan Stozae77c7662016-05-13 11:37:28 -07004419 const char* name = statsPair.first.c_str();
David Sodmancbaf0832017-11-07 14:21:36 -08004420 const SurfaceFlingerBE::BufferingStats& stats = statsPair.second;
Dan Stozae77c7662016-05-13 11:37:28 -07004421 if (stats.numSegments == 0) {
4422 continue;
4423 }
4424 float activeTime = ns2ms(stats.totalTime) / 1000.0f;
4425 float twoBufferRatio = static_cast<float>(stats.twoBufferTime) /
4426 stats.totalTime;
4427 float doubleBufferRatio = static_cast<float>(
4428 stats.doubleBufferedTime) / stats.totalTime;
4429 float tripleBufferRatio = static_cast<float>(
4430 stats.tripleBufferedTime) / stats.totalTime;
4431 sorted.insert({activeTime, {name, twoBufferRatio,
4432 doubleBufferRatio, tripleBufferRatio}});
4433 }
4434 for (const auto& sortedPair : sorted) {
4435 float activeTime = sortedPair.first;
4436 const BufferTuple& values = sortedPair.second;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004437 StringAppendF(&result, " [%s] %.2f %.3f %.3f %.3f\n", std::get<0>(values).c_str(),
4438 activeTime, std::get<1>(values), std::get<2>(values), std::get<3>(values));
Dan Stozae77c7662016-05-13 11:37:28 -07004439 }
4440 result.append("\n");
4441}
4442
Yiwei Zhang5434a782018-12-05 18:06:32 -08004443void SurfaceFlinger::dumpDisplayIdentificationData(std::string& result) const {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004444 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004445 const auto displayId = display->getId();
4446 if (!displayId) {
4447 continue;
4448 }
4449 const auto hwcDisplayId = getHwComposer().fromPhysicalDisplayId(*displayId);
Dominik Laskowski7e045462018-05-30 13:02:02 -07004450 if (!hwcDisplayId) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004451 continue;
4452 }
4453
Yiwei Zhang5434a782018-12-05 18:06:32 -08004454 StringAppendF(&result,
4455 "Display %s (HWC display %" PRIu64 "): ", to_string(*displayId).c_str(),
4456 *hwcDisplayId);
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004457 uint8_t port;
4458 DisplayIdentificationData data;
Dominik Laskowski7e045462018-05-30 13:02:02 -07004459 if (!getHwComposer().getDisplayIdentificationData(*hwcDisplayId, &port, &data)) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004460 result.append("no identification data\n");
4461 continue;
4462 }
4463
4464 if (!isEdid(data)) {
4465 result.append("unknown identification data: ");
4466 for (uint8_t byte : data) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004467 StringAppendF(&result, "%x ", byte);
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004468 }
4469 result.append("\n");
4470 continue;
4471 }
4472
4473 const auto edid = parseEdid(data);
4474 if (!edid) {
4475 result.append("invalid EDID: ");
4476 for (uint8_t byte : data) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004477 StringAppendF(&result, "%x ", byte);
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004478 }
4479 result.append("\n");
4480 continue;
4481 }
4482
Yiwei Zhang5434a782018-12-05 18:06:32 -08004483 StringAppendF(&result, "port=%u pnpId=%s displayName=\"", port, edid->pnpId.data());
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004484 result.append(edid->displayName.data(), edid->displayName.length());
4485 result.append("\"\n");
4486 }
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004487}
4488
Yiwei Zhang5434a782018-12-05 18:06:32 -08004489void SurfaceFlinger::dumpWideColorInfo(std::string& result) const {
4490 StringAppendF(&result, "Device has wide color display: %d\n", hasWideColorDisplay);
4491 StringAppendF(&result, "Device uses color management: %d\n", useColorManagement);
4492 StringAppendF(&result, "DisplayColorSetting: %s\n",
4493 decodeDisplayColorSetting(mDisplayColorSetting).c_str());
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004494
4495 // TODO: print out if wide-color mode is active or not
4496
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004497 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004498 const auto displayId = display->getId();
4499 if (!displayId) {
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004500 continue;
4501 }
4502
Yiwei Zhang5434a782018-12-05 18:06:32 -08004503 StringAppendF(&result, "Display %s color modes:\n", to_string(*displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004504 std::vector<ColorMode> modes = getHwComposer().getColorModes(*displayId);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004505 for (auto&& mode : modes) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004506 StringAppendF(&result, " %s (%d)\n", decodeColorMode(mode).c_str(), mode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004507 }
4508
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004509 ColorMode currentMode = display->getActiveColorMode();
Yiwei Zhang5434a782018-12-05 18:06:32 -08004510 StringAppendF(&result, " Current color mode: %s (%d)\n",
4511 decodeColorMode(currentMode).c_str(), currentMode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004512 }
4513 result.append("\n");
4514}
4515
Yiwei Zhang5434a782018-12-05 18:06:32 -08004516void SurfaceFlinger::dumpFrameCompositionInfo(std::string& result) const {
David Sodman7e4ae112018-02-09 15:02:28 -08004517 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski05275f12018-11-01 15:03:24 -07004518 const auto it = getBE().mEndOfFrameCompositionInfo.find(token);
4519 if (it == getBE().mEndOfFrameCompositionInfo.end()) {
David Sodman7e4ae112018-02-09 15:02:28 -08004520 continue;
4521 }
4522
Dominik Laskowski05275f12018-11-01 15:03:24 -07004523 const auto& compositionInfoList = it->second;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004524 StringAppendF(&result, "%s\n", display->getDebugName().c_str());
4525 StringAppendF(&result, "numComponents: %zu\n", compositionInfoList.size());
David Sodman7e4ae112018-02-09 15:02:28 -08004526 for (const auto& compositionInfo : compositionInfoList) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004527 compositionInfo.dump(result, nullptr);
4528 result.append("\n");
David Sodman7e4ae112018-02-09 15:02:28 -08004529 }
4530 }
David Sodman7e4ae112018-02-09 15:02:28 -08004531}
4532
Jorim Jaggi8e0af362017-11-14 16:28:28 +01004533LayersProto SurfaceFlinger::dumpProtoInfo(LayerVector::StateSet stateSet) const {
chaviw1d044282017-09-27 12:19:28 -07004534 LayersProto layersProto;
Jorim Jaggi8e0af362017-11-14 16:28:28 +01004535 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
4536 const State& state = useDrawing ? mDrawingState : mCurrentState;
4537 state.traverseInZOrder([&](Layer* layer) {
chaviw1d044282017-09-27 12:19:28 -07004538 LayerProto* layerProto = layersProto.add_layers();
Jorim Jaggi8e0af362017-11-14 16:28:28 +01004539 layer->writeToProto(layerProto, stateSet);
chaviw1d044282017-09-27 12:19:28 -07004540 });
4541
4542 return layersProto;
4543}
4544
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004545LayersProto SurfaceFlinger::dumpVisibleLayersProtoInfo(const DisplayDevice& display) const {
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004546 LayersProto layersProto;
Yiwei Zhang60d1a192018-03-07 14:52:28 -08004547
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004548 SizeProto* resolution = layersProto.mutable_resolution();
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004549 resolution->set_w(display.getWidth());
4550 resolution->set_h(display.getHeight());
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004551
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004552 layersProto.set_color_mode(decodeColorMode(display.getActiveColorMode()));
4553 layersProto.set_color_transform(decodeColorTransform(display.getColorTransform()));
4554 layersProto.set_global_transform(static_cast<int32_t>(display.getOrientationTransform()));
Yiwei Zhang60d1a192018-03-07 14:52:28 -08004555
Dominik Laskowski075d3172018-05-24 15:50:06 -07004556 const auto displayId = display.getId();
4557 LOG_ALWAYS_FATAL_IF(!displayId);
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004558 mDrawingState.traverseInZOrder([&](Layer* layer) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004559 if (!layer->visibleRegion.isEmpty() && layer->getBE().mHwcLayers.count(*displayId)) {
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004560 LayerProto* layerProto = layersProto.add_layers();
Dominik Laskowski075d3172018-05-24 15:50:06 -07004561 layer->writeToProto(layerProto, *displayId);
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004562 }
4563 });
4564
4565 return layersProto;
4566}
4567
Mathias Agopian74d211a2013-04-22 16:55:35 +02004568void SurfaceFlinger::dumpAllLocked(const Vector<String16>& args, size_t& index,
Yiwei Zhang5434a782018-12-05 18:06:32 -08004569 std::string& result) const {
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004570 bool colorize = false;
4571 if (index < args.size()
4572 && (args[index] == String16("--color"))) {
4573 colorize = true;
4574 index++;
4575 }
4576
4577 Colorizer colorizer(colorize);
4578
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004579 // figure out if we're stuck somewhere
4580 const nsecs_t now = systemTime();
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004581 const nsecs_t inTransaction(mDebugInTransaction);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004582 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
4583
4584 /*
Andy McFadden4803b742012-09-24 19:07:20 -07004585 * Dump library configuration.
4586 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004587
4588 colorizer.bold(result);
Andy McFadden4803b742012-09-24 19:07:20 -07004589 result.append("Build configuration:");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004590 colorizer.reset(result);
Andy McFadden4803b742012-09-24 19:07:20 -07004591 appendSfConfigString(result);
4592 appendUiConfigString(result);
4593 appendGuiConfigString(result);
4594 result.append("\n");
4595
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004596 result.append("\nDisplay identification data:\n");
4597 dumpDisplayIdentificationData(result);
4598
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004599 result.append("\nWide-Color information:\n");
4600 dumpWideColorInfo(result);
4601
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004602 colorizer.bold(result);
Mathias Agopianca088332013-03-28 17:44:13 -07004603 result.append("Sync configuration: ");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004604 colorizer.reset(result);
Mathias Agopianca088332013-03-28 17:44:13 -07004605 result.append(SyncFeatures::getInstance().toString());
4606 result.append("\n");
4607
Andy McFadden41d67d72014-04-25 16:58:34 -07004608 colorizer.bold(result);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004609 result.append("DispSync configuration:\n");
Andy McFadden41d67d72014-04-25 16:58:34 -07004610 colorizer.reset(result);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004611
Jorim Jaggi22ec38b2018-06-19 15:57:08 +02004612 const auto [sfEarlyOffset, appEarlyOffset] = mVsyncModulator.getEarlyOffsets();
4613 const auto [sfEarlyGlOffset, appEarlyGlOffset] = mVsyncModulator.getEarlyGlOffsets();
Dominik Laskowski075d3172018-05-24 15:50:06 -07004614 if (const auto displayId = getInternalDisplayId();
4615 displayId && getHwComposer().isConnected(*displayId)) {
4616 const auto activeConfig = getHwComposer().getActiveConfig(*displayId);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004617 StringAppendF(&result,
4618 "Display %s: app phase %" PRId64 " ns, "
4619 "sf phase %" PRId64 " ns, "
4620 "early app phase %" PRId64 " ns, "
4621 "early sf phase %" PRId64 " ns, "
4622 "early app gl phase %" PRId64 " ns, "
4623 "early sf gl phase %" PRId64 " ns, "
4624 "present offset %" PRId64 " ns (refresh %" PRId64 " ns)",
4625 to_string(*displayId).c_str(), vsyncPhaseOffsetNs, sfVsyncPhaseOffsetNs,
4626 appEarlyOffset, sfEarlyOffset, appEarlyGlOffset, sfEarlyGlOffset,
4627 dispSyncPresentTimeOffset, activeConfig->getVsyncPeriod());
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004628 }
Andy McFadden41d67d72014-04-25 16:58:34 -07004629 result.append("\n");
4630
Dan Stozab90cf072015-03-05 11:05:59 -08004631 // Dump static screen stats
4632 result.append("\n");
4633 dumpStaticScreenStats(result);
4634 result.append("\n");
4635
Yiwei Zhang5434a782018-12-05 18:06:32 -08004636 StringAppendF(&result, "Missed frame count: %u\n\n", mFrameMissedCount.load());
Marissa Wallcfcdaa52018-05-21 15:45:59 -07004637
Dan Stozae77c7662016-05-13 11:37:28 -07004638 dumpBufferingStats(result);
4639
Andy McFadden4803b742012-09-24 19:07:20 -07004640 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004641 * Dump the visible layer list
4642 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004643 colorizer.bold(result);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004644 StringAppendF(&result, "Visible layers (count = %zu)\n", mNumLayers);
4645 StringAppendF(&result, "GraphicBufferProducers: %zu, max %zu\n",
4646 mGraphicBufferProducerList.size(), mMaxGraphicBufferProducerListSize);
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004647 colorizer.reset(result);
chaviw1d044282017-09-27 12:19:28 -07004648
Chia-I Wu2f884132018-09-13 15:17:58 -07004649 {
4650 LayersProto layersProto = dumpProtoInfo(LayerVector::StateSet::Current);
4651 auto layerTree = LayerProtoParser::generateLayerTree(layersProto);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004652 result.append(LayerProtoParser::layerTreeToString(layerTree));
Chia-I Wu2f884132018-09-13 15:17:58 -07004653 result.append("\n");
4654 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004655
David Sodman7e4ae112018-02-09 15:02:28 -08004656 result.append("\nFrame-Composition information:\n");
4657 dumpFrameCompositionInfo(result);
4658 result.append("\n");
4659
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004660 /*
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004661 * Dump Display state
4662 */
4663
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004664 colorizer.bold(result);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004665 StringAppendF(&result, "Displays (%zu entries)\n", mDisplays.size());
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004666 colorizer.reset(result);
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004667 for (const auto& [token, display] : mDisplays) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004668 display->dump(result);
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004669 }
Chia-I Wu1e043612018-03-01 09:45:09 -08004670 result.append("\n");
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004671
4672 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004673 * Dump SurfaceFlinger global state
4674 */
4675
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004676 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02004677 result.append("SurfaceFlinger global state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004678 colorizer.reset(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004679
David Sodmanbc815282017-11-05 18:57:52 -08004680 getBE().mRenderEngine->dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004681
Dominik Laskowski075d3172018-05-24 15:50:06 -07004682 if (const auto display = getDefaultDisplayDeviceLocked()) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004683 display->undefinedRegion.dump(result, "undefinedRegion");
Yiwei Zhang5434a782018-12-05 18:06:32 -08004684 StringAppendF(&result, " orientation=%d, isPoweredOn=%d\n", display->getOrientation(),
4685 display->isPoweredOn());
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08004686 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08004687 StringAppendF(&result,
4688 " transaction-flags : %08x\n"
4689 " gpu_to_cpu_unsupported : %d\n",
4690 mTransactionFlags.load(), !mGpuToCpuSupported);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004691
Dominik Laskowski075d3172018-05-24 15:50:06 -07004692 if (const auto displayId = getInternalDisplayId();
4693 displayId && getHwComposer().isConnected(*displayId)) {
4694 const auto activeConfig = getHwComposer().getActiveConfig(*displayId);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004695 StringAppendF(&result,
4696 " refresh-rate : %f fps\n"
4697 " x-dpi : %f\n"
4698 " y-dpi : %f\n",
4699 1e9 / activeConfig->getVsyncPeriod(), activeConfig->getDpiX(),
4700 activeConfig->getDpiY());
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004701 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004702
Yiwei Zhang5434a782018-12-05 18:06:32 -08004703 StringAppendF(&result, " transaction time: %f us\n", inTransactionDuration / 1000.0);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004704
Yiwei Zhang5434a782018-12-05 18:06:32 -08004705 StringAppendF(&result, " use Scheduler: %s\n", mUseScheduler ? "true" : "false");
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004706 /*
4707 * VSYNC state
4708 */
Ana Krulec98b5b242018-08-10 15:03:23 -07004709 if (mUseScheduler) {
4710 mScheduler->dump(mAppConnectionHandle, result);
4711 } else {
4712 mEventThread->dump(result);
4713 }
Dan Stozae22aec72016-08-01 13:20:59 -07004714 result.append("\n");
4715
4716 /*
Yichi Chenadc69612018-09-15 14:51:18 +08004717 * Tracing state
4718 */
4719 mTracing.dump(result);
4720 result.append("\n");
4721
4722 /*
Dan Stozae22aec72016-08-01 13:20:59 -07004723 * HWC layer minidump
4724 */
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004725 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004726 const auto displayId = display->getId();
4727 if (!displayId) {
Dan Stozae22aec72016-08-01 13:20:59 -07004728 continue;
4729 }
4730
Yiwei Zhang5434a782018-12-05 18:06:32 -08004731 StringAppendF(&result, "Display %s HWC layers:\n", to_string(*displayId).c_str());
Dan Stozae22aec72016-08-01 13:20:59 -07004732 Layer::miniDumpHeader(result);
Dominik Laskowski075d3172018-05-24 15:50:06 -07004733 mCurrentState.traverseInZOrder([&](Layer* layer) { layer->miniDump(result, *displayId); });
Dan Stozae22aec72016-08-01 13:20:59 -07004734 result.append("\n");
4735 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004736
4737 /*
4738 * Dump HWComposer state
4739 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004740 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02004741 result.append("h/w composer state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004742 colorizer.reset(result);
Dan Stoza9f26a9c2016-06-22 14:51:09 -07004743 bool hwcDisabled = mDebugDisableHWC || mDebugRegion;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004744 StringAppendF(&result, " h/w composer %s\n", hwcDisabled ? "disabled" : "enabled");
Dominik Laskowski075d3172018-05-24 15:50:06 -07004745 getHwComposer().dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004746
4747 /*
4748 * Dump gralloc state
4749 */
4750 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
4751 alloc.dump(result);
Karthik Ravi Shankar171155a2017-06-28 15:40:24 -07004752
4753 /*
4754 * Dump VrFlinger state if in use.
4755 */
4756 if (mVrFlingerRequestsDisplay && mVrFlinger) {
4757 result.append("VrFlinger state:\n");
Yiwei Zhang5434a782018-12-05 18:06:32 -08004758 result.append(mVrFlinger->Dump());
Karthik Ravi Shankar171155a2017-06-28 15:40:24 -07004759 result.append("\n");
4760 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004761}
4762
Dominik Laskowski075d3172018-05-24 15:50:06 -07004763const Vector<sp<Layer>>& SurfaceFlinger::getLayerSortedByZForHwcDisplay(DisplayId displayId) {
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07004764 // Note: mStateLock is held here
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004765 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski7e045462018-05-30 13:02:02 -07004766 if (display->getId() == displayId) {
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004767 return getDisplayDeviceLocked(token)->getVisibleLayersSortedByZ();
Jesse Hall48bc05b2013-03-21 14:06:52 -07004768 }
4769 }
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004770
Dominik Laskowski34157762018-10-31 13:07:19 -07004771 ALOGE("%s: Invalid display %s", __FUNCTION__, to_string(displayId).c_str());
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004772 static const Vector<sp<Layer>> empty;
4773 return empty;
Mathias Agopiancb558572012-10-04 15:58:54 -07004774}
4775
Keun young Park63f165f2012-08-31 10:53:36 -07004776bool SurfaceFlinger::startDdmConnection()
4777{
4778 void* libddmconnection_dso =
4779 dlopen("libsurfaceflinger_ddmconnection.so", RTLD_NOW);
4780 if (!libddmconnection_dso) {
4781 return false;
4782 }
4783 void (*DdmConnection_start)(const char* name);
4784 DdmConnection_start =
Jesse Hall24cd98e2014-07-13 14:37:16 -07004785 (decltype(DdmConnection_start))dlsym(libddmconnection_dso, "DdmConnection_start");
Keun young Park63f165f2012-08-31 10:53:36 -07004786 if (!DdmConnection_start) {
4787 dlclose(libddmconnection_dso);
4788 return false;
4789 }
4790 (*DdmConnection_start)(getServiceName());
4791 return true;
4792}
4793
Chia-I Wu28f320b2018-05-03 11:02:56 -07004794void SurfaceFlinger::updateColorMatrixLocked() {
4795 mat4 colorMatrix;
4796 if (mGlobalSaturationFactor != 1.0f) {
4797 // Rec.709 luma coefficients
4798 float3 luminance{0.213f, 0.715f, 0.072f};
4799 luminance *= 1.0f - mGlobalSaturationFactor;
4800 mat4 saturationMatrix = mat4(
4801 vec4{luminance.r + mGlobalSaturationFactor, luminance.r, luminance.r, 0.0f},
4802 vec4{luminance.g, luminance.g + mGlobalSaturationFactor, luminance.g, 0.0f},
4803 vec4{luminance.b, luminance.b, luminance.b + mGlobalSaturationFactor, 0.0f},
4804 vec4{0.0f, 0.0f, 0.0f, 1.0f}
4805 );
4806 colorMatrix = mClientColorMatrix * saturationMatrix * mDaltonizer();
4807 } else {
4808 colorMatrix = mClientColorMatrix * mDaltonizer();
4809 }
4810
4811 if (mCurrentState.colorMatrix != colorMatrix) {
4812 mCurrentState.colorMatrix = colorMatrix;
4813 mCurrentState.colorMatrixChanged = true;
4814 setTransactionFlags(eTransactionNeeded);
4815 }
4816}
4817
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07004818status_t SurfaceFlinger::CheckTransactCodeCredentials(uint32_t code) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004819#pragma clang diagnostic push
4820#pragma clang diagnostic error "-Wswitch-enum"
4821 switch (static_cast<ISurfaceComposerTag>(code)) {
4822 // These methods should at minimum make sure that the client requested
4823 // access to SF.
Dan Stozae3344402018-08-20 19:53:42 +00004824 case BOOT_FINISHED:
4825 case CLEAR_ANIMATION_FRAME_STATS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004826 case CREATE_DISPLAY:
4827 case DESTROY_DISPLAY:
Dan Stozae3344402018-08-20 19:53:42 +00004828 case ENABLE_VSYNC_INJECTIONS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004829 case GET_ACTIVE_COLOR_MODE:
4830 case GET_ANIMATION_FRAME_STATS:
4831 case GET_HDR_CAPABILITIES:
4832 case SET_ACTIVE_CONFIG:
4833 case SET_ACTIVE_COLOR_MODE:
Chia-I Wu90f669f2017-10-05 14:24:41 -07004834 case INJECT_VSYNC:
Kevin DuBois9c0a1762018-10-16 13:32:31 -07004835 case SET_POWER_MODE:
Kevin DuBois74e53772018-11-19 10:52:38 -08004836 case GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES:
Kevin DuBois1d4249a2018-08-29 10:45:14 -07004837 case SET_DISPLAY_CONTENT_SAMPLING_ENABLED:
4838 case GET_DISPLAYED_CONTENT_SAMPLE: {
Robert Carrd4ae7f32018-06-07 16:10:57 -07004839 if (!callingThreadHasUnscopedSurfaceFlingerAccess()) {
4840 IPCThreadState* ipc = IPCThreadState::self();
4841 ALOGE("Permission Denial: can't access SurfaceFlinger pid=%d, uid=%d",
4842 ipc->getCallingPid(), ipc->getCallingUid());
Mathias Agopian375f5632009-06-15 18:24:59 -07004843 return PERMISSION_DENIED;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004844 }
Robert Carr1db73f62016-12-21 12:58:51 -08004845 return OK;
4846 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004847 case GET_LAYER_DEBUG_INFO: {
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07004848 IPCThreadState* ipc = IPCThreadState::self();
4849 const int pid = ipc->getCallingPid();
4850 const int uid = ipc->getCallingUid();
Ana Krulec13be8ad2018-08-21 02:43:56 +00004851 if ((uid != AID_SHELL) && !PermissionCache::checkPermission(sDump, pid, uid)) {
4852 ALOGE("Layer debug info permission denied for pid=%d, uid=%d", pid, uid);
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07004853 return PERMISSION_DENIED;
4854 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004855 return OK;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004856 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004857 // Used by apps to hook Choreographer to SurfaceFlinger.
4858 case CREATE_DISPLAY_EVENT_CONNECTION:
4859 // The following calls are currently used by clients that do not
4860 // request necessary permissions. However, they do not expose any secret
4861 // information, so it is OK to pass them.
4862 case AUTHENTICATE_SURFACE:
4863 case GET_ACTIVE_CONFIG:
4864 case GET_BUILT_IN_DISPLAY:
4865 case GET_DISPLAY_COLOR_MODES:
4866 case GET_DISPLAY_CONFIGS:
4867 case GET_DISPLAY_STATS:
4868 case GET_SUPPORTED_FRAME_TIMESTAMPS:
4869 // Calling setTransactionState is safe, because you need to have been
4870 // granted a reference to Client* and Handle* to do anything with it.
4871 case SET_TRANSACTION_STATE:
Robert Carrb89ea9d2018-12-10 13:01:14 -08004872 case CREATE_CONNECTION:
Ady Abraham37965d42018-11-01 13:43:32 -07004873 case GET_COLOR_MANAGEMENT:
Peiyong Lin0256f722018-08-31 15:45:10 -07004874 case GET_COMPOSITION_PREFERENCE: {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004875 return OK;
4876 }
4877 case CAPTURE_LAYERS:
4878 case CAPTURE_SCREEN: {
4879 // codes that require permission check
chaviwa76b2712017-09-20 12:02:26 -07004880 IPCThreadState* ipc = IPCThreadState::self();
4881 const int pid = ipc->getCallingPid();
4882 const int uid = ipc->getCallingUid();
4883 if ((uid != AID_GRAPHICS) &&
4884 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
4885 ALOGE("Permission Denial: can't read framebuffer pid=%d, uid=%d", pid, uid);
4886 return PERMISSION_DENIED;
4887 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004888 return OK;
4889 }
4890 // The following codes are deprecated and should never be allowed to access SF.
4891 case CONNECT_DISPLAY_UNUSED:
4892 case CREATE_GRAPHIC_BUFFER_ALLOC_UNUSED: {
4893 ALOGE("Attempting to access SurfaceFlinger with unused code: %u", code);
4894 return PERMISSION_DENIED;
chaviwa76b2712017-09-20 12:02:26 -07004895 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004896 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004897
4898 // These codes are used for the IBinder protocol to either interrogate the recipient
4899 // side of the transaction for its canonical interface descriptor or to dump its state.
4900 // We let them pass by default.
4901 if (code == IBinder::INTERFACE_TRANSACTION || code == IBinder::DUMP_TRANSACTION ||
4902 code == IBinder::PING_TRANSACTION || code == IBinder::SHELL_COMMAND_TRANSACTION ||
4903 code == IBinder::SYSPROPS_TRANSACTION) {
4904 return OK;
4905 }
Peiyong Lin9d846a52018-11-05 13:18:20 -08004906 // Numbers from 1000 to 1031 are currently use for backdoors. The code
Ana Krulec13be8ad2018-08-21 02:43:56 +00004907 // in onTransact verifies that the user is root, and has access to use SF.
Peiyong Lin9d846a52018-11-05 13:18:20 -08004908 if (code >= 1000 && code <= 1031) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004909 ALOGV("Accessing SurfaceFlinger through backdoor code: %u", code);
4910 return OK;
4911 }
4912 ALOGE("Permission Denial: SurfaceFlinger did not recognize request code: %u", code);
4913 return PERMISSION_DENIED;
4914#pragma clang diagnostic pop
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07004915}
4916
Ana Krulec13be8ad2018-08-21 02:43:56 +00004917status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
4918 uint32_t flags) {
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07004919 status_t credentialCheck = CheckTransactCodeCredentials(code);
4920 if (credentialCheck != OK) {
4921 return credentialCheck;
4922 }
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07004923
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004924 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
4925 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
Mathias Agopianb8a55602009-06-26 19:06:36 -07004926 CHECK_INTERFACE(ISurfaceComposer, data, reply);
Romain Guy8c6bbd62017-06-05 13:51:43 -07004927 IPCThreadState* ipc = IPCThreadState::self();
4928 const int uid = ipc->getCallingUid();
4929 if (CC_UNLIKELY(uid != AID_SYSTEM
4930 && !PermissionCache::checkCallingPermission(sHardwareTest))) {
Mathias Agopian375f5632009-06-15 18:24:59 -07004931 const int pid = ipc->getCallingPid();
Steve Blocke6f43dd2012-01-06 19:20:56 +00004932 ALOGE("Permission Denial: "
Mathias Agopian375f5632009-06-15 18:24:59 -07004933 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004934 return PERMISSION_DENIED;
4935 }
4936 int n;
4937 switch (code) {
Mathias Agopian01b76682009-04-16 20:04:08 -07004938 case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
Mathias Agopian35b48d12010-09-13 22:57:58 -07004939 case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004940 return NO_ERROR;
4941 case 1002: // SHOW_UPDATES
4942 n = data.readInt32();
4943 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
Mathias Agopian53331da2011-08-22 21:44:41 -07004944 invalidateHwcGeometry();
4945 repaintEverything();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004946 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004947 case 1004:{ // repaint everything
Mathias Agopian53331da2011-08-22 21:44:41 -07004948 repaintEverything();
Mathias Agopiancbb288b2009-09-07 16:32:45 -07004949 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004950 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -07004951 case 1005:{ // force transaction
Steven Thomas6d8110b2017-08-31 18:24:21 -07004952 Mutex::Autolock _l(mStateLock);
Mathias Agopiane57f2922012-08-09 16:29:12 -07004953 setTransactionFlags(
4954 eTransactionNeeded|
4955 eDisplayTransactionNeeded|
4956 eTraversalNeeded);
Mathias Agopiancbb288b2009-09-07 16:32:45 -07004957 return NO_ERROR;
4958 }
Mathias Agopian4d143ee2012-02-23 20:05:39 -08004959 case 1006:{ // send empty update
4960 signalRefresh();
4961 return NO_ERROR;
4962 }
Mathias Agopian53331da2011-08-22 21:44:41 -07004963 case 1008: // toggle use of hw composer
4964 n = data.readInt32();
4965 mDebugDisableHWC = n ? 1 : 0;
4966 invalidateHwcGeometry();
4967 repaintEverything();
4968 return NO_ERROR;
Mathias Agopiana4583642011-08-23 18:03:18 -07004969 case 1009: // toggle use of transform hint
4970 n = data.readInt32();
4971 mDebugDisableTransformHint = n ? 1 : 0;
4972 invalidateHwcGeometry();
4973 repaintEverything();
4974 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004975 case 1010: // interrogate.
Mathias Agopian01b76682009-04-16 20:04:08 -07004976 reply->writeInt32(0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004977 reply->writeInt32(0);
4978 reply->writeInt32(mDebugRegion);
Mathias Agopianb9494d52012-04-18 02:28:45 -07004979 reply->writeInt32(0);
Dianne Hackborn12839be2012-02-06 21:21:05 -08004980 reply->writeInt32(mDebugDisableHWC);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004981 return NO_ERROR;
4982 case 1013: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004983 const auto display = getDefaultDisplayDevice();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004984 if (!display) {
4985 return NAME_NOT_FOUND;
4986 }
4987
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004988 reply->writeInt32(display->getPageFlipCount());
Mathias Agopianff2ed702013-09-01 21:36:12 -07004989 return NO_ERROR;
4990 }
4991 case 1014: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07004992 Mutex::Autolock _l(mStateLock);
Mathias Agopianff2ed702013-09-01 21:36:12 -07004993 // daltonize
4994 n = data.readInt32();
4995 switch (n % 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07004996 case 1:
4997 mDaltonizer.setType(ColorBlindnessType::Protanomaly);
4998 break;
4999 case 2:
5000 mDaltonizer.setType(ColorBlindnessType::Deuteranomaly);
5001 break;
5002 case 3:
5003 mDaltonizer.setType(ColorBlindnessType::Tritanomaly);
5004 break;
5005 default:
5006 mDaltonizer.setType(ColorBlindnessType::None);
5007 break;
Mathias Agopianff2ed702013-09-01 21:36:12 -07005008 }
5009 if (n >= 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005010 mDaltonizer.setMode(ColorBlindnessMode::Correction);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005011 } else {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005012 mDaltonizer.setMode(ColorBlindnessMode::Simulation);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005013 }
Chia-I Wu28f320b2018-05-03 11:02:56 -07005014
5015 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005016 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005017 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005018 case 1015: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005019 Mutex::Autolock _l(mStateLock);
Alan Viverette9c5a3332013-09-12 20:04:35 -07005020 // apply a color matrix
5021 n = data.readInt32();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005022 if (n) {
Romain Guy0147a172017-06-01 13:53:56 -07005023 // color matrix is sent as a column-major mat4 matrix
Alan Viverette794c5ba2013-10-03 16:40:52 -07005024 for (size_t i = 0 ; i < 4; i++) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005025 for (size_t j = 0; j < 4; j++) {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005026 mClientColorMatrix[i][j] = data.readFloat();
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005027 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005028 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005029 } else {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005030 mClientColorMatrix = mat4();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005031 }
Romain Guy88d37dd2017-05-26 17:57:05 -07005032
5033 // Check that supplied matrix's last row is {0,0,0,1} so we can avoid
5034 // the division by w in the fragment shader
Chia-I Wu28f320b2018-05-03 11:02:56 -07005035 float4 lastRow(transpose(mClientColorMatrix)[3]);
Romain Guy88d37dd2017-05-26 17:57:05 -07005036 if (any(greaterThan(abs(lastRow - float4{0, 0, 0, 1}), float4{1e-4f}))) {
5037 ALOGE("The color transform's last row must be (0, 0, 0, 1)");
5038 }
5039
Chia-I Wu28f320b2018-05-03 11:02:56 -07005040 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005041 return NO_ERROR;
5042 }
Ruchi Kandoif52b3c82014-04-24 16:42:35 -07005043 // This is an experimental interface
5044 // Needs to be shifted to proper binder interface when we productize
5045 case 1016: {
Andy McFadden645b1f72014-06-10 14:43:32 -07005046 n = data.readInt32();
Ana Krulece588e312018-09-18 12:32:24 -07005047 // TODO(b/113612090): Evaluate if this can be removed.
Lloyd Pique41be5d22018-06-21 13:11:48 -07005048 mPrimaryDispSync->setRefreshSkipCount(n);
Ruchi Kandoif52b3c82014-04-24 16:42:35 -07005049 return NO_ERROR;
5050 }
Dan Stozaee44edd2015-03-23 15:50:23 -07005051 case 1017: {
5052 n = data.readInt32();
5053 mForceFullDamage = static_cast<bool>(n);
5054 return NO_ERROR;
5055 }
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005056 case 1018: { // Modify Choreographer's phase offset
5057 n = data.readInt32();
Ana Krulec98b5b242018-08-10 15:03:23 -07005058 if (mUseScheduler) {
5059 mScheduler->setPhaseOffset(mAppConnectionHandle, static_cast<nsecs_t>(n));
5060 } else {
5061 mEventThread->setPhaseOffset(static_cast<nsecs_t>(n));
5062 }
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005063 return NO_ERROR;
5064 }
5065 case 1019: { // Modify SurfaceFlinger's phase offset
5066 n = data.readInt32();
Ana Krulec98b5b242018-08-10 15:03:23 -07005067 if (mUseScheduler) {
5068 mScheduler->setPhaseOffset(mSfConnectionHandle, static_cast<nsecs_t>(n));
5069 } else {
5070 mSFEventThread->setPhaseOffset(static_cast<nsecs_t>(n));
5071 }
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005072 return NO_ERROR;
5073 }
Irvel468051e2016-06-13 16:44:44 -07005074 case 1020: { // Layer updates interceptor
5075 n = data.readInt32();
5076 if (n) {
5077 ALOGV("Interceptor enabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08005078 mInterceptor->enable(mDrawingState.layersSortedByZ, mDrawingState.displays);
Irvel468051e2016-06-13 16:44:44 -07005079 }
5080 else{
5081 ALOGV("Interceptor disabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08005082 mInterceptor->disable();
Irvel468051e2016-06-13 16:44:44 -07005083 }
5084 return NO_ERROR;
5085 }
Dan Stoza8cf150a2016-08-02 10:27:31 -07005086 case 1021: { // Disable HWC virtual displays
5087 n = data.readInt32();
5088 mUseHwcVirtualDisplays = !n;
5089 return NO_ERROR;
5090 }
Romain Guy0147a172017-06-01 13:53:56 -07005091 case 1022: { // Set saturation boost
Chia-I Wu28f320b2018-05-03 11:02:56 -07005092 Mutex::Autolock _l(mStateLock);
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005093 mGlobalSaturationFactor = std::max(0.0f, std::min(data.readFloat(), 2.0f));
Romain Guy0147a172017-06-01 13:53:56 -07005094
Chia-I Wu28f320b2018-05-03 11:02:56 -07005095 updateColorMatrixLocked();
Romain Guy0147a172017-06-01 13:53:56 -07005096 return NO_ERROR;
5097 }
Romain Guy54f154a2017-10-24 21:40:32 +01005098 case 1023: { // Set native mode
Chia-I Wu0d711262018-05-21 15:19:35 -07005099 mDisplayColorSetting = static_cast<DisplayColorSetting>(data.readInt32());
Romain Guy54f154a2017-10-24 21:40:32 +01005100 invalidateHwcGeometry();
5101 repaintEverything();
5102 return NO_ERROR;
5103 }
Peiyong Lin4bac91c2018-10-25 09:48:33 -07005104 // Deprecate, use 1030 to check whether the device is color managed.
5105 case 1024: {
5106 return NAME_NOT_FOUND;
Romain Guy54f154a2017-10-24 21:40:32 +01005107 }
Vishnu Nair87704c92018-01-08 15:32:57 -08005108 case 1025: { // Set layer tracing
Adrian Roos1e1a1282017-11-01 19:05:31 +01005109 n = data.readInt32();
5110 if (n) {
Yichi Chenadc69612018-09-15 14:51:18 +08005111 ALOGD("LayerTracing enabled");
Adrian Roos1e1a1282017-11-01 19:05:31 +01005112 mTracing.enable();
5113 doTracing("tracing.enable");
5114 reply->writeInt32(NO_ERROR);
5115 } else {
Yichi Chenadc69612018-09-15 14:51:18 +08005116 ALOGD("LayerTracing disabled");
Adrian Roos1e1a1282017-11-01 19:05:31 +01005117 status_t err = mTracing.disable();
5118 reply->writeInt32(err);
5119 }
5120 return NO_ERROR;
5121 }
Vishnu Nair87704c92018-01-08 15:32:57 -08005122 case 1026: { // Get layer tracing status
5123 reply->writeBool(mTracing.isEnabled());
5124 return NO_ERROR;
5125 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005126 // Is a DisplayColorSetting supported?
5127 case 1027: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005128 const auto display = getDefaultDisplayDevice();
5129 if (!display) {
Chia-I Wu0d711262018-05-21 15:19:35 -07005130 return NAME_NOT_FOUND;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005131 }
Chia-I Wu0d711262018-05-21 15:19:35 -07005132
5133 DisplayColorSetting setting = static_cast<DisplayColorSetting>(data.readInt32());
5134 switch (setting) {
5135 case DisplayColorSetting::MANAGED:
Peiyong Lin13effd12018-07-24 17:01:47 -07005136 reply->writeBool(useColorManagement);
Chia-I Wu0d711262018-05-21 15:19:35 -07005137 break;
5138 case DisplayColorSetting::UNMANAGED:
5139 reply->writeBool(true);
5140 break;
5141 case DisplayColorSetting::ENHANCED:
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005142 reply->writeBool(display->hasRenderIntent(RenderIntent::ENHANCE));
Chia-I Wu0d711262018-05-21 15:19:35 -07005143 break;
5144 default: // vendor display color setting
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005145 reply->writeBool(
5146 display->hasRenderIntent(static_cast<RenderIntent>(setting)));
Chia-I Wu0d711262018-05-21 15:19:35 -07005147 break;
5148 }
5149 return NO_ERROR;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005150 }
Steven Thomas97f1f4c2018-06-01 12:04:16 -07005151 // Is VrFlinger active?
5152 case 1028: {
5153 Mutex::Autolock _l(mStateLock);
5154 reply->writeBool(getBE().mHwc->isUsingVrComposer());
5155 return NO_ERROR;
5156 }
Peiyong Lin13effd12018-07-24 17:01:47 -07005157 // Is device color managed?
5158 case 1030: {
5159 reply->writeBool(useColorManagement);
5160 return NO_ERROR;
5161 }
Peiyong Lin9d846a52018-11-05 13:18:20 -08005162 // Override default composition data space
5163 // adb shell service call SurfaceFlinger 1031 i32 1 DATASPACE_NUMBER DATASPACE_NUMBER \
5164 // && adb shell stop zygote && adb shell start zygote
5165 // to restore: adb shell service call SurfaceFlinger 1031 i32 0 && \
5166 // adb shell stop zygote && adb shell start zygote
5167 case 1031: {
5168 Mutex::Autolock _l(mStateLock);
5169 n = data.readInt32();
5170 if (n) {
5171 n = data.readInt32();
5172 if (n) {
5173 Dataspace dataspace = static_cast<Dataspace>(n);
5174 if (!validateCompositionDataspace(dataspace)) {
5175 return BAD_VALUE;
5176 }
5177 mDefaultCompositionDataspace = dataspace;
5178 }
5179 n = data.readInt32();
5180 if (n) {
5181 Dataspace dataspace = static_cast<Dataspace>(n);
5182 if (!validateCompositionDataspace(dataspace)) {
5183 return BAD_VALUE;
5184 }
5185 mWideColorGamutCompositionDataspace = dataspace;
5186 }
5187 } else {
5188 // restore composition data space.
5189 mDefaultCompositionDataspace = defaultCompositionDataspace;
5190 mWideColorGamutCompositionDataspace = wideColorGamutCompositionDataspace;
5191 }
5192 return NO_ERROR;
5193 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005194 }
5195 }
5196 return err;
5197}
5198
Steven Thomas6d8110b2017-08-31 18:24:21 -07005199void SurfaceFlinger::repaintEverything() {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07005200 mRepaintEverything = true;
Dan Stozac7a25ad2018-04-12 11:45:09 -07005201 signalTransaction();
Steven Thomas6d8110b2017-08-31 18:24:21 -07005202}
5203
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005204// A simple RAII class to disconnect from an ANativeWindow* when it goes out of scope
5205class WindowDisconnector {
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005206public:
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005207 WindowDisconnector(ANativeWindow* window, int api) : mWindow(window), mApi(api) {}
5208 ~WindowDisconnector() {
5209 native_window_api_disconnect(mWindow, mApi);
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005210 }
5211
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005212private:
5213 ANativeWindow* mWindow;
5214 const int mApi;
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005215};
5216
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005217status_t SurfaceFlinger::captureScreen(const sp<IBinder>& displayToken,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005218 sp<GraphicBuffer>* outBuffer, const Dataspace reqDataspace,
5219 const ui::PixelFormat reqPixelFormat, Rect sourceCrop,
chaviw0e3479f2018-09-10 16:49:30 -07005220 uint32_t reqWidth, uint32_t reqHeight,
5221 bool useIdentityTransform,
chaviwa76b2712017-09-20 12:02:26 -07005222 ISurfaceComposer::Rotation rotation) {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005223 ATRACE_CALL();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005224
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005225 if (!displayToken) return BAD_VALUE;
chaviwa76b2712017-09-20 12:02:26 -07005226
Chia-I Wuc80dcbb2018-08-24 15:34:02 -07005227 auto renderAreaRotation = fromSurfaceComposerRotation(rotation);
5228
Chia-I Wu20261cb2018-08-23 12:55:44 -07005229 sp<DisplayDevice> display;
5230 {
5231 Mutex::Autolock _l(mStateLock);
Garfield Tan3b1b8af2018-03-16 17:37:33 -07005232
Chia-I Wu20261cb2018-08-23 12:55:44 -07005233 display = getDisplayDeviceLocked(displayToken);
5234 if (!display) return BAD_VALUE;
5235
Chia-I Wucb023152018-08-28 12:57:23 -07005236 // set the requested width/height to the logical display viewport size
5237 // by default
5238 if (reqWidth == 0 || reqHeight == 0) {
5239 reqWidth = uint32_t(display->getViewport().width());
5240 reqHeight = uint32_t(display->getViewport().height());
Chia-I Wu20261cb2018-08-23 12:55:44 -07005241 }
Yiwei Zhang06a58e22018-08-20 16:42:23 -07005242 }
5243
Peiyong Lin0e003c92018-09-17 11:09:51 -07005244 DisplayRenderArea renderArea(display, sourceCrop, reqWidth, reqHeight, reqDataspace,
5245 renderAreaRotation);
chaviwa76b2712017-09-20 12:02:26 -07005246
5247 auto traverseLayers = std::bind(std::mem_fn(&SurfaceFlinger::traverseLayersInDisplay), this,
chaviw0e3479f2018-09-10 16:49:30 -07005248 display, std::placeholders::_1);
Peiyong Lin0e003c92018-09-17 11:09:51 -07005249 return captureScreenCommon(renderArea, traverseLayers, outBuffer, reqPixelFormat,
5250 useIdentityTransform);
chaviwa76b2712017-09-20 12:02:26 -07005251}
5252
5253status_t SurfaceFlinger::captureLayers(const sp<IBinder>& layerHandleBinder,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005254 sp<GraphicBuffer>* outBuffer, const Dataspace reqDataspace,
5255 const ui::PixelFormat reqPixelFormat, const Rect& sourceCrop,
Robert Carr578038f2018-03-09 12:25:24 -08005256 float frameScale, bool childrenOnly) {
chaviwa76b2712017-09-20 12:02:26 -07005257 ATRACE_CALL();
5258
5259 class LayerRenderArea : public RenderArea {
5260 public:
Robert Carr578038f2018-03-09 12:25:24 -08005261 LayerRenderArea(SurfaceFlinger* flinger, const sp<Layer>& layer, const Rect crop,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005262 int32_t reqWidth, int32_t reqHeight, Dataspace reqDataSpace,
5263 bool childrenOnly)
5264 : RenderArea(reqWidth, reqHeight, CaptureFill::CLEAR, reqDataSpace),
Robert Carr578038f2018-03-09 12:25:24 -08005265 mLayer(layer),
5266 mCrop(crop),
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005267 mNeedsFiltering(false),
Robert Carr578038f2018-03-09 12:25:24 -08005268 mFlinger(flinger),
5269 mChildrenOnly(childrenOnly) {}
Peiyong Linefefaac2018-08-17 12:27:51 -07005270 const ui::Transform& getTransform() const override { return mTransform; }
Ady Abraham83729882018-12-07 12:26:48 -08005271 Rect getBounds() const override { return mLayer->getBufferSize(StateSet::Drawing); }
Marissa Wall61c58622018-07-18 10:12:20 -07005272 int getHeight() const override {
Ady Abraham83729882018-12-07 12:26:48 -08005273 return mLayer->getBufferSize(StateSet::Drawing).getHeight();
Marissa Wall61c58622018-07-18 10:12:20 -07005274 }
Vishnu Nair88a11f22018-11-28 18:30:57 -08005275 int getWidth() const override {
Ady Abraham83729882018-12-07 12:26:48 -08005276 return mLayer->getBufferSize(StateSet::Drawing).getWidth();
Vishnu Nair88a11f22018-11-28 18:30:57 -08005277 }
chaviwa76b2712017-09-20 12:02:26 -07005278 bool isSecure() const override { return false; }
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005279 bool needsFiltering() const override { return mNeedsFiltering; }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005280 Rect getSourceCrop() const override {
5281 if (mCrop.isEmpty()) {
5282 return getBounds();
5283 } else {
5284 return mCrop;
5285 }
5286 }
Robert Carr578038f2018-03-09 12:25:24 -08005287 class ReparentForDrawing {
5288 public:
5289 const sp<Layer>& oldParent;
5290 const sp<Layer>& newParent;
5291
5292 ReparentForDrawing(const sp<Layer>& oldParent, const sp<Layer>& newParent)
5293 : oldParent(oldParent), newParent(newParent) {
Robert Carr15eae092018-03-23 13:43:53 -07005294 oldParent->setChildrenDrawingParent(newParent);
Robert Carr578038f2018-03-09 12:25:24 -08005295 }
Robert Carr15eae092018-03-23 13:43:53 -07005296 ~ReparentForDrawing() { oldParent->setChildrenDrawingParent(oldParent); }
Robert Carr578038f2018-03-09 12:25:24 -08005297 };
5298
5299 void render(std::function<void()> drawLayers) override {
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005300 const Rect sourceCrop = getSourceCrop();
5301 // no need to check rotation because there is none
5302 mNeedsFiltering = sourceCrop.width() != getReqWidth() ||
5303 sourceCrop.height() != getReqHeight();
5304
Robert Carr578038f2018-03-09 12:25:24 -08005305 if (!mChildrenOnly) {
5306 mTransform = mLayer->getTransform().inverse();
5307 drawLayers();
5308 } else {
5309 Rect bounds = getBounds();
Lloyd Pique90c115d2018-09-18 21:39:42 -07005310 screenshotParentLayer = mFlinger->getFactory().createContainerLayer(
Lloyd Pique42ab75e2018-09-12 20:46:03 -07005311 LayerCreationArgs(mFlinger, nullptr, String8("Screenshot Parent"),
5312 bounds.getWidth(), bounds.getHeight(), 0));
Robert Carr578038f2018-03-09 12:25:24 -08005313
5314 ReparentForDrawing reparent(mLayer, screenshotParentLayer);
5315 drawLayers();
5316 }
5317 }
chaviwa76b2712017-09-20 12:02:26 -07005318
chaviwa76b2712017-09-20 12:02:26 -07005319 private:
chaviw7206d492017-11-10 16:16:12 -08005320 const sp<Layer> mLayer;
5321 const Rect mCrop;
Robert Carr578038f2018-03-09 12:25:24 -08005322
5323 // In the "childrenOnly" case we reparent the children to a screenshot
5324 // layer which has no properties set and which does not draw.
5325 sp<ContainerLayer> screenshotParentLayer;
Peiyong Linefefaac2018-08-17 12:27:51 -07005326 ui::Transform mTransform;
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005327 bool mNeedsFiltering;
Robert Carr578038f2018-03-09 12:25:24 -08005328
5329 SurfaceFlinger* mFlinger;
5330 const bool mChildrenOnly;
chaviwa76b2712017-09-20 12:02:26 -07005331 };
5332
5333 auto layerHandle = reinterpret_cast<Layer::Handle*>(layerHandleBinder.get());
5334 auto parent = layerHandle->owner.promote();
5335
Robert Carr2e102c92018-10-23 12:11:15 -07005336 if (parent == nullptr || parent->isRemovedFromCurrentState()) {
chaviw7206d492017-11-10 16:16:12 -08005337 ALOGE("captureLayers called with a removed parent");
5338 return NAME_NOT_FOUND;
5339 }
5340
Robert Carr578038f2018-03-09 12:25:24 -08005341 const int uid = IPCThreadState::self()->getCallingUid();
5342 const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
Ady Abraham83729882018-12-07 12:26:48 -08005343 if (!forSystem && parent->getCurrentFlags() & layer_state_t::eLayerSecure) {
Robert Carr578038f2018-03-09 12:25:24 -08005344 ALOGW("Attempting to capture secure layer: PERMISSION_DENIED");
5345 return PERMISSION_DENIED;
5346 }
5347
chaviw7206d492017-11-10 16:16:12 -08005348 Rect crop(sourceCrop);
5349 if (sourceCrop.width() <= 0) {
5350 crop.left = 0;
Ady Abraham83729882018-12-07 12:26:48 -08005351 crop.right = parent->getBufferSize(StateSet::Current).getWidth();
chaviw7206d492017-11-10 16:16:12 -08005352 }
5353
5354 if (sourceCrop.height() <= 0) {
5355 crop.top = 0;
Ady Abraham83729882018-12-07 12:26:48 -08005356 crop.bottom = parent->getBufferSize(StateSet::Current).getHeight();
chaviw7206d492017-11-10 16:16:12 -08005357 }
5358
5359 int32_t reqWidth = crop.width() * frameScale;
5360 int32_t reqHeight = crop.height() * frameScale;
5361
Chia-I Wu20261cb2018-08-23 12:55:44 -07005362 // really small crop or frameScale
5363 if (reqWidth <= 0) {
5364 reqWidth = 1;
5365 }
5366 if (reqHeight <= 0) {
5367 reqHeight = 1;
5368 }
5369
Peiyong Lin0e003c92018-09-17 11:09:51 -07005370 LayerRenderArea renderArea(this, parent, crop, reqWidth, reqHeight, reqDataspace, childrenOnly);
chaviw7206d492017-11-10 16:16:12 -08005371
Robert Carr578038f2018-03-09 12:25:24 -08005372 auto traverseLayers = [parent, childrenOnly](const LayerVector::Visitor& visitor) {
chaviwa76b2712017-09-20 12:02:26 -07005373 parent->traverseChildrenInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
5374 if (!layer->isVisible()) {
5375 return;
Robert Carr578038f2018-03-09 12:25:24 -08005376 } else if (childrenOnly && layer == parent.get()) {
5377 return;
chaviwa76b2712017-09-20 12:02:26 -07005378 }
5379 visitor(layer);
5380 });
5381 };
Peiyong Lin0e003c92018-09-17 11:09:51 -07005382 return captureScreenCommon(renderArea, traverseLayers, outBuffer, reqPixelFormat, false);
chaviwa76b2712017-09-20 12:02:26 -07005383}
5384
5385status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea,
5386 TraverseLayersFunction traverseLayers,
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005387 sp<GraphicBuffer>* outBuffer,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005388 const ui::PixelFormat reqPixelFormat,
chaviwa76b2712017-09-20 12:02:26 -07005389 bool useIdentityTransform) {
5390 ATRACE_CALL();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005391
Peiyong Lin0e003c92018-09-17 11:09:51 -07005392 // TODO(b/116112787) Make buffer usage a parameter.
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005393 const uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
5394 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
Lloyd Pique90c115d2018-09-18 21:39:42 -07005395 *outBuffer =
5396 getFactory().createGraphicBuffer(renderArea.getReqWidth(), renderArea.getReqHeight(),
5397 static_cast<android_pixel_format>(reqPixelFormat), 1,
5398 usage, "screenshot");
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005399
5400 // This mutex protects syncFd and captureResult for communication of the return values from the
5401 // main thread back to this Binder thread
5402 std::mutex captureMutex;
5403 std::condition_variable captureCondition;
5404 std::unique_lock<std::mutex> captureLock(captureMutex);
5405 int syncFd = -1;
5406 std::optional<status_t> captureResult;
5407
Robert Carr03480e22018-01-04 16:02:06 -08005408 const int uid = IPCThreadState::self()->getCallingUid();
5409 const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
5410
Dominik Laskowski8c001672018-05-30 16:52:06 -07005411 sp<LambdaMessage> message = new LambdaMessage([&] {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005412 // If there is a refresh pending, bug out early and tell the binder thread to try again
5413 // after the refresh.
5414 if (mRefreshPending) {
5415 ATRACE_NAME("Skipping screenshot for now");
5416 std::unique_lock<std::mutex> captureLock(captureMutex);
5417 captureResult = std::make_optional<status_t>(EAGAIN);
5418 captureCondition.notify_one();
5419 return;
5420 }
5421
5422 status_t result = NO_ERROR;
5423 int fd = -1;
5424 {
5425 Mutex::Autolock _l(mStateLock);
Dominik Laskowski8c001672018-05-30 16:52:06 -07005426 renderArea.render([&] {
Robert Carr578038f2018-03-09 12:25:24 -08005427 result = captureScreenImplLocked(renderArea, traverseLayers, (*outBuffer).get(),
5428 useIdentityTransform, forSystem, &fd);
5429 });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005430 }
5431
5432 {
5433 std::unique_lock<std::mutex> captureLock(captureMutex);
5434 syncFd = fd;
5435 captureResult = std::make_optional<status_t>(result);
5436 captureCondition.notify_one();
5437 }
5438 });
5439
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005440 status_t result = postMessageAsync(message);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005441 if (result == NO_ERROR) {
Dominik Laskowski8c001672018-05-30 16:52:06 -07005442 captureCondition.wait(captureLock, [&] { return captureResult; });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005443 while (*captureResult == EAGAIN) {
5444 captureResult.reset();
5445 result = postMessageAsync(message);
5446 if (result != NO_ERROR) {
5447 return result;
5448 }
Dominik Laskowski8c001672018-05-30 16:52:06 -07005449 captureCondition.wait(captureLock, [&] { return captureResult; });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005450 }
5451 result = *captureResult;
5452 }
5453
5454 if (result == NO_ERROR) {
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005455 sync_wait(syncFd, -1);
5456 close(syncFd);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005457 }
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005458
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005459 return result;
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005460}
5461
chaviwa76b2712017-09-20 12:02:26 -07005462void SurfaceFlinger::renderScreenImplLocked(const RenderArea& renderArea,
Chia-I Wu1be50b52018-08-29 10:44:48 -07005463 TraverseLayersFunction traverseLayers,
chaviwa76b2712017-09-20 12:02:26 -07005464 bool useIdentityTransform) {
Mathias Agopian180f10d2013-04-10 22:55:41 -07005465 ATRACE_CALL();
chaviwa76b2712017-09-20 12:02:26 -07005466
Lloyd Pique144e1162017-12-20 16:44:52 -08005467 auto& engine(getRenderEngine());
Mathias Agopian180f10d2013-04-10 22:55:41 -07005468
chaviwa76b2712017-09-20 12:02:26 -07005469 const auto reqWidth = renderArea.getReqWidth();
5470 const auto reqHeight = renderArea.getReqHeight();
Chia-I Wuf2aa3112018-08-27 14:54:37 -07005471 const auto sourceCrop = renderArea.getSourceCrop();
5472 const auto rotation = renderArea.getRotationFlags();
Dan Stozac1879002014-05-22 15:59:05 -07005473
Peiyong Lin0e003c92018-09-17 11:09:51 -07005474 engine.setOutputDataSpace(renderArea.getReqDataSpace());
Chia-I Wu36574d92018-05-16 10:54:36 -07005475 engine.setDisplayMaxLuminance(DisplayDevice::sDefaultMaxLumiance);
Romain Guy88d37dd2017-05-26 17:57:05 -07005476
Mathias Agopian180f10d2013-04-10 22:55:41 -07005477 // make sure to clear all GL error flags
Mathias Agopian3f844832013-08-07 21:24:32 -07005478 engine.checkErrors();
Mathias Agopian180f10d2013-04-10 22:55:41 -07005479
5480 // set-up our viewport
Chia-I Wu1be50b52018-08-29 10:44:48 -07005481 engine.setViewportAndProjection(reqWidth, reqHeight, sourceCrop, rotation);
Mathias Agopian3f844832013-08-07 21:24:32 -07005482 engine.disableTexturing();
Mathias Agopian180f10d2013-04-10 22:55:41 -07005483
chaviw50da5042018-04-09 13:49:37 -07005484 const float alpha = RenderArea::getCaptureFillValue(renderArea.getCaptureFill());
Mathias Agopian180f10d2013-04-10 22:55:41 -07005485 // redraw the screen entirely...
chaviw50da5042018-04-09 13:49:37 -07005486 engine.clearWithColor(0, 0, 0, alpha);
Mathias Agopian180f10d2013-04-10 22:55:41 -07005487
chaviwa76b2712017-09-20 12:02:26 -07005488 traverseLayers([&](Layer* layer) {
Peiyong Lind3788632018-09-18 16:01:31 -07005489 engine.setColorTransform(layer->getColorTransform());
David Sodmanfb95bcc2017-12-22 15:45:30 -08005490 layer->draw(renderArea, useIdentityTransform);
Peiyong Lind3788632018-09-18 16:01:31 -07005491 engine.setColorTransform(mat4());
chaviwa76b2712017-09-20 12:02:26 -07005492 });
Mathias Agopian180f10d2013-04-10 22:55:41 -07005493}
5494
chaviwa76b2712017-09-20 12:02:26 -07005495status_t SurfaceFlinger::captureScreenImplLocked(const RenderArea& renderArea,
5496 TraverseLayersFunction traverseLayers,
5497 ANativeWindowBuffer* buffer,
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005498 bool useIdentityTransform,
Robert Carr03480e22018-01-04 16:02:06 -08005499 bool forSystem,
chaviwa76b2712017-09-20 12:02:26 -07005500 int* outSyncFd) {
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005501 ATRACE_CALL();
5502
Pablo Ceballosb5b35632016-02-23 11:18:51 -08005503 bool secureLayerIsVisible = false;
chaviwa76b2712017-09-20 12:02:26 -07005504
5505 traverseLayers([&](Layer* layer) {
5506 secureLayerIsVisible = secureLayerIsVisible || (layer->isVisible() && layer->isSecure());
5507 });
Pablo Ceballosb5b35632016-02-23 11:18:51 -08005508
Robert Carr03480e22018-01-04 16:02:06 -08005509 // We allow the system server to take screenshots of secure layers for
5510 // use in situations like the Screen-rotation animation and place
5511 // the impetus on WindowManager to not persist them.
5512 if (secureLayerIsVisible && !forSystem) {
Pablo Ceballosb5b35632016-02-23 11:18:51 -08005513 ALOGW("FB is protected: PERMISSION_DENIED");
5514 return PERMISSION_DENIED;
5515 }
Peiyong Linfb530cf2018-12-15 05:07:38 +00005516 auto& engine(getRenderEngine());
Pablo Ceballosb5b35632016-02-23 11:18:51 -08005517
Dan Stozaa9b1aa02017-06-01 14:16:23 -07005518 // this binds the given EGLImage as a framebuffer for the
5519 // duration of this scope.
Peiyong Linfb530cf2018-12-15 05:07:38 +00005520 renderengine::BindNativeBufferAsFramebuffer bufferBond(engine, buffer);
Chia-I Wueadbaa62017-11-09 11:26:15 -08005521 if (bufferBond.getStatus() != NO_ERROR) {
5522 ALOGE("got ANWB binding error while taking screenshot");
Dan Stozaabcda352017-06-01 14:37:39 -07005523 return INVALID_OPERATION;
5524 }
Dan Stozaa9b1aa02017-06-01 14:16:23 -07005525
Dan Stozaabcda352017-06-01 14:37:39 -07005526 // this will in fact render into our dequeued buffer
5527 // via an FBO, which means we didn't have to create
5528 // an EGLSurface and therefore we're not
5529 // dependent on the context's EGLConfig.
Chia-I Wu1be50b52018-08-29 10:44:48 -07005530 renderScreenImplLocked(renderArea, traverseLayers, useIdentityTransform);
Dan Stozaa9b1aa02017-06-01 14:16:23 -07005531
Peiyong Linfb530cf2018-12-15 05:07:38 +00005532 base::unique_fd syncFd = engine.flush();
Alec Mouri492bc572018-09-11 21:40:04 +00005533 if (syncFd < 0) {
Peiyong Linfb530cf2018-12-15 05:07:38 +00005534 engine.finish();
Dan Stozaabcda352017-06-01 14:37:39 -07005535 }
Alec Mouri492bc572018-09-11 21:40:04 +00005536 *outSyncFd = syncFd.release();
Dan Stozaabcda352017-06-01 14:37:39 -07005537
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005538 return NO_ERROR;
Mathias Agopian74c40c02010-09-29 13:02:36 -07005539}
5540
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07005541// ---------------------------------------------------------------------------
5542
Dan Stoza412903f2017-04-27 13:42:17 -07005543void SurfaceFlinger::State::traverseInZOrder(const LayerVector::Visitor& visitor) const {
5544 layersSortedByZ.traverseInZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07005545}
5546
Dan Stoza412903f2017-04-27 13:42:17 -07005547void SurfaceFlinger::State::traverseInReverseZOrder(const LayerVector::Visitor& visitor) const {
5548 layersSortedByZ.traverseInReverseZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07005549}
5550
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005551void SurfaceFlinger::traverseLayersInDisplay(const sp<const DisplayDevice>& display,
chaviwa76b2712017-09-20 12:02:26 -07005552 const LayerVector::Visitor& visitor) {
5553 // We loop through the first level of layers without traversing,
chaviw0e3479f2018-09-10 16:49:30 -07005554 // as we need to determine which layers belong to the requested display.
chaviwa76b2712017-09-20 12:02:26 -07005555 for (const auto& layer : mDrawingState.layersSortedByZ) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005556 if (!layer->belongsToDisplay(display->getLayerStack(), false)) {
chaviwa76b2712017-09-20 12:02:26 -07005557 continue;
5558 }
Chia-I Wuec2d9852017-11-21 09:21:01 -08005559 // relative layers are traversed in Layer::traverseInZOrder
chaviwa76b2712017-09-20 12:02:26 -07005560 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005561 if (!layer->belongsToDisplay(display->getLayerStack(), false)) {
Adrian Roos8acf5a02018-01-17 21:28:19 +01005562 return;
5563 }
chaviwa76b2712017-09-20 12:02:26 -07005564 if (!layer->isVisible()) {
5565 return;
5566 }
5567 visitor(layer);
5568 });
5569 }
5570}
5571
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005572}; // namespace android
Mathias Agopian3f844832013-08-07 21:24:32 -07005573
Lloyd Pique074e8122018-07-26 12:57:23 -07005574
Mathias Agopian3f844832013-08-07 21:24:32 -07005575#if defined(__gl_h_)
5576#error "don't include gl/gl.h in this file"
5577#endif
5578
5579#if defined(__gl2_h_)
5580#error "don't include gl2/gl2.h in this file"
Chia-I Wu767fcf72017-11-30 22:07:38 -08005581#endif