blob: 5e0ba13faaf8e32e538a6b373c8b99b5b2bfa967 [file] [log] [blame]
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Alec Mourie7d1d4a2019-02-05 01:13:46 +000017//#define LOG_NDEBUG 0
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080018#define ATRACE_TAG ATRACE_TAG_GRAPHICS
19
Mathias Agopian921e6ac2012-07-23 23:11:29 -070020#include <sys/types.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080021#include <errno.h>
Keun young Park63f165f2012-08-31 10:53:36 -070022#include <dlfcn.h>
Dominik Laskowski83b88212018-12-11 13:34:06 -080023
24#include <algorithm>
25#include <cinttypes>
26#include <cmath>
27#include <cstdint>
28#include <functional>
29#include <mutex>
Dan Stoza2b6d38e2017-06-01 16:40:30 -070030#include <optional>
Dominik Laskowskic2867142019-01-21 11:33:38 -080031#include <unordered_map>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070032
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080033#include <cutils/properties.h>
Mark Salyzyn7823e122016-09-29 08:08:05 -070034#include <log/log.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080035
Mathias Agopianc5b2c0b2009-05-19 19:08:10 -070036#include <binder/IPCThreadState.h>
37#include <binder/IServiceManager.h>
Mathias Agopian99b49842011-06-27 16:05:52 -070038#include <binder/PermissionCache.h>
Mathias Agopian7303c6b2009-07-02 18:11:53 -070039
Lloyd Pique70d91362018-10-18 16:02:55 -070040#include <compositionengine/CompositionEngine.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070041#include <compositionengine/Display.h>
Lloyd Pique3d0c02e2018-10-19 18:38:12 -070042#include <compositionengine/DisplayColorProfile.h>
Lloyd Piquecc01a452018-12-04 17:24:00 -080043#include <compositionengine/Layer.h>
44#include <compositionengine/OutputLayer.h>
Lloyd Pique31cb2942018-10-19 17:23:03 -070045#include <compositionengine/RenderSurface.h>
Lloyd Pique0b785d82018-12-04 17:25:27 -080046#include <compositionengine/impl/LayerCompositionState.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070047#include <compositionengine/impl/OutputCompositionState.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080048#include <compositionengine/impl/OutputLayerCompositionState.h>
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -080049#include <dvr/vr_flinger.h>
Jamie Gennis1a4d8832012-08-02 20:11:05 -070050#include <gui/BufferQueue.h>
Andy McFadden4803b742012-09-24 19:07:20 -070051#include <gui/GuiConfig.h>
Jamie Gennis1a4d8832012-08-02 20:11:05 -070052#include <gui/IDisplayEventConnection.h>
Alec Mouri0a9c7b82018-11-16 13:05:25 -080053#include <gui/IProducerListener.h>
Kalle Raitaa099a242017-01-11 11:17:29 -080054#include <gui/LayerDebugInfo.h>
Mathias Agopiane3c697f2013-02-14 17:11:02 -080055#include <gui/Surface.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070056#include <input/IInputFlinger.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070057#include <renderengine/RenderEngine.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070058#include <ui/ColorSpace.h>
59#include <ui/DebugUtils.h>
60#include <ui/DisplayInfo.h>
61#include <ui/DisplayStatInfo.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070062#include <ui/GraphicBufferAllocator.h>
63#include <ui/PixelFormat.h>
Andy McFadden4803b742012-09-24 19:07:20 -070064#include <ui/UiConfig.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080065#include <utils/StopWatch.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070066#include <utils/String16.h>
67#include <utils/String8.h>
Yusuke Sato0a688f52015-07-30 23:05:39 -070068#include <utils/Timers.h>
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080069#include <utils/Trace.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070070#include <utils/misc.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080071
Mathias Agopian921e6ac2012-07-23 23:11:29 -070072#include <private/android_filesystem_config.h>
Mathias Agopianca088332013-03-28 17:44:13 -070073#include <private/gui/SyncFeatures.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080074
Robert Carr578038f2018-03-09 12:25:24 -080075#include "BufferLayer.h"
Marissa Wallfd668622018-05-10 10:21:13 -070076#include "BufferQueueLayer.h"
Marissa Wall61c58622018-07-18 10:12:20 -070077#include "BufferStateLayer.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +020078#include "Client.h"
Robert Carr578038f2018-03-09 12:25:24 -080079#include "ColorLayer.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +020080#include "Colorizer.h"
Robert Carr578038f2018-03-09 12:25:24 -080081#include "ContainerLayer.h"
Robert Carr578038f2018-03-09 12:25:24 -080082#include "DisplayDevice.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080083#include "Layer.h"
Robert Carr1f0a16a2016-10-24 16:27:39 -070084#include "LayerVector.h"
Robert Carr1db73f62016-12-21 12:58:51 -080085#include "MonitoredProducer.h"
Lloyd Pique22098362018-09-13 11:46:49 -070086#include "NativeWindowSurface.h"
Ady Abraham03b02dd2019-03-21 15:40:11 -070087#include "RefreshRateOverlay.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070088#include "StartPropertySetThread.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080089#include "SurfaceFlinger.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070090#include "SurfaceInterceptor.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080091
Steven Thomasb02664d2017-07-26 18:48:28 -070092#include "DisplayHardware/ComposerHal.h"
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -070093#include "DisplayHardware/DisplayIdentification.h"
Mathias Agopiana4912602012-07-12 14:25:33 -070094#include "DisplayHardware/FramebufferSurface.h"
Mathias Agopiana350ff92010-08-10 17:14:02 -070095#include "DisplayHardware/HWComposer.h"
Jesse Hall99c7dbb2013-03-14 14:29:29 -070096#include "DisplayHardware/VirtualDisplaySurface.h"
Mathias Agopianff2ed702013-09-01 21:36:12 -070097#include "Effects/Daltonizer.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -070098#include "RegionSamplingThread.h"
Ana Krulecfefcb582018-08-07 14:22:37 -070099#include "Scheduler/DispSync.h"
Ana Krulec241cf832018-08-10 15:03:23 -0700100#include "Scheduler/DispSyncSource.h"
Ana Krulecfefcb582018-08-07 14:22:37 -0700101#include "Scheduler/EventControlThread.h"
102#include "Scheduler/EventThread.h"
Ana Krulec47454452018-08-14 11:04:14 -0700103#include "Scheduler/InjectVSyncSource.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -0700104#include "Scheduler/MessageQueue.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700105#include "Scheduler/PhaseOffsets.h"
Ana Krulec98b5b242018-08-10 15:03:23 -0700106#include "Scheduler/Scheduler.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800107#include "TimeStats/TimeStats.h"
Ana Krulecfefcb582018-08-07 14:22:37 -0700108
Mathias Agopianff2ed702013-09-01 21:36:12 -0700109#include <cutils/compiler.h>
Mathias Agopian875d8e12013-06-07 15:35:48 -0700110
David Sodman7e4ae112018-02-09 15:02:28 -0800111#include "android-base/stringprintf.h"
112
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900113#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
Iris Chang7501ed62018-04-30 14:45:42 +0800114#include <android/hardware/configstore/1.1/ISurfaceFlingerConfigs.h>
115#include <android/hardware/configstore/1.1/types.h>
Jaesoo Lee43518572017-01-23 19:03:16 +0900116#include <configstore/Utils.h>
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900117
chaviw1d044282017-09-27 12:19:28 -0700118#include <layerproto/LayerProtoParser.h>
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900119#include "SurfaceFlingerProperties.h"
chaviw1d044282017-09-27 12:19:28 -0700120
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800121namespace android {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700122
Jaesoo Lee43518572017-01-23 19:03:16 +0900123using namespace android::hardware::configstore;
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900124using namespace android::hardware::configstore::V1_0;
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900125using namespace android::sysprop;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -0800126
Yiwei Zhang5434a782018-12-05 18:06:32 -0800127using base::StringAppendF;
Peiyong Lin9f034472018-03-28 15:29:00 -0700128using ui::ColorMode;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700129using ui::Dataspace;
Daniel Solomon42d04562019-01-20 21:03:19 -0800130using ui::DisplayPrimaries;
Peiyong Lin62665892018-04-16 11:07:44 -0700131using ui::Hdr;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700132using ui::RenderIntent;
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900133
Steven Thomasb02664d2017-07-26 18:48:28 -0700134namespace {
Peiyong Linfca547f2018-07-09 13:03:33 -0700135
136#pragma clang diagnostic push
137#pragma clang diagnostic error "-Wswitch-enum"
138
139bool isWideColorMode(const ColorMode colorMode) {
140 switch (colorMode) {
141 case ColorMode::DISPLAY_P3:
142 case ColorMode::ADOBE_RGB:
143 case ColorMode::DCI_P3:
144 case ColorMode::BT2020:
Valerie Hau9758ae02018-10-09 16:05:09 -0700145 case ColorMode::DISPLAY_BT2020:
Peiyong Linfca547f2018-07-09 13:03:33 -0700146 case ColorMode::BT2100_PQ:
147 case ColorMode::BT2100_HLG:
148 return true;
149 case ColorMode::NATIVE:
150 case ColorMode::STANDARD_BT601_625:
151 case ColorMode::STANDARD_BT601_625_UNADJUSTED:
152 case ColorMode::STANDARD_BT601_525:
153 case ColorMode::STANDARD_BT601_525_UNADJUSTED:
154 case ColorMode::STANDARD_BT709:
155 case ColorMode::SRGB:
156 return false;
157 }
158 return false;
159}
160
Peiyong Lin34ea5b92019-03-15 18:40:15 -0700161bool isHdrColorMode(const ColorMode colorMode) {
162 switch (colorMode) {
163 case ColorMode::BT2100_PQ:
164 case ColorMode::BT2100_HLG:
165 return true;
166 case ColorMode::DISPLAY_P3:
167 case ColorMode::ADOBE_RGB:
168 case ColorMode::DCI_P3:
169 case ColorMode::BT2020:
170 case ColorMode::DISPLAY_BT2020:
171 case ColorMode::NATIVE:
172 case ColorMode::STANDARD_BT601_625:
173 case ColorMode::STANDARD_BT601_625_UNADJUSTED:
174 case ColorMode::STANDARD_BT601_525:
175 case ColorMode::STANDARD_BT601_525_UNADJUSTED:
176 case ColorMode::STANDARD_BT709:
177 case ColorMode::SRGB:
178 return false;
179 }
180 return false;
181}
182
Chia-I Wuc80dcbb2018-08-24 15:34:02 -0700183ui::Transform::orientation_flags fromSurfaceComposerRotation(ISurfaceComposer::Rotation rotation) {
184 switch (rotation) {
185 case ISurfaceComposer::eRotateNone:
186 return ui::Transform::ROT_0;
187 case ISurfaceComposer::eRotate90:
188 return ui::Transform::ROT_90;
189 case ISurfaceComposer::eRotate180:
190 return ui::Transform::ROT_180;
191 case ISurfaceComposer::eRotate270:
192 return ui::Transform::ROT_270;
193 }
194 ALOGE("Invalid rotation passed to captureScreen(): %d\n", rotation);
195 return ui::Transform::ROT_0;
196}
197
Peiyong Linfca547f2018-07-09 13:03:33 -0700198#pragma clang diagnostic pop
199
Steven Thomasb02664d2017-07-26 18:48:28 -0700200class ConditionalLock {
201public:
202 ConditionalLock(Mutex& mutex, bool lock) : mMutex(mutex), mLocked(lock) {
203 if (lock) {
204 mMutex.lock();
205 }
206 }
207 ~ConditionalLock() { if (mLocked) mMutex.unlock(); }
208private:
209 Mutex& mMutex;
210 bool mLocked;
211};
Peiyong Linfca547f2018-07-09 13:03:33 -0700212
Peiyong Lin9d846a52018-11-05 13:18:20 -0800213// Currently we only support V0_SRGB and DISPLAY_P3 as composition preference.
214bool validateCompositionDataspace(Dataspace dataspace) {
215 return dataspace == Dataspace::V0_SRGB || dataspace == Dataspace::DISPLAY_P3;
216}
217
Steven Thomasb02664d2017-07-26 18:48:28 -0700218} // namespace anonymous
219
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800220// ---------------------------------------------------------------------------
221
Mathias Agopian99b49842011-06-27 16:05:52 -0700222const String16 sHardwareTest("android.permission.HARDWARE_TEST");
223const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER");
224const String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER");
225const String16 sDump("android.permission.DUMP");
226
227// ---------------------------------------------------------------------------
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700228int64_t SurfaceFlinger::dispSyncPresentTimeOffset;
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700229bool SurfaceFlinger::useHwcForRgbToYuv;
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800230uint64_t SurfaceFlinger::maxVirtualDisplaySize;
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800231bool SurfaceFlinger::hasSyncFramework;
Steven Thomas050b2c82017-03-06 11:45:16 -0800232bool SurfaceFlinger::useVrFlinger;
Fabien Sanglard1971b632017-03-10 14:50:03 -0800233int64_t SurfaceFlinger::maxFrameBufferAcquiredBuffers;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600234bool SurfaceFlinger::hasWideColorDisplay;
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700235int SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientationDefault;
Peiyong Lin13effd12018-07-24 17:01:47 -0700236bool SurfaceFlinger::useColorManagement;
Peiyong Linb3839ad2018-09-05 15:37:19 -0700237bool SurfaceFlinger::useContextPriority;
Peiyong Linc6780972018-10-28 15:24:08 -0700238Dataspace SurfaceFlinger::defaultCompositionDataspace = Dataspace::V0_SRGB;
239ui::PixelFormat SurfaceFlinger::defaultCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
240Dataspace SurfaceFlinger::wideColorGamutCompositionDataspace = Dataspace::V0_SRGB;
241ui::PixelFormat SurfaceFlinger::wideColorGamutCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
Mathias Agopian99b49842011-06-27 16:05:52 -0700242
Kalle Raitaa099a242017-01-11 11:17:29 -0800243std::string getHwcServiceName() {
244 char value[PROPERTY_VALUE_MAX] = {};
245 property_get("debug.sf.hwc_service_name", value, "default");
246 ALOGI("Using HWComposer service: '%s'", value);
247 return std::string(value);
248}
249
250bool useTrebleTestingOverride() {
251 char value[PROPERTY_VALUE_MAX] = {};
252 property_get("debug.sf.treble_testing_override", value, "false");
253 ALOGI("Treble testing override: '%s'", value);
254 return std::string(value) == "true";
255}
256
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800257std::string decodeDisplayColorSetting(DisplayColorSetting displayColorSetting) {
258 switch(displayColorSetting) {
259 case DisplayColorSetting::MANAGED:
Chia-I Wu0d711262018-05-21 15:19:35 -0700260 return std::string("Managed");
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800261 case DisplayColorSetting::UNMANAGED:
Chia-I Wu0d711262018-05-21 15:19:35 -0700262 return std::string("Unmanaged");
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800263 case DisplayColorSetting::ENHANCED:
Chia-I Wu0d711262018-05-21 15:19:35 -0700264 return std::string("Enhanced");
265 default:
266 return std::string("Unknown ") +
267 std::to_string(static_cast<int>(displayColorSetting));
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800268 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800269}
270
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700271SurfaceFlingerBE::SurfaceFlingerBE() : mHwcServiceName(getHwcServiceName()) {}
David Sodmanbc815282017-11-05 18:57:52 -0800272
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700273SurfaceFlinger::SurfaceFlinger(Factory& factory, SkipInitializationTag)
274 : mFactory(factory),
275 mPhaseOffsets(mFactory.createPhaseOffsets()),
276 mInterceptor(mFactory.createSurfaceInterceptor(this)),
277 mTimeStats(mFactory.createTimeStats()),
278 mEventQueue(mFactory.createMessageQueue()),
279 mCompositionEngine(mFactory.createCompositionEngine()) {}
Lloyd Piqueac648ee2018-01-17 13:42:24 -0800280
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700281SurfaceFlinger::SurfaceFlinger(Factory& factory) : SurfaceFlinger(factory, SkipInitialization) {
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800282 ALOGI("SurfaceFlinger is starting");
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800283
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900284 hasSyncFramework = running_without_sync_framework(true);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800285
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900286 dispSyncPresentTimeOffset = present_time_offset_from_vsync_ns(0);
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700287
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900288 useHwcForRgbToYuv = force_hwc_copy_for_virtual_displays(false);
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700289
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900290 maxVirtualDisplaySize = max_virtual_display_dimension(0);
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800291
Steven Thomas050b2c82017-03-06 11:45:16 -0800292 // Vr flinger is only enabled on Daydream ready devices.
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900293 useVrFlinger = use_vr_flinger(false);
Steven Thomas050b2c82017-03-06 11:45:16 -0800294
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900295 maxFrameBufferAcquiredBuffers = max_frame_buffer_acquired_buffers(2);
Fabien Sanglard1971b632017-03-10 14:50:03 -0800296
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900297 hasWideColorDisplay = has_wide_color_display(false);
Peiyong Lin0256f722018-08-31 15:45:10 -0700298
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900299 useColorManagement = use_color_management(false);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600300
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900301 mDefaultCompositionDataspace =
302 static_cast<ui::Dataspace>(default_composition_dataspace(Dataspace::V0_SRGB));
303 mWideColorGamutCompositionDataspace =
304 static_cast<ui::Dataspace>(wcg_composition_dataspace(Dataspace::V0_SRGB));
305 defaultCompositionDataspace = mDefaultCompositionDataspace;
306 wideColorGamutCompositionDataspace = mWideColorGamutCompositionDataspace;
307 defaultCompositionPixelFormat = static_cast<ui::PixelFormat>(
308 default_composition_pixel_format(ui::PixelFormat::RGBA_8888));
309 wideColorGamutCompositionPixelFormat =
310 static_cast<ui::PixelFormat>(wcg_composition_pixel_format(ui::PixelFormat::RGBA_8888));
Peiyong Linb3839ad2018-09-05 15:37:19 -0700311
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900312 useContextPriority = use_context_priority(true);
Iris Chang7501ed62018-04-30 14:45:42 +0800313
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900314 auto tmpPrimaryDisplayOrientation = primary_display_orientation(
315 SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_0);
316 switch (tmpPrimaryDisplayOrientation) {
317 case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_90:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700318 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientation90;
Iris Chang7501ed62018-04-30 14:45:42 +0800319 break;
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900320 case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_180:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700321 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientation180;
Iris Chang7501ed62018-04-30 14:45:42 +0800322 break;
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900323 case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_270:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700324 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientation270;
Iris Chang7501ed62018-04-30 14:45:42 +0800325 break;
326 default:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700327 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientationDefault;
Iris Chang7501ed62018-04-30 14:45:42 +0800328 break;
329 }
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700330 ALOGV("Primary Display Orientation is set to %2d.", SurfaceFlinger::primaryDisplayOrientation);
Iris Chang7501ed62018-04-30 14:45:42 +0800331
Sundong Ahn85131bd2019-02-18 15:51:53 +0900332 mInternalDisplayPrimaries = sysprop::getDisplayNativePrimaries();
Daniel Solomon42d04562019-01-20 21:03:19 -0800333
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800334 // debugging stuff...
335 char value[PROPERTY_VALUE_MAX];
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700336
Mathias Agopianb4b17302013-03-20 18:36:41 -0700337 property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");
Mathias Agopian50210b92013-03-21 21:13:21 -0700338 mGpuToCpuSupported = !atoi(value);
Mathias Agopianb4b17302013-03-20 18:36:41 -0700339
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800340 property_get("debug.sf.showupdates", value, "0");
341 mDebugRegion = atoi(value);
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700342
Mathias Agopianc1d359d2012-08-04 20:09:03 -0700343 ALOGI_IF(mDebugRegion, "showupdates enabled");
Orion Hodson34397da2019-02-04 09:36:10 +0000344
345 // DDMS debugging deprecated (b/120782499)
346 property_get("debug.sf.ddms", value, "0");
347 int debugDdms = atoi(value);
348 ALOGI_IF(debugDdms, "DDMS debugging not supported");
Dan Stozac5da2712016-07-20 15:38:12 -0700349
350 property_get("debug.sf.disable_backpressure", value, "0");
351 mPropagateBackpressure = !atoi(value);
352 ALOGI_IF(!mPropagateBackpressure, "Disabling backpressure propagation");
Dan Stoza8cf150a2016-08-02 10:27:31 -0700353
Fabien Sanglard642b23d2017-02-09 12:29:39 -0800354 property_get("debug.sf.enable_hwc_vds", value, "0");
355 mUseHwcVirtualDisplays = atoi(value);
Chia-I Wu11d10612018-06-21 15:41:13 +0800356 ALOGI_IF(mUseHwcVirtualDisplays, "Enabling HWC virtual displays");
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800357
Yiwei Zhangb770ed32018-12-17 17:44:28 -0800358 property_get("ro.sf.disable_triple_buffer", value, "0");
Fabien Sanglardc65dafa2017-02-07 14:06:39 -0800359 mLayerTripleBufferingDisabled = atoi(value);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800360 ALOGI_IF(mLayerTripleBufferingDisabled, "Disabling Triple Buffering");
Romain Guy3054f002017-06-05 18:38:53 -0700361
Yiwei Zhang243b3782018-05-15 17:40:04 -0700362 const size_t defaultListSize = MAX_LAYERS;
Dan Stoza0a0158c2018-03-16 13:38:54 -0700363 auto listSize = property_get_int32("debug.sf.max_igbp_list_size", int32_t(defaultListSize));
364 mMaxGraphicBufferProducerListSize = (listSize > 0) ? size_t(listSize) : defaultListSize;
365
Ana Krulece5a06e02019-03-06 17:09:03 -0800366 mUseSmart90ForVideo = use_smart_90_for_video(false);
Ana Krulecba13ab32019-02-20 14:14:12 -0800367 property_get("debug.sf.use_smart_90_for_video", value, "0");
Ana Krulece5a06e02019-03-06 17:09:03 -0800368
369 int int_value = atoi(value);
370 if (int_value) {
371 mUseSmart90ForVideo = true;
372 }
Ana Krulecba13ab32019-02-20 14:14:12 -0800373
Dan Stozaec460082018-12-17 15:35:09 -0800374 property_get("debug.sf.luma_sampling", value, "1");
375 mLumaSampling = atoi(value);
376
Ana Krulec757f63a2019-01-25 10:46:18 -0800377 const auto [early, gl, late] = mPhaseOffsets->getCurrentOffsets();
378 mVsyncModulator.setPhaseOffsets(early, gl, late);
Dan Stoza84d619e2018-03-28 17:07:36 -0700379
Romain Guy11d63f42017-07-20 12:47:14 -0700380 // We should be reading 'persist.sys.sf.color_saturation' here
381 // but since /data may be encrypted, we need to wait until after vold
382 // comes online to attempt to read the property. The property is
383 // instead read after the boot animation
Kalle Raitaa099a242017-01-11 11:17:29 -0800384
385 if (useTrebleTestingOverride()) {
386 // Without the override SurfaceFlinger cannot connect to HIDL
387 // services that are not listed in the manifests. Considered
388 // deriving the setting from the set service name, but it
389 // would be brittle if the name that's not 'default' is used
390 // for production purposes later on.
391 setenv("TREBLE_TESTING_OVERRIDE", "true", true);
392 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800393}
394
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800395void SurfaceFlinger::onFirstRef()
396{
Lloyd Pique3fcdef12018-01-22 17:14:00 -0800397 mEventQueue->init(this);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800398}
399
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700400SurfaceFlinger::~SurfaceFlinger() = default;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800401
Dan Stozac7014012014-02-14 15:03:43 -0800402void SurfaceFlinger::binderDied(const wp<IBinder>& /* who */)
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800403{
404 // the window manager died on us. prepare its eulogy.
405
Andy McFadden13a082e2012-08-24 10:16:42 -0700406 // restore initial conditions (default device unblank, etc)
407 initializeDisplays();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800408
409 // restart the boot-animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700410 startBootAnim();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800411}
412
Robert Carr1db73f62016-12-21 12:58:51 -0800413static sp<ISurfaceComposerClient> initClient(const sp<Client>& client) {
Mathias Agopian96f08192010-06-02 23:28:45 -0700414 status_t err = client->initCheck();
415 if (err == NO_ERROR) {
Robert Carr1db73f62016-12-21 12:58:51 -0800416 return client;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800417 }
Robert Carr1db73f62016-12-21 12:58:51 -0800418 return nullptr;
419}
420
421sp<ISurfaceComposerClient> SurfaceFlinger::createConnection() {
422 return initClient(new Client(this));
423}
424
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700425sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName,
426 bool secure)
Mathias Agopiane57f2922012-08-09 16:29:12 -0700427{
428 class DisplayToken : public BBinder {
429 sp<SurfaceFlinger> flinger;
430 virtual ~DisplayToken() {
431 // no more references, this display must be terminated
432 Mutex::Autolock _l(flinger->mStateLock);
433 flinger->mCurrentState.displays.removeItem(this);
434 flinger->setTransactionFlags(eDisplayTransactionNeeded);
435 }
436 public:
Chih-Hung Hsiehc4067912016-05-03 14:03:27 -0700437 explicit DisplayToken(const sp<SurfaceFlinger>& flinger)
Mathias Agopiane57f2922012-08-09 16:29:12 -0700438 : flinger(flinger) {
439 }
440 };
441
442 sp<BBinder> token = new DisplayToken(this);
443
444 Mutex::Autolock _l(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700445 // Display ID is assigned when virtual display is allocated by HWC.
446 DisplayDeviceState state;
447 state.isSecure = secure;
448 state.displayName = displayName;
449 mCurrentState.displays.add(token, state);
450 mInterceptor->saveDisplayCreation(state);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700451 return token;
452}
453
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700454void SurfaceFlinger::destroyDisplay(const sp<IBinder>& displayToken) {
Jesse Hall6c913be2013-08-08 12:15:49 -0700455 Mutex::Autolock _l(mStateLock);
456
Dominik Laskowski075d3172018-05-24 15:50:06 -0700457 ssize_t index = mCurrentState.displays.indexOfKey(displayToken);
458 if (index < 0) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700459 ALOGE("destroyDisplay: Invalid display token %p", displayToken.get());
Jesse Hall6c913be2013-08-08 12:15:49 -0700460 return;
461 }
462
Dominik Laskowski075d3172018-05-24 15:50:06 -0700463 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
464 if (!state.isVirtual()) {
Jesse Hall6c913be2013-08-08 12:15:49 -0700465 ALOGE("destroyDisplay called for non-virtual display");
466 return;
467 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700468 mInterceptor->saveDisplayDeletion(state.sequenceId);
469 mCurrentState.displays.removeItemsAt(index);
Jesse Hall6c913be2013-08-08 12:15:49 -0700470 setTransactionFlags(eDisplayTransactionNeeded);
471}
472
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800473std::vector<PhysicalDisplayId> SurfaceFlinger::getPhysicalDisplayIds() const {
474 Mutex::Autolock lock(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700475
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800476 const auto internalDisplayId = getInternalDisplayIdLocked();
477 if (!internalDisplayId) {
478 return {};
Dominik Laskowski075d3172018-05-24 15:50:06 -0700479 }
480
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800481 std::vector<PhysicalDisplayId> displayIds;
482 displayIds.reserve(mPhysicalDisplayTokens.size());
483 displayIds.push_back(internalDisplayId->value);
484
485 for (const auto& [id, token] : mPhysicalDisplayTokens) {
486 if (id != *internalDisplayId) {
487 displayIds.push_back(id.value);
488 }
Mathias Agopiane57f2922012-08-09 16:29:12 -0700489 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700490
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800491 return displayIds;
492}
493
494sp<IBinder> SurfaceFlinger::getPhysicalDisplayToken(PhysicalDisplayId displayId) const {
495 Mutex::Autolock lock(mStateLock);
496 return getPhysicalDisplayTokenLocked(DisplayId{displayId});
Mathias Agopiane57f2922012-08-09 16:29:12 -0700497}
498
Ady Abraham37965d42018-11-01 13:43:32 -0700499status_t SurfaceFlinger::getColorManagement(bool* outGetColorManagement) const {
500 if (!outGetColorManagement) {
501 return BAD_VALUE;
502 }
503 *outGetColorManagement = useColorManagement;
504 return NO_ERROR;
Ady Abraham2a6ab2a2018-10-26 14:25:30 -0700505}
506
Lloyd Pique441d5042018-10-18 16:49:51 -0700507HWComposer& SurfaceFlinger::getHwComposer() const {
508 return mCompositionEngine->getHwComposer();
509}
510
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700511renderengine::RenderEngine& SurfaceFlinger::getRenderEngine() const {
512 return mCompositionEngine->getRenderEngine();
513}
514
Lloyd Pique70d91362018-10-18 16:02:55 -0700515compositionengine::CompositionEngine& SurfaceFlinger::getCompositionEngine() const {
516 return *mCompositionEngine.get();
517}
518
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800519void SurfaceFlinger::bootFinished()
520{
Wei Wangf9b05ee2017-07-19 20:59:39 -0700521 if (mStartPropertySetThread->join() != NO_ERROR) {
522 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800523 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800524 const nsecs_t now = systemTime();
525 const nsecs_t duration = now - mBootTime;
Steve Blocka19954a2012-01-04 20:05:49 +0000526 ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700527
528 // wait patiently for the window manager death
529 const String16 name("window");
530 sp<IBinder> window(defaultServiceManager()->getService(name));
531 if (window != 0) {
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700532 window->linkToDeath(static_cast<IBinder::DeathRecipient*>(this));
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700533 }
Robert Carr720e5062018-07-30 17:45:14 -0700534 sp<IBinder> input(defaultServiceManager()->getService(
535 String16("inputflinger")));
536 if (input == nullptr) {
537 ALOGE("Failed to link to input service");
538 } else {
539 mInputFlinger = interface_cast<IInputFlinger>(input);
540 }
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700541
Steven Thomas050b2c82017-03-06 11:45:16 -0800542 if (mVrFlinger) {
543 mVrFlinger->OnBootFinished();
544 }
545
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700546 // stop boot animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700547 // formerly we would just kill the process, but we now ask it to exit so it
548 // can choose where to stop the animation.
549 property_set("service.bootanim.exit", "1");
Yusuke Sato0a688f52015-07-30 23:05:39 -0700550
551 const int LOGTAG_SF_STOP_BOOTANIM = 60110;
552 LOG_EVENT_LONG(LOGTAG_SF_STOP_BOOTANIM,
553 ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
Romain Guy11d63f42017-07-20 12:47:14 -0700554
Ana Krulecbd6654b2019-02-15 15:18:15 -0800555 postMessageAsync(new LambdaMessage([this]() NO_THREAD_SAFETY_ANALYSIS {
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800556 readPersistentProperties();
557 mBootStage = BootStage::FINISHED;
Ana Krulecbd6654b2019-02-15 15:18:15 -0800558
Ady Abraham97d04232019-03-05 19:48:12 -0800559 // set the refresh rate according to the policy
Alec Mouri0a1cc962019-03-14 12:33:02 -0700560 const auto& performanceRefreshRate =
Dominik Laskowski22488f62019-03-28 09:53:04 -0700561 mRefreshRateConfigs.getRefreshRate(RefreshRateType::PERFORMANCE);
Ady Abraham97d04232019-03-05 19:48:12 -0800562
Dominik Laskowski22488f62019-03-28 09:53:04 -0700563 if (performanceRefreshRate && isDisplayConfigAllowed(performanceRefreshRate->configId)) {
Ana Krulec8d3e4f32019-03-05 10:40:33 -0800564 setRefreshRateTo(RefreshRateType::PERFORMANCE, Scheduler::ConfigEvent::None);
Ana Krulecbd6654b2019-02-15 15:18:15 -0800565 } else {
Ana Krulec8d3e4f32019-03-05 10:40:33 -0800566 setRefreshRateTo(RefreshRateType::DEFAULT, Scheduler::ConfigEvent::None);
Ana Krulecbd6654b2019-02-15 15:18:15 -0800567 }
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800568 }));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800569}
570
Dan Stoza436ccf32018-06-21 12:10:12 -0700571uint32_t SurfaceFlinger::getNewTexture() {
572 {
573 std::lock_guard lock(mTexturePoolMutex);
574 if (!mTexturePool.empty()) {
575 uint32_t name = mTexturePool.back();
576 mTexturePool.pop_back();
577 ATRACE_INT("TexturePoolSize", mTexturePool.size());
578 return name;
579 }
580
581 // The pool was too small, so increase it for the future
582 ++mTexturePoolSize;
583 }
584
585 // The pool was empty, so we need to get a new texture name directly using a
586 // blocking call to the main thread
587 uint32_t name = 0;
588 postMessageSync(new LambdaMessage([&]() { getRenderEngine().genTextures(1, &name); }));
589 return name;
590}
591
Mathias Agopian3f844832013-08-07 21:24:32 -0700592void SurfaceFlinger::deleteTextureAsync(uint32_t texture) {
Dominik Laskowski8c001672018-05-30 16:52:06 -0700593 postMessageAsync(new LambdaMessage([=] { getRenderEngine().deleteTextures(1, &texture); }));
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700594}
595
Wei Wangf9b05ee2017-07-19 20:59:39 -0700596// Do not call property_set on main thread which will be blocked by init
597// Use StartPropertySetThread instead.
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700598void SurfaceFlinger::init() {
Mathias Agopiana4912602012-07-12 14:25:33 -0700599 ALOGI( "SurfaceFlinger's main thread ready to run. "
600 "Initializing graphics H/W...");
601
Ana Krulec757f63a2019-01-25 10:46:18 -0800602 ALOGI("Phase offset NS: %" PRId64 "", mPhaseOffsets->getCurrentAppOffset());
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900603
Steven Thomasb02664d2017-07-26 18:48:28 -0700604 Mutex::Autolock _l(mStateLock);
Steven Thomasb02664d2017-07-26 18:48:28 -0700605 // start the EventThread
Ana Krulecc2870422019-01-29 19:00:58 -0800606 mScheduler =
Ady Abraham09bd3922019-04-08 10:44:56 -0700607 getFactory().createScheduler([this](bool enabled) { setPrimaryVsyncEnabled(enabled); },
608 mRefreshRateConfigs);
Ana Krulecc2870422019-01-29 19:00:58 -0800609 auto resyncCallback =
610 mScheduler->makeResyncCallback(std::bind(&SurfaceFlinger::getVsyncPeriod, this));
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800611
Ana Krulecc2870422019-01-29 19:00:58 -0800612 mAppConnectionHandle =
613 mScheduler->createConnection("app", mPhaseOffsets->getCurrentAppOffset(),
614 resyncCallback,
615 impl::EventThread::InterceptVSyncsCallback());
616 mSfConnectionHandle = mScheduler->createConnection("sf", mPhaseOffsets->getCurrentSfOffset(),
617 resyncCallback, [this](nsecs_t timestamp) {
618 mInterceptor->saveVSyncEvent(timestamp);
619 });
620
621 mEventQueue->setEventConnection(mScheduler->getEventConnection(mSfConnectionHandle));
622 mVsyncModulator.setSchedulerAndHandles(mScheduler.get(), mAppConnectionHandle.get(),
623 mSfConnectionHandle.get());
624
Kevin DuBois413287f2019-02-25 08:46:47 -0800625 mRegionSamplingThread =
626 new RegionSamplingThread(*this, *mScheduler,
627 RegionSamplingThread::EnvironmentTimingTunables());
628
Steven Thomasb02664d2017-07-26 18:48:28 -0700629 // Get a RenderEngine for the given display / config (can't fail)
Peiyong Lin13effd12018-07-24 17:01:47 -0700630 int32_t renderEngineFeature = 0;
Peiyong Lin833074a2018-08-28 11:53:54 -0700631 renderEngineFeature |= (useColorManagement ?
632 renderengine::RenderEngine::USE_COLOR_MANAGEMENT : 0);
Peiyong Linb3839ad2018-09-05 15:37:19 -0700633 renderEngineFeature |= (useContextPriority ?
634 renderengine::RenderEngine::USE_HIGH_PRIORITY_CONTEXT : 0);
Peiyong Lin6a043d52019-04-01 17:18:21 -0700635 renderEngineFeature |=
636 (enable_protected_contents(false) ? renderengine::RenderEngine::ENABLE_PROTECTED_CONTEXT
637 : 0);
Peiyong Lin0256f722018-08-31 15:45:10 -0700638
639 // TODO(b/77156734): We need to stop casting and use HAL types when possible.
Alec Mourida4cf3b2019-02-12 15:33:01 -0800640 // Sending maxFrameBufferAcquiredBuffers as the cache size is tightly tuned to single-display.
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700641 mCompositionEngine->setRenderEngine(
Peiyong Linc6780972018-10-28 15:24:08 -0700642 renderengine::RenderEngine::create(static_cast<int32_t>(defaultCompositionPixelFormat),
Alec Mourida4cf3b2019-02-12 15:33:01 -0800643 renderEngineFeature, maxFrameBufferAcquiredBuffers));
Steven Thomasb02664d2017-07-26 18:48:28 -0700644
645 LOG_ALWAYS_FATAL_IF(mVrFlingerRequestsDisplay,
646 "Starting with vr flinger active is not currently supported.");
Lloyd Pique441d5042018-10-18 16:49:51 -0700647 mCompositionEngine->setHwComposer(getFactory().createHWComposer(getBE().mHwcServiceName));
648 mCompositionEngine->getHwComposer().registerCallback(this, getBE().mComposerSequenceId);
Lloyd Piqueba04e622017-12-14 17:11:26 -0800649 // Process any initial hotplug and resulting display changes.
650 processDisplayHotplugEventsLocked();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700651 const auto display = getDefaultDisplayDeviceLocked();
652 LOG_ALWAYS_FATAL_IF(!display, "Missing internal display after registering composer callback.");
Dominik Laskowski075d3172018-05-24 15:50:06 -0700653 LOG_ALWAYS_FATAL_IF(!getHwComposer().isConnected(*display->getId()),
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700654 "Internal display is disconnected.");
Jesse Hall692c7232012-11-08 15:41:56 -0800655
Steven Thomas050b2c82017-03-06 11:45:16 -0800656 if (useVrFlinger) {
Dominik Laskowski8c001672018-05-30 16:52:06 -0700657 auto vrFlingerRequestDisplayCallback = [this](bool requestDisplay) {
Steven Thomasbe6cbae2017-09-28 15:30:23 -0700658 // This callback is called from the vr flinger dispatch thread. We
659 // need to call signalTransaction(), which requires holding
660 // mStateLock when we're not on the main thread. Acquiring
661 // mStateLock from the vr flinger dispatch thread might trigger a
662 // deadlock in surface flinger (see b/66916578), so post a message
663 // to be handled on the main thread instead.
Dominik Laskowski8c001672018-05-30 16:52:06 -0700664 postMessageAsync(new LambdaMessage([=] {
Steven Thomasbe6cbae2017-09-28 15:30:23 -0700665 ALOGI("VR request display mode: requestDisplay=%d", requestDisplay);
666 mVrFlingerRequestsDisplay = requestDisplay;
667 signalTransaction();
Dominik Laskowski8c001672018-05-30 16:52:06 -0700668 }));
Steven Thomas050b2c82017-03-06 11:45:16 -0800669 };
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700670 mVrFlinger = dvr::VrFlinger::Create(getHwComposer().getComposer(),
671 getHwComposer()
Dominik Laskowski075d3172018-05-24 15:50:06 -0700672 .fromPhysicalDisplayId(*display->getId())
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700673 .value_or(0),
674 vrFlingerRequestDisplayCallback);
Steven Thomas050b2c82017-03-06 11:45:16 -0800675 if (!mVrFlinger) {
676 ALOGE("Failed to start vrflinger");
677 }
678 }
679
Mathias Agopian92a979a2012-08-02 18:32:23 -0700680 // initialize our drawing state
681 mDrawingState = mCurrentState;
Mathias Agopian86303202012-07-24 22:46:10 -0700682
Andy McFadden13a082e2012-08-24 10:16:42 -0700683 // set initial conditions (e.g. unblank default device)
684 initializeDisplays();
685
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700686 getRenderEngine().primeCache();
Dan Stoza4e637772016-07-28 13:31:51 -0700687
Wei Wangf9b05ee2017-07-19 20:59:39 -0700688 // Inform native graphics APIs whether the present timestamp is supported:
Lloyd Pique90c115d2018-09-18 21:39:42 -0700689
690 const bool presentFenceReliable =
691 !getHwComposer().hasCapability(HWC2::Capability::PresentFenceIsNotReliable);
692 mStartPropertySetThread = getFactory().createStartPropertySetThread(presentFenceReliable);
Wei Wangf9b05ee2017-07-19 20:59:39 -0700693
694 if (mStartPropertySetThread->Start() != NO_ERROR) {
695 ALOGE("Run StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800696 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800697
Ady Abraham97d04232019-03-05 19:48:12 -0800698 if (mScheduler->isIdleTimerEnabled()) {
Ana Krulec8d3e4f32019-03-05 10:40:33 -0800699 mScheduler->setChangeRefreshRateCallback(
700 [this](RefreshRateType type, Scheduler::ConfigEvent event) {
701 Mutex::Autolock lock(mStateLock);
702 setRefreshRateTo(type, event);
703 });
Kevin DuBois36233132019-02-19 14:08:55 -0800704 }
Ady Abraham09bd3922019-04-08 10:44:56 -0700705
Dominik Laskowski22488f62019-03-28 09:53:04 -0700706 mRefreshRateConfigs.populate(getHwComposer().getConfigs(*display->getId()));
707 mRefreshRateStats.setConfigMode(getHwComposer().getActiveConfigIndex(*display->getId()));
Ana Krulec7d1d6832018-12-27 11:10:09 -0800708
Dan Stoza9e56aa02015-11-02 13:00:03 -0800709 ALOGV("Done initializing");
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700710}
711
Romain Guy11d63f42017-07-20 12:47:14 -0700712void SurfaceFlinger::readPersistentProperties() {
Chia-I Wu28f320b2018-05-03 11:02:56 -0700713 Mutex::Autolock _l(mStateLock);
714
Romain Guy11d63f42017-07-20 12:47:14 -0700715 char value[PROPERTY_VALUE_MAX];
716
717 property_get("persist.sys.sf.color_saturation", value, "1.0");
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800718 mGlobalSaturationFactor = atof(value);
Chia-I Wu28f320b2018-05-03 11:02:56 -0700719 updateColorMatrixLocked();
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800720 ALOGV("Saturation is set to %.2f", mGlobalSaturationFactor);
Romain Guy54f154a2017-10-24 21:40:32 +0100721
722 property_get("persist.sys.sf.native_mode", value, "0");
Chia-I Wu0d711262018-05-21 15:19:35 -0700723 mDisplayColorSetting = static_cast<DisplayColorSetting>(atoi(value));
Peiyong Lina3ea5592019-02-10 14:45:00 -0800724
725 property_get("persist.sys.sf.color_mode", value, "0");
726 mForceColorMode = static_cast<ColorMode>(atoi(value));
Romain Guy11d63f42017-07-20 12:47:14 -0700727}
728
Mathias Agopiana67e4182012-06-19 17:26:12 -0700729void SurfaceFlinger::startBootAnim() {
Wei Wangb254fa32017-01-31 17:43:23 -0800730 // Start boot animation service by setting a property mailbox
731 // if property setting thread is already running, Start() will be just a NOP
Wei Wangf9b05ee2017-07-19 20:59:39 -0700732 mStartPropertySetThread->Start();
Wei Wangb254fa32017-01-31 17:43:23 -0800733 // Wait until property was set
Wei Wangf9b05ee2017-07-19 20:59:39 -0700734 if (mStartPropertySetThread->join() != NO_ERROR) {
735 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800736 }
Mathias Agopiana67e4182012-06-19 17:26:12 -0700737}
738
Mathias Agopian875d8e12013-06-07 15:35:48 -0700739size_t SurfaceFlinger::getMaxTextureSize() const {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700740 return getRenderEngine().getMaxTextureSize();
Mathias Agopiana4912602012-07-12 14:25:33 -0700741}
742
Mathias Agopian875d8e12013-06-07 15:35:48 -0700743size_t SurfaceFlinger::getMaxViewportDims() const {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700744 return getRenderEngine().getMaxViewportDims();
Mathias Agopiana4912602012-07-12 14:25:33 -0700745}
746
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800747// ----------------------------------------------------------------------------
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800748
Jamie Gennis582270d2011-08-17 18:19:00 -0700749bool SurfaceFlinger::authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800750 const sp<IGraphicBufferProducer>& bufferProducer) const {
Jamie Gennis134f0422011-03-08 12:18:54 -0800751 Mutex::Autolock _l(mStateLock);
Robert Carr0d480722017-01-10 16:42:54 -0800752 return authenticateSurfaceTextureLocked(bufferProducer);
753}
754
755bool SurfaceFlinger::authenticateSurfaceTextureLocked(
756 const sp<IGraphicBufferProducer>& bufferProducer) const {
Marco Nelissen097ca272014-11-14 08:01:01 -0800757 sp<IBinder> surfaceTextureBinder(IInterface::asBinder(bufferProducer));
Dan Stoza101d8dc2018-02-27 15:42:25 -0800758 return mGraphicBufferProducerList.count(surfaceTextureBinder.get()) > 0;
Jamie Gennis134f0422011-03-08 12:18:54 -0800759}
760
Brian Anderson6b376712017-04-04 10:51:39 -0700761status_t SurfaceFlinger::getSupportedFrameTimestamps(
762 std::vector<FrameEvent>* outSupported) const {
763 *outSupported = {
764 FrameEvent::REQUESTED_PRESENT,
765 FrameEvent::ACQUIRE,
766 FrameEvent::LATCH,
767 FrameEvent::FIRST_REFRESH_START,
768 FrameEvent::LAST_REFRESH_START,
769 FrameEvent::GPU_COMPOSITION_DONE,
770 FrameEvent::DEQUEUE_READY,
771 FrameEvent::RELEASE,
772 };
Steven Thomas6d8110b2017-08-31 18:24:21 -0700773 ConditionalLock _l(mStateLock,
774 std::this_thread::get_id() != mMainThreadId);
Brian Anderson6b376712017-04-04 10:51:39 -0700775 if (!getHwComposer().hasCapability(
776 HWC2::Capability::PresentFenceIsNotReliable)) {
777 outSupported->push_back(FrameEvent::DISPLAY_PRESENT);
778 }
779 return NO_ERROR;
780}
781
Dominik Laskowski22488f62019-03-28 09:53:04 -0700782status_t SurfaceFlinger::getDisplayConfigs(const sp<IBinder>& displayToken,
783 Vector<DisplayInfo>* configs) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700784 if (!displayToken || !configs) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700785 return BAD_VALUE;
786 }
787
Dominik Laskowski22488f62019-03-28 09:53:04 -0700788 Mutex::Autolock lock(mStateLock);
789
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800790 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700791 if (!displayId) {
792 return NAME_NOT_FOUND;
Mathias Agopianc666cae2012-07-25 18:56:13 -0700793 }
Mathias Agopian8b736f12012-08-13 17:54:26 -0700794
Mathias Agopian8b736f12012-08-13 17:54:26 -0700795 // TODO: Not sure if display density should handled by SF any longer
796 class Density {
Hernan Liatis57568932018-08-16 17:07:08 -0700797 static float getDensityFromProperty(char const* propName) {
Mathias Agopian8b736f12012-08-13 17:54:26 -0700798 char property[PROPERTY_VALUE_MAX];
Hernan Liatis57568932018-08-16 17:07:08 -0700799 float density = 0.0f;
Peiyong Lin566a3b42018-01-09 18:22:43 -0800800 if (property_get(propName, property, nullptr) > 0) {
Hernan Liatis57568932018-08-16 17:07:08 -0700801 density = strtof(property, nullptr);
Mathias Agopian8b736f12012-08-13 17:54:26 -0700802 }
803 return density;
804 }
805 public:
Hernan Liatis57568932018-08-16 17:07:08 -0700806 static float getEmuDensity() {
Mathias Agopian8b736f12012-08-13 17:54:26 -0700807 return getDensityFromProperty("qemu.sf.lcd_density"); }
Hernan Liatis57568932018-08-16 17:07:08 -0700808 static float getBuildDensity() {
Mathias Agopian8b736f12012-08-13 17:54:26 -0700809 return getDensityFromProperty("ro.sf.lcd_density"); }
810 };
Mathias Agopian1604f772012-09-18 21:54:42 -0700811
Dan Stoza7f7da322014-05-02 15:26:25 -0700812 configs->clear();
Mathias Agopian1604f772012-09-18 21:54:42 -0700813
Dominik Laskowski075d3172018-05-24 15:50:06 -0700814 for (const auto& hwConfig : getHwComposer().getConfigs(*displayId)) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700815 DisplayInfo info = DisplayInfo();
816
Dan Stoza9e56aa02015-11-02 13:00:03 -0800817 float xdpi = hwConfig->getDpiX();
818 float ydpi = hwConfig->getDpiY();
Dan Stoza7f7da322014-05-02 15:26:25 -0700819
Yiwei Zhang27de5df2018-08-23 17:04:51 -0700820 info.w = hwConfig->getWidth();
821 info.h = hwConfig->getHeight();
822 // Default display viewport to display width and height
823 info.viewportW = info.w;
824 info.viewportH = info.h;
825
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800826 if (displayId == getInternalDisplayIdLocked()) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700827 // The density of the device is provided by a build property
828 float density = Density::getBuildDensity() / 160.0f;
829 if (density == 0) {
830 // the build doesn't provide a density -- this is wrong!
831 // use xdpi instead
832 ALOGE("ro.sf.lcd_density must be defined as a build property");
833 density = xdpi / 160.0f;
834 }
835 if (Density::getEmuDensity()) {
836 // if "qemu.sf.lcd_density" is specified, it overrides everything
837 xdpi = ydpi = density = Density::getEmuDensity();
838 density /= 160.0f;
839 }
840 info.density = density;
841
842 // TODO: this needs to go away (currently needed only by webkit)
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700843 const auto display = getDefaultDisplayDeviceLocked();
844 info.orientation = display ? display->getOrientation() : 0;
Yiwei Zhang27de5df2018-08-23 17:04:51 -0700845
846 // This is for screenrecord
847 const Rect viewport = display->getViewport();
848 if (viewport.isValid()) {
849 info.viewportW = uint32_t(viewport.getWidth());
850 info.viewportH = uint32_t(viewport.getHeight());
851 }
Dan Stoza7f7da322014-05-02 15:26:25 -0700852 } else {
853 // TODO: where should this value come from?
854 static const int TV_DENSITY = 213;
855 info.density = TV_DENSITY / 160.0f;
856 info.orientation = 0;
857 }
858
Dan Stoza7f7da322014-05-02 15:26:25 -0700859 info.xdpi = xdpi;
860 info.ydpi = ydpi;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800861 info.fps = 1e9 / hwConfig->getVsyncPeriod();
Ady Abraham796beb02019-04-11 15:23:07 -0700862 const auto refreshRateType = mRefreshRateConfigs.getRefreshRateType(hwConfig->getId());
863 const auto offset = mPhaseOffsets->getOffsetsForRefreshRate(refreshRateType);
864 info.appVsyncOffset = offset.late.app;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800865
Andy McFadden91b2ca82014-06-13 14:04:23 -0700866 // This is how far in advance a buffer must be queued for
867 // presentation at a given time. If you want a buffer to appear
868 // on the screen at time N, you must submit the buffer before
869 // (N - presentationDeadline).
870 //
871 // Normally it's one full refresh period (to give SF a chance to
872 // latch the buffer), but this can be reduced by configuring a
873 // DispSync offset. Any additional delays introduced by the hardware
874 // composer or panel must be accounted for here.
875 //
876 // We add an additional 1ms to allow for processing time and
877 // differences between the ideal and actual refresh rate.
Ady Abraham796beb02019-04-11 15:23:07 -0700878 info.presentationDeadline = hwConfig->getVsyncPeriod() - offset.late.sf + 1000000;
Dan Stoza7f7da322014-05-02 15:26:25 -0700879
880 // All non-virtual displays are currently considered secure.
881 info.secure = true;
882
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800883 if (displayId == getInternalDisplayIdLocked() &&
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700884 primaryDisplayOrientation & DisplayState::eOrientationSwapMask) {
Iris Chang7501ed62018-04-30 14:45:42 +0800885 std::swap(info.w, info.h);
886 }
887
Michael Wright28f24d02016-07-12 13:30:53 -0700888 configs->push_back(info);
Mathias Agopian8b736f12012-08-13 17:54:26 -0700889 }
890
Dan Stoza7f7da322014-05-02 15:26:25 -0700891 return NO_ERROR;
892}
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700893
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700894status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>&, DisplayStatInfo* stats) {
895 if (!stats) {
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700896 return BAD_VALUE;
897 }
898
Ana Krulecc2870422019-01-29 19:00:58 -0800899 mScheduler->getDisplayStatInfo(stats);
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700900 return NO_ERROR;
901}
902
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700903int SurfaceFlinger::getActiveConfig(const sp<IBinder>& displayToken) {
904 const auto display = getDisplayDevice(displayToken);
905 if (!display) {
906 ALOGE("getActiveConfig: Invalid display token %p", displayToken.get());
Jinguang Dong9f8b9ae2016-11-29 13:55:57 +0800907 return BAD_VALUE;
908 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700909
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700910 return display->getActiveConfig();
Dan Stoza7f7da322014-05-02 15:26:25 -0700911}
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700912
Ady Abraham03b02dd2019-03-21 15:40:11 -0700913void SurfaceFlinger::setDesiredActiveConfig(const ActiveConfigInfo& info) {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800914 ATRACE_CALL();
Ana Krulec7d1d6832018-12-27 11:10:09 -0800915
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800916 // Don't check against the current mode yet. Worst case we set the desired
Ady Abraham9360a222019-02-27 17:05:30 -0800917 // config twice. However event generation config might have changed so we need to update it
918 // accordingly
Ady Abrahamb838aed2019-02-12 15:30:16 -0800919 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Ady Abraham03b02dd2019-03-21 15:40:11 -0700920 const Scheduler::ConfigEvent prevConfig = mDesiredActiveConfig.event;
921 mDesiredActiveConfig = info;
922 mDesiredActiveConfig.event = mDesiredActiveConfig.event | prevConfig;
Ady Abrahamb838aed2019-02-12 15:30:16 -0800923
924 if (!mDesiredActiveConfigChanged) {
Ady Abrahamb838aed2019-02-12 15:30:16 -0800925 // This will trigger HWC refresh without resetting the idle timer.
926 repaintEverythingForHWC();
Alec Mouri754c98a2019-03-18 18:53:42 -0700927 // Start receiving vsync samples now, so that we can detect a period
928 // switch.
929 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
930 mPhaseOffsets->setRefreshRateType(info.type);
931 const auto [early, gl, late] = mPhaseOffsets->getCurrentOffsets();
932 mVsyncModulator.onRefreshRateChangeInitiated();
933 mVsyncModulator.setPhaseOffsets(early, gl, late);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800934 }
Ady Abrahamb838aed2019-02-12 15:30:16 -0800935 mDesiredActiveConfigChanged = true;
936 ATRACE_INT("DesiredActiveConfigChanged", mDesiredActiveConfigChanged);
Ady Abraham03b02dd2019-03-21 15:40:11 -0700937
938 if (mRefreshRateOverlay) {
939 mRefreshRateOverlay->changeRefreshRate(mDesiredActiveConfig.type);
940 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800941}
942
943status_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& displayToken, int mode) {
944 ATRACE_CALL();
Ady Abraham838de062019-02-04 10:24:03 -0800945
946 std::vector<int32_t> allowedConfig;
947 allowedConfig.push_back(mode);
948
949 return setAllowedDisplayConfigs(displayToken, allowedConfig);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800950}
951
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800952void SurfaceFlinger::setActiveConfigInternal() {
953 ATRACE_CALL();
954
Dominik Laskowski22488f62019-03-28 09:53:04 -0700955 const auto display = getDefaultDisplayDeviceLocked();
956 if (!display) {
957 return;
958 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800959
Dominik Laskowski22488f62019-03-28 09:53:04 -0700960 std::lock_guard<std::mutex> lock(mActiveConfigLock);
961 mRefreshRateStats.setConfigMode(mUpcomingActiveConfig.configId);
962
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800963 display->setActiveConfig(mUpcomingActiveConfig.configId);
964
Ana Krulecc2870422019-01-29 19:00:58 -0800965 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
Alec Mouri754c98a2019-03-18 18:53:42 -0700966 mPhaseOffsets->setRefreshRateType(mUpcomingActiveConfig.type);
Alec Mouri1c9e82b2019-03-07 12:24:05 -0800967 const auto [early, gl, late] = mPhaseOffsets->getCurrentOffsets();
968 mVsyncModulator.setPhaseOffsets(early, gl, late);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800969 ATRACE_INT("ActiveConfigMode", mUpcomingActiveConfig.configId);
Dominik Laskowski22488f62019-03-28 09:53:04 -0700970
Ana Krulec8d3e4f32019-03-05 10:40:33 -0800971 if (mUpcomingActiveConfig.event != Scheduler::ConfigEvent::None) {
Ady Abraham447052e2019-02-13 16:07:27 -0800972 mScheduler->onConfigChanged(mAppConnectionHandle, display->getId()->value,
973 mUpcomingActiveConfig.configId);
974 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800975}
976
Dominik Laskowski22488f62019-03-28 09:53:04 -0700977bool SurfaceFlinger::performSetActiveConfig() {
Alec Mourife3dc942019-02-12 14:19:18 -0800978 ATRACE_CALL();
Ady Abrahamb838aed2019-02-12 15:30:16 -0800979 if (mCheckPendingFence) {
Ady Abrahambe0f9482019-04-24 15:41:53 -0700980 if (previousFrameMissed()) {
Ady Abrahamb838aed2019-02-12 15:30:16 -0800981 // fence has not signaled yet. wait for the next invalidate
982 repaintEverythingForHWC();
983 return true;
984 }
985
986 // We received the present fence from the HWC, so we assume it successfully updated
987 // the config, hence we update SF.
988 mCheckPendingFence = false;
989 setActiveConfigInternal();
990 }
991
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800992 // Store the local variable to release the lock.
993 ActiveConfigInfo desiredActiveConfig;
994 {
995 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Ady Abrahamb838aed2019-02-12 15:30:16 -0800996 if (!mDesiredActiveConfigChanged) {
997 return false;
998 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800999 desiredActiveConfig = mDesiredActiveConfig;
1000 }
1001
Dominik Laskowski22488f62019-03-28 09:53:04 -07001002 const auto display = getDefaultDisplayDeviceLocked();
Ady Abrahamb838aed2019-02-12 15:30:16 -08001003 if (!display || display->getActiveConfig() == desiredActiveConfig.configId) {
1004 // display is not valid or we are already in the requested mode
1005 // on both cases there is nothing left to do
1006 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Ady Abraham6398a0a2019-04-18 19:30:44 -07001007 mDesiredActiveConfig.event = Scheduler::ConfigEvent::None;
Ady Abrahamb838aed2019-02-12 15:30:16 -08001008 mDesiredActiveConfigChanged = false;
1009 ATRACE_INT("DesiredActiveConfigChanged", mDesiredActiveConfigChanged);
1010 return false;
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001011 }
Ady Abrahamb838aed2019-02-12 15:30:16 -08001012
Ady Abraham838de062019-02-04 10:24:03 -08001013 // Desired active config was set, it is different than the config currently in use, however
1014 // allowed configs might have change by the time we process the refresh.
1015 // Make sure the desired config is still allowed
Dominik Laskowski22488f62019-03-28 09:53:04 -07001016 if (!isDisplayConfigAllowed(desiredActiveConfig.configId)) {
Ady Abraham838de062019-02-04 10:24:03 -08001017 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Alec Mouriecf2e0f2019-03-26 13:26:17 -07001018 mDesiredActiveConfig.event = Scheduler::ConfigEvent::None;
Ady Abraham838de062019-02-04 10:24:03 -08001019 mDesiredActiveConfig.configId = display->getActiveConfig();
Ady Abraham6398a0a2019-04-18 19:30:44 -07001020 mDesiredActiveConfigChanged = false;
1021 ATRACE_INT("DesiredActiveConfigChanged", mDesiredActiveConfigChanged);
Ady Abraham838de062019-02-04 10:24:03 -08001022 return false;
1023 }
Ady Abrahamb838aed2019-02-12 15:30:16 -08001024 mUpcomingActiveConfig = desiredActiveConfig;
1025 const auto displayId = display->getId();
1026 LOG_ALWAYS_FATAL_IF(!displayId);
1027
1028 ATRACE_INT("ActiveConfigModeHWC", mUpcomingActiveConfig.configId);
1029 getHwComposer().setActiveConfig(*displayId, mUpcomingActiveConfig.configId);
1030
1031 // we need to submit an empty frame to HWC to start the process
Ady Abrahamb838aed2019-02-12 15:30:16 -08001032 mCheckPendingFence = true;
1033
1034 return false;
Mathias Agopianc666cae2012-07-25 18:56:13 -07001035}
Dominik Laskowski075d3172018-05-24 15:50:06 -07001036
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001037status_t SurfaceFlinger::getDisplayColorModes(const sp<IBinder>& displayToken,
1038 Vector<ColorMode>* outColorModes) {
1039 if (!displayToken || !outColorModes) {
Michael Wright28f24d02016-07-12 13:30:53 -07001040 return BAD_VALUE;
1041 }
1042
Peiyong Lina52f0292018-03-14 17:26:31 -07001043 std::vector<ColorMode> modes;
Steven Thomas6d8110b2017-08-31 18:24:21 -07001044 {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001045 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
1046
1047 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1048 if (!displayId) {
1049 return NAME_NOT_FOUND;
1050 }
1051
Dominik Laskowski075d3172018-05-24 15:50:06 -07001052 modes = getHwComposer().getColorModes(*displayId);
Steven Thomas6d8110b2017-08-31 18:24:21 -07001053 }
Michael Wright28f24d02016-07-12 13:30:53 -07001054 outColorModes->clear();
1055 std::copy(modes.cbegin(), modes.cend(), std::back_inserter(*outColorModes));
1056
1057 return NO_ERROR;
1058}
1059
Daniel Solomon42d04562019-01-20 21:03:19 -08001060status_t SurfaceFlinger::getDisplayNativePrimaries(const sp<IBinder>& displayToken,
1061 ui::DisplayPrimaries &primaries) {
1062 if (!displayToken) {
1063 return BAD_VALUE;
1064 }
1065
1066 // Currently we only support this API for a single internal display.
1067 if (getInternalDisplayToken() != displayToken) {
1068 return BAD_VALUE;
1069 }
1070
1071 memcpy(&primaries, &mInternalDisplayPrimaries, sizeof(ui::DisplayPrimaries));
1072 return NO_ERROR;
1073}
1074
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001075ColorMode SurfaceFlinger::getActiveColorMode(const sp<IBinder>& displayToken) {
1076 if (const auto display = getDisplayDevice(displayToken)) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07001077 return display->getCompositionDisplay()->getState().colorMode;
Michael Wright28f24d02016-07-12 13:30:53 -07001078 }
Peiyong Lina52f0292018-03-14 17:26:31 -07001079 return static_cast<ColorMode>(BAD_VALUE);
Michael Wright28f24d02016-07-12 13:30:53 -07001080}
1081
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001082status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& displayToken, ColorMode mode) {
Dominik Laskowski8c001672018-05-30 16:52:06 -07001083 postMessageSync(new LambdaMessage([&] {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001084 Vector<ColorMode> modes;
1085 getDisplayColorModes(displayToken, &modes);
1086 bool exists = std::find(std::begin(modes), std::end(modes), mode) != std::end(modes);
1087 if (mode < ColorMode::NATIVE || !exists) {
1088 ALOGE("Attempt to set invalid active color mode %s (%d) for display token %p",
1089 decodeColorMode(mode).c_str(), mode, displayToken.get());
1090 return;
Michael Wright28f24d02016-07-12 13:30:53 -07001091 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001092 const auto display = getDisplayDevice(displayToken);
1093 if (!display) {
1094 ALOGE("Attempt to set active color mode %s (%d) for invalid display token %p",
1095 decodeColorMode(mode).c_str(), mode, displayToken.get());
1096 } else if (display->isVirtual()) {
1097 ALOGW("Attempt to set active color mode %s (%d) for virtual display",
1098 decodeColorMode(mode).c_str(), mode);
1099 } else {
Lloyd Pique32cbe282018-10-19 13:09:22 -07001100 display->getCompositionDisplay()->setColorMode(mode, Dataspace::UNKNOWN,
1101 RenderIntent::COLORIMETRIC);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001102 }
1103 }));
1104
Michael Wright28f24d02016-07-12 13:30:53 -07001105 return NO_ERROR;
1106}
Mathias Agopianc666cae2012-07-25 18:56:13 -07001107
Svetoslavd85084b2014-03-20 10:28:31 -07001108status_t SurfaceFlinger::clearAnimationFrameStats() {
1109 Mutex::Autolock _l(mStateLock);
1110 mAnimFrameTracker.clearStats();
1111 return NO_ERROR;
1112}
1113
1114status_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const {
1115 Mutex::Autolock _l(mStateLock);
1116 mAnimFrameTracker.getStats(outStats);
1117 return NO_ERROR;
1118}
1119
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001120status_t SurfaceFlinger::getHdrCapabilities(const sp<IBinder>& displayToken,
1121 HdrCapabilities* outCapabilities) const {
Dan Stozac4f471e2016-03-24 09:31:08 -07001122 Mutex::Autolock _l(mStateLock);
1123
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001124 const auto display = getDisplayDeviceLocked(displayToken);
1125 if (!display) {
1126 ALOGE("getHdrCapabilities: Invalid display token %p", displayToken.get());
Dan Stozac4f471e2016-03-24 09:31:08 -07001127 return BAD_VALUE;
1128 }
1129
Peiyong Linfb069302018-04-25 14:34:31 -07001130 // At this point the DisplayDeivce should already be set up,
1131 // meaning the luminance information is already queried from
1132 // hardware composer and stored properly.
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001133 const HdrCapabilities& capabilities = display->getHdrCapabilities();
Peiyong Linfb069302018-04-25 14:34:31 -07001134 *outCapabilities = HdrCapabilities(capabilities.getSupportedHdrTypes(),
1135 capabilities.getDesiredMaxLuminance(),
1136 capabilities.getDesiredMaxAverageLuminance(),
1137 capabilities.getDesiredMinLuminance());
Dan Stozac4f471e2016-03-24 09:31:08 -07001138
1139 return NO_ERROR;
1140}
1141
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001142status_t SurfaceFlinger::getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
1143 ui::PixelFormat* outFormat,
1144 ui::Dataspace* outDataspace,
1145 uint8_t* outComponentMask) const {
1146 if (!outFormat || !outDataspace || !outComponentMask) {
1147 return BAD_VALUE;
1148 }
Kevin DuBois74e53772018-11-19 10:52:38 -08001149 const auto display = getDisplayDevice(displayToken);
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001150 if (!display || !display->getId()) {
1151 ALOGE("getDisplayedContentSamplingAttributes: Bad display token: %p", display.get());
1152 return BAD_VALUE;
1153 }
1154 return getHwComposer().getDisplayedContentSamplingAttributes(*display->getId(), outFormat,
1155 outDataspace, outComponentMask);
1156}
1157
Kevin DuBois74e53772018-11-19 10:52:38 -08001158status_t SurfaceFlinger::setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken,
1159 bool enable, uint8_t componentMask,
1160 uint64_t maxFrames) const {
1161 const auto display = getDisplayDevice(displayToken);
1162 if (!display || !display->getId()) {
1163 ALOGE("setDisplayContentSamplingEnabled: Bad display token: %p", display.get());
1164 return BAD_VALUE;
1165 }
1166
1167 return getHwComposer().setDisplayContentSamplingEnabled(*display->getId(), enable,
1168 componentMask, maxFrames);
1169}
1170
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001171status_t SurfaceFlinger::getDisplayedContentSample(const sp<IBinder>& displayToken,
1172 uint64_t maxFrames, uint64_t timestamp,
1173 DisplayedFrameStats* outStats) const {
1174 const auto display = getDisplayDevice(displayToken);
1175 if (!display || !display->getId()) {
1176 ALOGE("getDisplayContentSample: Bad display token: %p", displayToken.get());
1177 return BAD_VALUE;
1178 }
1179
1180 return getHwComposer().getDisplayedContentSample(*display->getId(), maxFrames, timestamp,
1181 outStats);
1182}
1183
Peiyong Lin3c2791e2019-01-14 17:05:18 -08001184status_t SurfaceFlinger::getProtectedContentSupport(bool* outSupported) const {
1185 if (!outSupported) {
1186 return BAD_VALUE;
1187 }
1188 *outSupported = getRenderEngine().supportsProtectedContent();
1189 return NO_ERROR;
1190}
1191
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001192status_t SurfaceFlinger::isWideColorDisplay(const sp<IBinder>& displayToken,
1193 bool* outIsWideColorDisplay) const {
1194 if (!displayToken || !outIsWideColorDisplay) {
1195 return BAD_VALUE;
1196 }
1197 Mutex::Autolock _l(mStateLock);
1198 const auto display = getDisplayDeviceLocked(displayToken);
1199 if (!display) {
1200 return BAD_VALUE;
1201 }
1202 *outIsWideColorDisplay = display->hasWideColorGamut();
1203 return NO_ERROR;
1204}
1205
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001206status_t SurfaceFlinger::enableVSyncInjections(bool enable) {
Dominik Laskowski8c001672018-05-30 16:52:06 -07001207 postMessageSync(new LambdaMessage([&] {
Chia-I Wu90f669f2017-10-05 14:24:41 -07001208 Mutex::Autolock _l(mStateLock);
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001209
Chia-I Wu90f669f2017-10-05 14:24:41 -07001210 if (mInjectVSyncs == enable) {
1211 return;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001212 }
Chia-I Wu90f669f2017-10-05 14:24:41 -07001213
Ana Krulecc2870422019-01-29 19:00:58 -08001214 auto resyncCallback =
1215 mScheduler->makeResyncCallback(std::bind(&SurfaceFlinger::getVsyncPeriod, this));
Dominik Laskowskif654d572018-12-20 11:03:06 -08001216
Ady Abraham46e2f3e2019-03-18 16:40:15 -07001217 // TODO(b/128863962): Part of the Injector should be refactored, so that it
Ana Krulec98b5b242018-08-10 15:03:23 -07001218 // can be passed to Scheduler.
Chia-I Wu90f669f2017-10-05 14:24:41 -07001219 if (enable) {
1220 ALOGV("VSync Injections enabled");
1221 if (mVSyncInjector.get() == nullptr) {
Lloyd Piquee83f9312018-02-01 12:53:17 -08001222 mVSyncInjector = std::make_unique<InjectVSyncSource>();
Lloyd Pique24b0a482018-03-09 18:52:26 -08001223 mInjectorEventThread = std::make_unique<
Dominik Laskowskif654d572018-12-20 11:03:06 -08001224 impl::EventThread>(mVSyncInjector.get(),
Lloyd Pique24b0a482018-03-09 18:52:26 -08001225 impl::EventThread::InterceptVSyncsCallback(),
1226 "injEventThread");
Chia-I Wu90f669f2017-10-05 14:24:41 -07001227 }
Dominik Laskowskif654d572018-12-20 11:03:06 -08001228 mEventQueue->setEventThread(mInjectorEventThread.get(), std::move(resyncCallback));
Chia-I Wu90f669f2017-10-05 14:24:41 -07001229 } else {
1230 ALOGV("VSync Injections disabled");
Ana Krulecc2870422019-01-29 19:00:58 -08001231 mEventQueue->setEventThread(mScheduler->getEventThread(mSfConnectionHandle),
1232 std::move(resyncCallback));
Chia-I Wu90f669f2017-10-05 14:24:41 -07001233 }
1234
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001235 mInjectVSyncs = enable;
Dominik Laskowski8c001672018-05-30 16:52:06 -07001236 }));
1237
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001238 return NO_ERROR;
1239}
1240
1241status_t SurfaceFlinger::injectVSync(nsecs_t when) {
Chia-I Wu90f669f2017-10-05 14:24:41 -07001242 Mutex::Autolock _l(mStateLock);
1243
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001244 if (!mInjectVSyncs) {
1245 ALOGE("VSync Injections not enabled");
1246 return BAD_VALUE;
1247 }
1248 if (mInjectVSyncs && mInjectorEventThread.get() != nullptr) {
1249 ALOGV("Injecting VSync inside SurfaceFlinger");
1250 mVSyncInjector->onInjectSyncEvent(when);
1251 }
1252 return NO_ERROR;
1253}
1254
Lloyd Pique755e3192018-01-31 16:46:15 -08001255status_t SurfaceFlinger::getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const
1256 NO_THREAD_SAFETY_ANALYSIS {
Kalle Raitaa099a242017-01-11 11:17:29 -08001257 // Try to acquire a lock for 1s, fail gracefully
1258 const status_t err = mStateLock.timedLock(s2ns(1));
1259 const bool locked = (err == NO_ERROR);
1260 if (!locked) {
1261 ALOGE("LayerDebugInfo: SurfaceFlinger unresponsive (%s [%d]) - exit", strerror(-err), err);
1262 return TIMED_OUT;
1263 }
1264
1265 outLayers->clear();
1266 mCurrentState.traverseInZOrder([&](Layer* layer) {
1267 outLayers->push_back(layer->getLayerDebugInfo());
1268 });
1269
1270 mStateLock.unlock();
1271 return NO_ERROR;
1272}
1273
Peiyong Linc6780972018-10-28 15:24:08 -07001274status_t SurfaceFlinger::getCompositionPreference(
1275 Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
1276 Dataspace* outWideColorGamutDataspace,
1277 ui::PixelFormat* outWideColorGamutPixelFormat) const {
Peiyong Lin9d846a52018-11-05 13:18:20 -08001278 *outDataspace = mDefaultCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001279 *outPixelFormat = defaultCompositionPixelFormat;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001280 *outWideColorGamutDataspace = mWideColorGamutCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001281 *outWideColorGamutPixelFormat = wideColorGamutCompositionPixelFormat;
Peiyong Lin0256f722018-08-31 15:45:10 -07001282 return NO_ERROR;
1283}
1284
Dan Stozaec460082018-12-17 15:35:09 -08001285status_t SurfaceFlinger::addRegionSamplingListener(const Rect& samplingArea,
1286 const sp<IBinder>& stopLayerHandle,
1287 const sp<IRegionSamplingListener>& listener) {
tangrobinaf45f012019-02-26 18:10:10 +08001288 if (!listener || samplingArea == Rect::INVALID_RECT) {
Dan Stozaec460082018-12-17 15:35:09 -08001289 return BAD_VALUE;
1290 }
1291 mRegionSamplingThread->addListener(samplingArea, stopLayerHandle, listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001292 return NO_ERROR;
1293}
1294
Dan Stozaec460082018-12-17 15:35:09 -08001295status_t SurfaceFlinger::removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) {
tangrobinaf45f012019-02-26 18:10:10 +08001296 if (!listener) {
1297 return BAD_VALUE;
1298 }
Dan Stozaec460082018-12-17 15:35:09 -08001299 mRegionSamplingThread->removeListener(listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001300 return NO_ERROR;
1301}
Dan Gittik57e63c52019-01-18 16:37:54 +00001302
1303status_t SurfaceFlinger::getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
1304 bool* outSupport) const {
1305 if (!displayToken || !outSupport) {
1306 return BAD_VALUE;
1307 }
1308 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1309 if (!displayId) {
1310 return NAME_NOT_FOUND;
1311 }
1312 *outSupport =
1313 getHwComposer().hasDisplayCapability(displayId, HWC2::DisplayCapability::Brightness);
1314 return NO_ERROR;
1315}
1316
1317status_t SurfaceFlinger::setDisplayBrightness(const sp<IBinder>& displayToken,
1318 float brightness) const {
1319 if (!displayToken) {
1320 return BAD_VALUE;
1321 }
1322 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1323 if (!displayId) {
1324 return NAME_NOT_FOUND;
1325 }
1326 return getHwComposer().setDisplayBrightness(*displayId, brightness);
1327}
1328
Mathias Agopiand0566bc2011-11-17 17:49:17 -08001329// ----------------------------------------------------------------------------
1330
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -07001331sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection(
1332 ISurfaceComposer::VsyncSource vsyncSource) {
Ana Krulecc2870422019-01-29 19:00:58 -08001333 auto resyncCallback = mScheduler->makeResyncCallback([this] {
Dominik Laskowski83b88212018-12-11 13:34:06 -08001334 Mutex::Autolock lock(mStateLock);
1335 return getVsyncPeriod();
1336 });
Dominik Laskowskif654d572018-12-20 11:03:06 -08001337
Ana Krulecc2870422019-01-29 19:00:58 -08001338 const auto& handle =
1339 vsyncSource == eVsyncSourceSurfaceFlinger ? mSfConnectionHandle : mAppConnectionHandle;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001340
Ana Krulecc2870422019-01-29 19:00:58 -08001341 return mScheduler->createDisplayEventConnection(handle, std::move(resyncCallback));
Mathias Agopianbb641242010-05-18 17:06:55 -07001342}
1343
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001344// ----------------------------------------------------------------------------
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001345
1346void SurfaceFlinger::waitForEvent() {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001347 mEventQueue->waitMessage();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001348}
1349
1350void SurfaceFlinger::signalTransaction() {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001351 mEventQueue->invalidate();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001352}
1353
1354void SurfaceFlinger::signalLayerUpdate() {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001355 mEventQueue->invalidate();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001356}
1357
1358void SurfaceFlinger::signalRefresh() {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07001359 mRefreshPending = true;
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001360 mEventQueue->refresh();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001361}
1362
1363status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,
Dan Stozac7014012014-02-14 15:03:43 -08001364 nsecs_t reltime, uint32_t /* flags */) {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001365 return mEventQueue->postMessage(msg, reltime);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001366}
1367
1368status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
Dan Stozac7014012014-02-14 15:03:43 -08001369 nsecs_t reltime, uint32_t /* flags */) {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001370 status_t res = mEventQueue->postMessage(msg, reltime);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001371 if (res == NO_ERROR) {
1372 msg->wait();
1373 }
1374 return res;
1375}
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001376
Mathias Agopian4f4f0942013-08-19 17:26:18 -07001377void SurfaceFlinger::run() {
Mathias Agopian4f4f0942013-08-19 17:26:18 -07001378 do {
1379 waitForEvent();
1380 } while (true);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001381}
1382
Dominik Laskowski83b88212018-12-11 13:34:06 -08001383nsecs_t SurfaceFlinger::getVsyncPeriod() const {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001384 const auto displayId = getInternalDisplayIdLocked();
Dominik Laskowski83b88212018-12-11 13:34:06 -08001385 if (!displayId || !getHwComposer().isConnected(*displayId)) {
1386 return 0;
1387 }
1388
1389 const auto config = getHwComposer().getActiveConfig(*displayId);
1390 return config ? config->getVsyncPeriod() : 0;
1391}
1392
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001393void SurfaceFlinger::onVsyncReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId,
1394 int64_t timestamp) {
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001395 ATRACE_NAME("SF onVsync");
1396
Steven Thomas3cfac282017-02-06 12:29:30 -08001397 Mutex::Autolock lock(mStateLock);
Steven Thomasb02664d2017-07-26 18:48:28 -07001398 // Ignore any vsyncs from a previous hardware composer.
David Sodman105b7dc2017-11-04 20:28:14 -07001399 if (sequenceId != getBE().mComposerSequenceId) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001400 return;
1401 }
1402
Dominik Laskowski075d3172018-05-24 15:50:06 -07001403 if (!getHwComposer().onVsync(hwcDisplayId, timestamp)) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001404 return;
1405 }
1406
Dominik Laskowski075d3172018-05-24 15:50:06 -07001407 if (hwcDisplayId != getHwComposer().getInternalHwcDisplayId()) {
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001408 // For now, we don't do anything with external display vsyncs.
1409 return;
1410 }
1411
Alec Mouri754c98a2019-03-18 18:53:42 -07001412 bool periodChanged = false;
1413 mScheduler->addResyncSample(timestamp, &periodChanged);
1414 if (periodChanged) {
1415 mVsyncModulator.onRefreshRateChangeDetected();
1416 }
Mathias Agopian148994e2012-09-19 17:31:36 -07001417}
1418
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001419void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
David Sodman99974d22017-11-28 12:04:33 -08001420 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
1421 *compositorTiming = getBE().mCompositorTiming;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001422}
1423
Dominik Laskowski22488f62019-03-28 09:53:04 -07001424bool SurfaceFlinger::isDisplayConfigAllowed(int32_t configId) {
1425 return mAllowedDisplayConfigs.empty() || mAllowedDisplayConfigs.count(configId);
Ady Abraham838de062019-02-04 10:24:03 -08001426}
1427
Ana Krulec8d3e4f32019-03-05 10:40:33 -08001428void SurfaceFlinger::setRefreshRateTo(RefreshRateType refreshRate, Scheduler::ConfigEvent event) {
Dominik Laskowski22488f62019-03-28 09:53:04 -07001429 const auto display = getDefaultDisplayDeviceLocked();
1430 if (!display || mBootStage != BootStage::FINISHED) {
Ana Krulec7d1d6832018-12-27 11:10:09 -08001431 return;
1432 }
Alec Mouri1c9e82b2019-03-07 12:24:05 -08001433 ATRACE_CALL();
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001434
Ana Krulec7d1d6832018-12-27 11:10:09 -08001435 // Don't do any updating if the current fps is the same as the new one.
Dominik Laskowski22488f62019-03-28 09:53:04 -07001436 const auto& refreshRateConfig = mRefreshRateConfigs.getRefreshRate(refreshRate);
Alec Mouri0a1cc962019-03-14 12:33:02 -07001437 if (!refreshRateConfig) {
1438 ALOGV("Skipping refresh rate change request for unsupported rate.");
Ady Abraham1902d072019-03-01 17:18:59 -08001439 return;
Ana Krulec7d1d6832018-12-27 11:10:09 -08001440 }
Ady Abraham1902d072019-03-01 17:18:59 -08001441
Alec Mouri0a1cc962019-03-14 12:33:02 -07001442 const int desiredConfigId = refreshRateConfig->configId;
1443
Dominik Laskowski22488f62019-03-28 09:53:04 -07001444 if (!isDisplayConfigAllowed(desiredConfigId)) {
Ady Abraham1902d072019-03-01 17:18:59 -08001445 ALOGV("Skipping config %d as it is not part of allowed configs", desiredConfigId);
1446 return;
1447 }
1448
Alec Mouri0a1cc962019-03-14 12:33:02 -07001449 if (desiredConfigId == display->getActiveConfig()) {
1450 return;
1451 }
1452
Dominik Laskowski22488f62019-03-28 09:53:04 -07001453 setDesiredActiveConfig({refreshRate, desiredConfigId, event});
Ana Krulec7d1d6832018-12-27 11:10:09 -08001454}
1455
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001456void SurfaceFlinger::onHotplugReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId,
Lloyd Pique715a2c12017-12-14 17:18:08 -08001457 HWC2::Connection connection) {
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001458 ALOGV("%s(%d, %" PRIu64 ", %s)", __FUNCTION__, sequenceId, hwcDisplayId,
Lloyd Pique715a2c12017-12-14 17:18:08 -08001459 connection == HWC2::Connection::Connected ? "connected" : "disconnected");
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001460
Lloyd Piqueba04e622017-12-14 17:11:26 -08001461 // Ignore events that do not have the right sequenceId.
1462 if (sequenceId != getBE().mComposerSequenceId) {
1463 return;
1464 }
1465
Steven Thomasb02664d2017-07-26 18:48:28 -07001466 // Only lock if we're not on the main thread. This function is normally
1467 // called on a hwbinder thread, but for the primary display it's called on
1468 // the main thread with the state lock already held, so don't attempt to
1469 // acquire it here.
Lloyd Piqueba04e622017-12-14 17:11:26 -08001470 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
Steven Thomasb02664d2017-07-26 18:48:28 -07001471
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001472 mPendingHotplugEvents.emplace_back(HotplugEvent{hwcDisplayId, connection});
Mathias Agopian9e2463e2012-09-21 18:26:16 -07001473
Jiwen 'Steve' Caiccfd6822018-02-21 16:15:58 -08001474 if (std::this_thread::get_id() == mMainThreadId) {
1475 // Process all pending hot plug events immediately if we are on the main thread.
1476 processDisplayHotplugEventsLocked();
1477 }
1478
Lloyd Piqueba04e622017-12-14 17:11:26 -08001479 setTransactionFlags(eDisplayTransactionNeeded);
Mathias Agopian86303202012-07-24 22:46:10 -07001480}
1481
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001482void SurfaceFlinger::onRefreshReceived(int sequenceId, hwc2_display_t /*hwcDisplayId*/) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001483 Mutex::Autolock lock(mStateLock);
David Sodman105b7dc2017-11-04 20:28:14 -07001484 if (sequenceId != getBE().mComposerSequenceId) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001485 return;
Steven Thomas3cfac282017-02-06 12:29:30 -08001486 }
Ana Krulec7d1d6832018-12-27 11:10:09 -08001487 repaintEverythingForHWC();
Steven Thomas3cfac282017-02-06 12:29:30 -08001488}
1489
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001490void SurfaceFlinger::setPrimaryVsyncEnabled(bool enabled) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001491 ATRACE_CALL();
Steven Thomasb02664d2017-07-26 18:48:28 -07001492 Mutex::Autolock lock(mStateLock);
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001493 if (const auto displayId = getInternalDisplayIdLocked()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07001494 getHwComposer().setVsyncEnabled(*displayId,
1495 enabled ? HWC2::Vsync::Enable : HWC2::Vsync::Disable);
1496 }
Mathias Agopian86303202012-07-24 22:46:10 -07001497}
1498
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001499// Note: it is assumed the caller holds |mStateLock| when this is called
Steven Thomasb02664d2017-07-26 18:48:28 -07001500void SurfaceFlinger::resetDisplayState() {
Ana Krulecc2870422019-01-29 19:00:58 -08001501 mScheduler->disableHardwareVsync(true);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001502 // Clear the drawing state so that the logic inside of
1503 // handleTransactionLocked will fire. It will determine the delta between
1504 // mCurrentState and mDrawingState and re-apply all changes when we make the
1505 // transition.
1506 mDrawingState.displays.clear();
1507 mDisplays.clear();
1508}
1509
Steven Thomas050b2c82017-03-06 11:45:16 -08001510void SurfaceFlinger::updateVrFlinger() {
Alec Mourife3dc942019-02-12 14:19:18 -08001511 ATRACE_CALL();
Steven Thomas050b2c82017-03-06 11:45:16 -08001512 if (!mVrFlinger)
1513 return;
1514 bool vrFlingerRequestsDisplay = mVrFlingerRequestsDisplay;
Lloyd Pique441d5042018-10-18 16:49:51 -07001515 if (vrFlingerRequestsDisplay == getHwComposer().isUsingVrComposer()) {
Mark Urbanus209beca2017-02-23 11:16:04 -08001516 return;
1517 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001518
Lloyd Pique441d5042018-10-18 16:49:51 -07001519 if (vrFlingerRequestsDisplay && !getHwComposer().getComposer()->isRemote()) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001520 ALOGE("Vr flinger is only supported for remote hardware composer"
1521 " service connections. Ignoring request to transition to vr"
1522 " flinger.");
1523 mVrFlingerRequestsDisplay = false;
1524 return;
Mark Urbanus209beca2017-02-23 11:16:04 -08001525 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001526
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001527 Mutex::Autolock _l(mStateLock);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001528
Steven Thomas0123ac62018-07-12 11:32:34 -07001529 sp<DisplayDevice> display = getDefaultDisplayDeviceLocked();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07001530 LOG_ALWAYS_FATAL_IF(!display);
Lloyd Pique07e33212018-12-18 16:33:37 -08001531
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07001532 const int currentDisplayPowerMode = display->getPowerMode();
Lloyd Pique07e33212018-12-18 16:33:37 -08001533
1534 // Clear out all the output layers from the composition engine for all
1535 // displays before destroying the hardware composer interface. This ensures
1536 // any HWC layers are destroyed through that interface before it becomes
1537 // invalid.
1538 for (const auto& [token, displayDevice] : mDisplays) {
1539 displayDevice->getCompositionDisplay()->setOutputLayersOrderedByZ(
1540 compositionengine::Output::OutputLayers());
1541 }
1542
Steven Thomas0123ac62018-07-12 11:32:34 -07001543 // This DisplayDevice will no longer be relevant once resetDisplayState() is
1544 // called below. Clear the reference now so we don't accidentally use it
1545 // later.
1546 display.clear();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001547
Steven Thomasb02664d2017-07-26 18:48:28 -07001548 if (!vrFlingerRequestsDisplay) {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001549 mVrFlinger->SeizeDisplayOwnership();
Steven Thomasb02664d2017-07-26 18:48:28 -07001550 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001551
Steven Thomasb02664d2017-07-26 18:48:28 -07001552 resetDisplayState();
Lloyd Pique441d5042018-10-18 16:49:51 -07001553 // Delete the current instance before creating the new one
1554 mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
1555 mCompositionEngine->setHwComposer(getFactory().createHWComposer(
1556 vrFlingerRequestsDisplay ? "vr" : getBE().mHwcServiceName));
1557 getHwComposer().registerCallback(this, ++getBE().mComposerSequenceId);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001558
Lloyd Pique441d5042018-10-18 16:49:51 -07001559 LOG_ALWAYS_FATAL_IF(!getHwComposer().getComposer()->isRemote(),
David Sodman105b7dc2017-11-04 20:28:14 -07001560 "Switched to non-remote hardware composer");
Steven Thomasb02664d2017-07-26 18:48:28 -07001561
1562 if (vrFlingerRequestsDisplay) {
1563 mVrFlinger->GrantDisplayOwnership();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001564 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001565
1566 mVisibleRegionsDirty = true;
1567 invalidateHwcGeometry();
1568
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001569 // Re-enable default display.
Steven Thomas0123ac62018-07-12 11:32:34 -07001570 display = getDefaultDisplayDeviceLocked();
1571 LOG_ALWAYS_FATAL_IF(!display);
Dominik Laskowskie9774092018-12-11 10:04:24 -08001572 setPowerModeInternal(display, currentDisplayPowerMode);
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001573
Steven Thomasb02664d2017-07-26 18:48:28 -07001574 // Reset the timing values to account for the period of the swapped in HWC
Dominik Laskowski83b88212018-12-11 13:34:06 -08001575 const nsecs_t vsyncPeriod = getVsyncPeriod();
1576 mAnimFrameTracker.setDisplayRefreshPeriod(vsyncPeriod);
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001577
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001578 // The present fences returned from vr_hwc are not an accurate
1579 // representation of vsync times.
Ana Krulecc2870422019-01-29 19:00:58 -08001580 mScheduler->setIgnorePresentFences(getHwComposer().isUsingVrComposer() || !hasSyncFramework);
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001581
Steven Thomasb02664d2017-07-26 18:48:28 -07001582 // Use phase of 0 since phase is not known.
1583 // Use latency of 0, which will snap to the ideal latency.
Dominik Laskowski83b88212018-12-11 13:34:06 -08001584 DisplayStatInfo stats{0 /* vsyncTime */, vsyncPeriod};
Ana Krulece588e312018-09-18 12:32:24 -07001585 setCompositorTimingSnapped(stats, 0);
Stephen Kiazyk82386cd2017-04-14 13:43:29 -07001586
Ana Krulecc2870422019-01-29 19:00:58 -08001587 mScheduler->resyncToHardwareVsync(false, vsyncPeriod);
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001588
Lloyd Piquef1c675b2018-09-12 20:45:39 -07001589 mRepaintEverything = true;
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001590 setTransactionFlags(eDisplayTransactionNeeded);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001591}
1592
Ady Abrahambe0f9482019-04-24 15:41:53 -07001593bool SurfaceFlinger::previousFrameMissed() NO_THREAD_SAFETY_ANALYSIS {
1594 // We are storing the last 2 present fences. If sf's phase offset is to be
1595 // woken up before the actual vsync but targeting the next vsync, we need to check
1596 // fence N-2
1597 const sp<Fence>& fence =
1598 mVsyncModulator.getOffsets().sf < mPhaseOffsets->getOffsetThresholdForNextVsync()
1599 ? mPreviousPresentFences[0]
1600 : mPreviousPresentFences[1];
1601
1602 return fence != Fence::NO_FENCE && (fence->getStatus() == Fence::Status::Unsignaled);
1603}
1604
Dominik Laskowski22488f62019-03-28 09:53:04 -07001605void SurfaceFlinger::onMessageReceived(int32_t what) NO_THREAD_SAFETY_ANALYSIS {
Jamie Gennis1c8e95c2012-02-23 19:27:23 -08001606 ATRACE_CALL();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001607 switch (what) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08001608 case MessageQueue::INVALIDATE: {
Ady Abrahambe0f9482019-04-24 15:41:53 -07001609 bool frameMissed = previousFrameMissed();
Alec Mouricc0fc602019-02-26 21:45:19 -08001610 bool hwcFrameMissed = mHadDeviceComposition && frameMissed;
1611 bool gpuFrameMissed = mHadClientComposition && frameMissed;
1612 ATRACE_INT("FrameMissed", static_cast<int>(frameMissed));
1613 ATRACE_INT("HwcFrameMissed", static_cast<int>(hwcFrameMissed));
1614 ATRACE_INT("GpuFrameMissed", static_cast<int>(gpuFrameMissed));
1615 if (frameMissed) {
1616 mFrameMissedCount++;
1617 mTimeStats->incrementMissedFrames();
1618 }
1619
Alec Mouri40189b02019-03-05 15:07:54 -08001620 if (hwcFrameMissed) {
1621 mHwcFrameMissedCount++;
1622 }
1623
1624 if (gpuFrameMissed) {
1625 mGpuFrameMissedCount++;
1626 }
1627
Ana Krulecfefd6ae2019-02-13 17:53:08 -08001628 if (mUseSmart90ForVideo) {
1629 // This call is made each time SF wakes up and creates a new frame. It is part
1630 // of video detection feature.
Ady Abraham09bd3922019-04-08 10:44:56 -07001631 mScheduler->updateFpsBasedOnContent();
Ana Krulecfefd6ae2019-02-13 17:53:08 -08001632 }
1633
Ady Abrahamb838aed2019-02-12 15:30:16 -08001634 if (performSetActiveConfig()) {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001635 break;
1636 }
1637
Alec Mourife3dc942019-02-12 14:19:18 -08001638 // For now, only propagate backpressure when missing a hwc frame.
1639 if (hwcFrameMissed) {
Yiwei Zhang621f9d42018-05-07 10:40:55 -07001640 if (mPropagateBackpressure) {
1641 signalLayerUpdate();
1642 break;
1643 }
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07001644 }
Dan Stoza50182882016-07-08 12:02:20 -07001645
Steven Thomas050b2c82017-03-06 11:45:16 -08001646 // Now that we're going to make it to the handleMessageTransaction()
1647 // call below it's safe to call updateVrFlinger(), which will
1648 // potentially trigger a display handoff.
1649 updateVrFlinger();
1650
Dan Stoza6b9454d2014-11-07 16:00:59 -08001651 bool refreshNeeded = handleMessageTransaction();
1652 refreshNeeded |= handleMessageInvalidate();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001653
1654 updateCursorAsync();
1655 updateInputFlinger();
1656
Dan Stoza58784442014-12-02 16:58:17 -08001657 refreshNeeded |= mRepaintEverything;
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08001658 if (refreshNeeded && CC_LIKELY(mBootStage != BootStage::BOOTLOADER)) {
Dan Stoza58784442014-12-02 16:58:17 -08001659 // Signal a refresh if a transaction modified the window state,
1660 // a new buffer was latched, or if HWC has requested a full
1661 // repaint
Dan Stoza6b9454d2014-11-07 16:00:59 -08001662 signalRefresh();
1663 }
1664 break;
1665 }
1666 case MessageQueue::REFRESH: {
1667 handleMessageRefresh();
1668 break;
1669 }
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001670 }
1671}
1672
Dan Stoza6b9454d2014-11-07 16:00:59 -08001673bool SurfaceFlinger::handleMessageTransaction() {
Alec Mourife3dc942019-02-12 14:19:18 -08001674 ATRACE_CALL();
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08001675 uint32_t transactionFlags = peekTransactionFlags();
Marissa Wall713b63f2018-10-17 15:42:43 -07001676
Marissa Walle6e3c0d2019-03-29 10:28:30 -07001677 bool flushedATransaction = flushTransactionQueues();
1678
1679 bool runHandleTransaction = transactionFlags &&
1680 ((transactionFlags != eTransactionFlushNeeded) || flushedATransaction);
1681
1682 if (runHandleTransaction) {
1683 handleTransaction(eTransactionMask);
1684 } else {
1685 getTransactionFlags(eTransactionFlushNeeded);
Marissa Wall713b63f2018-10-17 15:42:43 -07001686 }
1687
Marissa Walle6e3c0d2019-03-29 10:28:30 -07001688 if (transactionFlushNeeded()) {
1689 setTransactionFlags(eTransactionFlushNeeded);
Mathias Agopian4fec8732012-06-29 14:12:52 -07001690 }
Marissa Wall713b63f2018-10-17 15:42:43 -07001691
Marissa Walle6e3c0d2019-03-29 10:28:30 -07001692 return runHandleTransaction;
Mathias Agopian4fec8732012-06-29 14:12:52 -07001693}
1694
Mathias Agopian4fec8732012-06-29 14:12:52 -07001695void SurfaceFlinger::handleMessageRefresh() {
Mathias Agopiancd60f992012-08-16 16:28:27 -07001696 ATRACE_CALL();
Dan Stoza14cd37c2015-07-09 12:43:33 -07001697
Dan Stoza2b6d38e2017-06-01 16:40:30 -07001698 mRefreshPending = false;
1699
Lloyd Piquef1c675b2018-09-12 20:45:39 -07001700 const bool repaintEverything = mRepaintEverything.exchange(false);
David Sodman2b406362017-12-15 13:33:47 -08001701 preComposition();
Lloyd Pique074e8122018-07-26 12:57:23 -07001702 rebuildLayerStacks();
David Sodman79bba0e2018-08-05 18:07:49 -07001703 calculateWorkingSet();
David Sodmanfa9b2af2017-12-24 13:28:59 -08001704 for (const auto& [token, display] : mDisplays) {
1705 beginFrame(display);
1706 prepareFrame(display);
1707 doDebugFlashRegions(display, repaintEverything);
1708 doComposition(display, repaintEverything);
1709 }
1710
Yiwei Zhang7124ad32018-02-21 13:02:45 -08001711 logLayerStats();
David Sodmanfa9b2af2017-12-24 13:28:59 -08001712
1713 postFrame();
David Sodman2b406362017-12-15 13:33:47 -08001714 postComposition();
Dan Stoza05dacfb2016-07-01 13:33:38 -07001715
Dan Stozabfbffeb2016-07-21 14:49:33 -07001716 mHadClientComposition = false;
Alec Mouricc0fc602019-02-26 21:45:19 -08001717 mHadDeviceComposition = false;
Lloyd Pique32cbe282018-10-19 13:09:22 -07001718 for (const auto& [token, displayDevice] : mDisplays) {
1719 auto display = displayDevice->getCompositionDisplay();
1720 const auto displayId = display->getId();
Lloyd Pique441d5042018-10-18 16:49:51 -07001721 mHadClientComposition =
Lloyd Pique32cbe282018-10-19 13:09:22 -07001722 mHadClientComposition || getHwComposer().hasClientComposition(displayId);
Alec Mouricc0fc602019-02-26 21:45:19 -08001723 mHadDeviceComposition =
1724 mHadDeviceComposition || getHwComposer().hasDeviceComposition(displayId);
Dan Stozabfbffeb2016-07-21 14:49:33 -07001725 }
David Sodmanfa9b2af2017-12-24 13:28:59 -08001726
Jorim Jaggi90535212018-05-23 23:44:06 +02001727 mVsyncModulator.onRefreshed(mHadClientComposition);
Dan Stoza14cd37c2015-07-09 12:43:33 -07001728
David Sodman7e4ae112018-02-09 15:02:28 -08001729 mLayersWithQueuedFrames.clear();
Mathias Agopiancd60f992012-08-16 16:28:27 -07001730}
Mathias Agopian4fec8732012-06-29 14:12:52 -07001731
David Sodmanfa9b2af2017-12-24 13:28:59 -08001732
1733bool SurfaceFlinger::handleMessageInvalidate() {
1734 ATRACE_CALL();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001735 bool refreshNeeded = handlePageFlip();
1736
Vishnu Nair4351ad52019-02-11 14:13:02 -08001737 if (mVisibleRegionsDirty) {
1738 computeLayerBounds();
Nataniel Borges2b796da2019-02-15 13:32:18 -08001739 if (mTracingEnabled) {
1740 mTracing.notify("visibleRegionsDirty");
1741 }
Vishnu Nair4351ad52019-02-11 14:13:02 -08001742 }
1743
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001744 for (auto& layer : mLayersPendingRefresh) {
1745 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08001746 visibleReg.set(layer->getScreenBounds());
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001747 invalidateLayerStack(layer, visibleReg);
1748 }
1749 mLayersPendingRefresh.clear();
1750 return refreshNeeded;
Mathias Agopian4fec8732012-06-29 14:12:52 -07001751}
1752
David Sodman79bba0e2018-08-05 18:07:49 -07001753void SurfaceFlinger::calculateWorkingSet() {
1754 ATRACE_CALL();
1755 ALOGV(__FUNCTION__);
1756
David Sodman79bba0e2018-08-05 18:07:49 -07001757 // build the h/w work list
1758 if (CC_UNLIKELY(mGeometryInvalid)) {
1759 mGeometryInvalid = false;
Lloyd Pique32cbe282018-10-19 13:09:22 -07001760 for (const auto& [token, displayDevice] : mDisplays) {
1761 auto display = displayDevice->getCompositionDisplay();
David Sodman79bba0e2018-08-05 18:07:49 -07001762
Lloyd Piquea83776c2019-01-29 18:42:32 -08001763 uint32_t zOrder = 0;
David Sodman79bba0e2018-08-05 18:07:49 -07001764
Lloyd Piquea83776c2019-01-29 18:42:32 -08001765 for (auto& layer : display->getOutputLayersOrderedByZ()) {
1766 auto& compositionState = layer->editState();
1767 compositionState.forceClientComposition = false;
1768 if (!compositionState.hwc || mDebugDisableHWC || mDebugRegion) {
1769 compositionState.forceClientComposition = true;
David Sodman79bba0e2018-08-05 18:07:49 -07001770 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07001771
Lloyd Piquea83776c2019-01-29 18:42:32 -08001772 // The output Z order is set here based on a simple counter.
1773 compositionState.z = zOrder++;
1774
1775 // Update the display independent composition state. This goes
1776 // to the general composition layer state structure.
1777 // TODO: Do this once per compositionengine::CompositionLayer.
1778 layer->getLayerFE().latchCompositionState(layer->getLayer().editState().frontEnd,
1779 true);
1780
1781 // Recalculate the geometry state of the output layer.
1782 layer->updateCompositionState(true);
1783
1784 // Write the updated geometry state to the HWC
1785 layer->writeStateToHWC(true);
David Sodman79bba0e2018-08-05 18:07:49 -07001786 }
1787 }
1788 }
1789
1790 // Set the per-frame data
Lloyd Pique32cbe282018-10-19 13:09:22 -07001791 for (const auto& [token, displayDevice] : mDisplays) {
1792 auto display = displayDevice->getCompositionDisplay();
David Sodman79bba0e2018-08-05 18:07:49 -07001793 const auto displayId = display->getId();
Dominik Laskowski075d3172018-05-24 15:50:06 -07001794 if (!displayId) {
David Sodman79bba0e2018-08-05 18:07:49 -07001795 continue;
1796 }
Lloyd Pique3d0c02e2018-10-19 18:38:12 -07001797 auto* profile = display->getDisplayColorProfile();
David Sodman79bba0e2018-08-05 18:07:49 -07001798
1799 if (mDrawingState.colorMatrixChanged) {
1800 display->setColorTransform(mDrawingState.colorMatrix);
David Sodman79bba0e2018-08-05 18:07:49 -07001801 }
Peiyong Linc502cb72019-03-01 15:00:23 -08001802 Dataspace targetDataspace = Dataspace::UNKNOWN;
1803 if (useColorManagement) {
1804 ColorMode colorMode;
1805 RenderIntent renderIntent;
1806 pickColorMode(displayDevice, &colorMode, &targetDataspace, &renderIntent);
1807 display->setColorMode(colorMode, targetDataspace, renderIntent);
1808 }
Lloyd Pique32cbe282018-10-19 13:09:22 -07001809 for (auto& layer : displayDevice->getVisibleLayersSortedByZ()) {
David Sodman79bba0e2018-08-05 18:07:49 -07001810 if (layer->isHdrY410()) {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001811 layer->forceClientComposition(displayDevice);
David Sodman79bba0e2018-08-05 18:07:49 -07001812 } else if ((layer->getDataSpace() == Dataspace::BT2020_PQ ||
1813 layer->getDataSpace() == Dataspace::BT2020_ITU_PQ) &&
Lloyd Pique3d0c02e2018-10-19 18:38:12 -07001814 !profile->hasHDR10Support()) {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001815 layer->forceClientComposition(displayDevice);
David Sodman79bba0e2018-08-05 18:07:49 -07001816 } else if ((layer->getDataSpace() == Dataspace::BT2020_HLG ||
1817 layer->getDataSpace() == Dataspace::BT2020_ITU_HLG) &&
Lloyd Pique3d0c02e2018-10-19 18:38:12 -07001818 !profile->hasHLGSupport()) {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001819 layer->forceClientComposition(displayDevice);
David Sodman79bba0e2018-08-05 18:07:49 -07001820 }
1821
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001822 if (layer->getRoundedCornerState().radius > 0.0f) {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001823 layer->forceClientComposition(displayDevice);
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001824 }
1825
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001826 if (layer->getForceClientComposition(displayDevice)) {
David Sodman79bba0e2018-08-05 18:07:49 -07001827 ALOGV("[%s] Requesting Client composition", layer->getName().string());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001828 layer->setCompositionType(displayDevice,
1829 Hwc2::IComposerClient::Composition::CLIENT);
David Sodman79bba0e2018-08-05 18:07:49 -07001830 continue;
1831 }
1832
Lloyd Pique32cbe282018-10-19 13:09:22 -07001833 const auto& displayState = display->getState();
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001834 layer->setPerFrameData(displayDevice, displayState.transform, displayState.viewport,
Peiyong Lin34ea5b92019-03-15 18:40:15 -07001835 displayDevice->getSupportedPerFrameMetadata(),
1836 isHdrColorMode(displayState.colorMode) ? Dataspace::UNKNOWN
1837 : targetDataspace);
David Sodman79bba0e2018-08-05 18:07:49 -07001838 }
1839 }
1840
1841 mDrawingState.colorMatrixChanged = false;
David Sodmanba340492018-08-05 21:51:33 -07001842
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001843 for (const auto& [token, displayDevice] : mDisplays) {
1844 auto display = displayDevice->getCompositionDisplay();
1845 for (auto& layer : displayDevice->getVisibleLayersSortedByZ()) {
Lloyd Pique0b785d82018-12-04 17:25:27 -08001846 auto& layerState = layer->getCompositionLayer()->editState().frontEnd;
1847 layerState.compositionType = static_cast<Hwc2::IComposerClient::Composition>(
1848 layer->getCompositionType(displayDevice));
David Sodmanba340492018-08-05 21:51:33 -07001849 }
1850 }
David Sodman79bba0e2018-08-05 18:07:49 -07001851}
1852
Lloyd Pique32cbe282018-10-19 13:09:22 -07001853void SurfaceFlinger::doDebugFlashRegions(const sp<DisplayDevice>& displayDevice,
1854 bool repaintEverything) {
1855 auto display = displayDevice->getCompositionDisplay();
1856 const auto& displayState = display->getState();
1857
Mathias Agopiancd60f992012-08-16 16:28:27 -07001858 // is debugging enabled
1859 if (CC_LIKELY(!mDebugRegion))
1860 return;
1861
Lloyd Pique32cbe282018-10-19 13:09:22 -07001862 if (displayState.isEnabled) {
David Sodmanfa9b2af2017-12-24 13:28:59 -08001863 // transform the dirty region into this screen's coordinate space
Alec Mourie7d1d4a2019-02-05 01:13:46 +00001864 const Region dirtyRegion = display->getDirtyRegion(repaintEverything);
David Sodmanfa9b2af2017-12-24 13:28:59 -08001865 if (!dirtyRegion.isEmpty()) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +00001866 base::unique_fd readyFence;
David Sodmanfa9b2af2017-12-24 13:28:59 -08001867 // redraw the whole screen
Alec Mourie7d1d4a2019-02-05 01:13:46 +00001868 doComposeSurfaces(displayDevice, dirtyRegion, &readyFence);
Mathias Agopiancd60f992012-08-16 16:28:27 -07001869
Alec Mourie7d1d4a2019-02-05 01:13:46 +00001870 display->getRenderSurface()->queueBuffer(std::move(readyFence));
Mathias Agopiancd60f992012-08-16 16:28:27 -07001871 }
1872 }
1873
Lloyd Pique32cbe282018-10-19 13:09:22 -07001874 postFramebuffer(displayDevice);
Mathias Agopiancd60f992012-08-16 16:28:27 -07001875
1876 if (mDebugRegion > 1) {
1877 usleep(mDebugRegion * 1000);
1878 }
Mathias Agopianbb53b0e2012-09-24 21:27:29 -07001879
Lloyd Pique32cbe282018-10-19 13:09:22 -07001880 prepareFrame(displayDevice);
Mathias Agopiancd60f992012-08-16 16:28:27 -07001881}
1882
Yiwei Zhang7124ad32018-02-21 13:02:45 -08001883void SurfaceFlinger::logLayerStats() {
1884 ATRACE_CALL();
1885 if (CC_UNLIKELY(mLayerStats.isEnabled())) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07001886 for (const auto& [token, display] : mDisplays) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001887 if (display->isPrimary()) {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001888 mLayerStats.logLayerStats(dumpVisibleLayersProtoInfo(display));
Dominik Laskowski63165dc2018-05-25 18:36:52 -07001889 return;
Yiwei Zhang7124ad32018-02-21 13:02:45 -08001890 }
1891 }
Dominik Laskowski63165dc2018-05-25 18:36:52 -07001892
1893 ALOGE("logLayerStats: no primary display");
Yiwei Zhang7124ad32018-02-21 13:02:45 -08001894 }
1895}
1896
David Sodman2b406362017-12-15 13:33:47 -08001897void SurfaceFlinger::preComposition()
Mathias Agopiancd60f992012-08-16 16:28:27 -07001898{
Dan Stoza9e56aa02015-11-02 13:00:03 -08001899 ATRACE_CALL();
1900 ALOGV("preComposition");
1901
David Sodman2b406362017-12-15 13:33:47 -08001902 mRefreshStartTime = systemTime(SYSTEM_TIME_MONOTONIC);
1903
Mathias Agopiancd60f992012-08-16 16:28:27 -07001904 bool needExtraInvalidate = false;
Robert Carr2047fae2016-11-28 14:09:09 -08001905 mDrawingState.traverseInZOrder([&](Layer* layer) {
David Sodman2b406362017-12-15 13:33:47 -08001906 if (layer->onPreComposition(mRefreshStartTime)) {
Mathias Agopiancd60f992012-08-16 16:28:27 -07001907 needExtraInvalidate = true;
1908 }
Robert Carr2047fae2016-11-28 14:09:09 -08001909 });
1910
Mathias Agopiancd60f992012-08-16 16:28:27 -07001911 if (needExtraInvalidate) {
1912 signalLayerUpdate();
1913 }
1914}
1915
Ana Krulece588e312018-09-18 12:32:24 -07001916void SurfaceFlinger::updateCompositorTiming(const DisplayStatInfo& stats, nsecs_t compositeTime,
1917 std::shared_ptr<FenceTime>& presentFenceTime) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001918 // Update queue of past composite+present times and determine the
1919 // most recently known composite to present latency.
David Sodman99974d22017-11-28 12:04:33 -08001920 getBE().mCompositePresentTimes.push({compositeTime, presentFenceTime});
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001921 nsecs_t compositeToPresentLatency = -1;
David Sodman99974d22017-11-28 12:04:33 -08001922 while (!getBE().mCompositePresentTimes.empty()) {
1923 SurfaceFlingerBE::CompositePresentTime& cpt = getBE().mCompositePresentTimes.front();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001924 // Cached values should have been updated before calling this method,
1925 // which helps avoid duplicate syscalls.
1926 nsecs_t displayTime = cpt.display->getCachedSignalTime();
1927 if (displayTime == Fence::SIGNAL_TIME_PENDING) {
1928 break;
1929 }
1930 compositeToPresentLatency = displayTime - cpt.composite;
David Sodman99974d22017-11-28 12:04:33 -08001931 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001932 }
1933
1934 // Don't let mCompositePresentTimes grow unbounded, just in case.
David Sodman99974d22017-11-28 12:04:33 -08001935 while (getBE().mCompositePresentTimes.size() > 16) {
1936 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001937 }
1938
Ana Krulece588e312018-09-18 12:32:24 -07001939 setCompositorTimingSnapped(stats, compositeToPresentLatency);
Brian Andersond0010582017-03-07 13:20:31 -08001940}
1941
Ana Krulece588e312018-09-18 12:32:24 -07001942void SurfaceFlinger::setCompositorTimingSnapped(const DisplayStatInfo& stats,
1943 nsecs_t compositeToPresentLatency) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001944 // Integer division and modulo round toward 0 not -inf, so we need to
1945 // treat negative and positive offsets differently.
Ana Krulec757f63a2019-01-25 10:46:18 -08001946 nsecs_t idealLatency = (mPhaseOffsets->getCurrentSfOffset() > 0)
1947 ? (stats.vsyncPeriod - (mPhaseOffsets->getCurrentSfOffset() % stats.vsyncPeriod))
1948 : ((-mPhaseOffsets->getCurrentSfOffset()) % stats.vsyncPeriod);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001949
Ana Krulec757f63a2019-01-25 10:46:18 -08001950 // Just in case mPhaseOffsets->getCurrentSfOffset() == -vsyncInterval.
Brian Andersond0010582017-03-07 13:20:31 -08001951 if (idealLatency <= 0) {
Ana Krulece588e312018-09-18 12:32:24 -07001952 idealLatency = stats.vsyncPeriod;
Brian Andersond0010582017-03-07 13:20:31 -08001953 }
1954
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001955 // Snap the latency to a value that removes scheduling jitter from the
1956 // composition and present times, which often have >1ms of jitter.
1957 // Reducing jitter is important if an app attempts to extrapolate
1958 // something (such as user input) to an accurate diasplay time.
Ana Krulec757f63a2019-01-25 10:46:18 -08001959 // Snapping also allows an app to precisely calculate mPhaseOffsets->getCurrentSfOffset()
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001960 // with (presentLatency % interval).
Ana Krulece588e312018-09-18 12:32:24 -07001961 nsecs_t bias = stats.vsyncPeriod / 2;
1962 int64_t extraVsyncs = (compositeToPresentLatency - idealLatency + bias) / stats.vsyncPeriod;
1963 nsecs_t snappedCompositeToPresentLatency =
1964 (extraVsyncs > 0) ? idealLatency + (extraVsyncs * stats.vsyncPeriod) : idealLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001965
David Sodman99974d22017-11-28 12:04:33 -08001966 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
Ana Krulece588e312018-09-18 12:32:24 -07001967 getBE().mCompositorTiming.deadline = stats.vsyncTime - idealLatency;
1968 getBE().mCompositorTiming.interval = stats.vsyncPeriod;
David Sodman99974d22017-11-28 12:04:33 -08001969 getBE().mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001970}
1971
David Sodman2b406362017-12-15 13:33:47 -08001972void SurfaceFlinger::postComposition()
Mathias Agopiancd60f992012-08-16 16:28:27 -07001973{
Dan Stoza9e56aa02015-11-02 13:00:03 -08001974 ATRACE_CALL();
1975 ALOGV("postComposition");
1976
Brian Anderson3546a3f2016-07-14 11:51:14 -07001977 // Release any buffers which were replaced this frame
Brian Andersonf6386862016-10-31 16:34:13 -07001978 nsecs_t dequeueReadyTime = systemTime();
Brian Anderson3546a3f2016-07-14 11:51:14 -07001979 for (auto& layer : mLayersWithQueuedFrames) {
Brian Andersonf6386862016-10-31 16:34:13 -07001980 layer->releasePendingBuffer(dequeueReadyTime);
Brian Anderson3546a3f2016-07-14 11:51:14 -07001981 }
1982
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001983 // |mStateLock| not needed as we are on the main thread
Lloyd Pique32cbe282018-10-19 13:09:22 -07001984 const auto displayDevice = getDefaultDisplayDeviceLocked();
Brian Anderson3d4039d2016-09-23 16:31:30 -07001985
David Sodman73beded2017-11-15 11:56:06 -08001986 getBE().mGlCompositionDoneTimeline.updateSignalTimes();
Brian Anderson3d4039d2016-09-23 16:31:30 -07001987 std::shared_ptr<FenceTime> glCompositionDoneFenceTime;
Lloyd Pique32cbe282018-10-19 13:09:22 -07001988 if (displayDevice && getHwComposer().hasClientComposition(displayDevice->getId())) {
Brian Anderson3d4039d2016-09-23 16:31:30 -07001989 glCompositionDoneFenceTime =
Lloyd Pique31cb2942018-10-19 17:23:03 -07001990 std::make_shared<FenceTime>(displayDevice->getCompositionDisplay()
1991 ->getRenderSurface()
1992 ->getClientTargetAcquireFence());
David Sodman73beded2017-11-15 11:56:06 -08001993 getBE().mGlCompositionDoneTimeline.push(glCompositionDoneFenceTime);
Brian Anderson3d4039d2016-09-23 16:31:30 -07001994 } else {
1995 glCompositionDoneFenceTime = FenceTime::NO_FENCE;
1996 }
Brian Anderson3d4039d2016-09-23 16:31:30 -07001997
David Sodman73beded2017-11-15 11:56:06 -08001998 getBE().mDisplayTimeline.updateSignalTimes();
Ady Abrahambe0f9482019-04-24 15:41:53 -07001999 mPreviousPresentFences[1] = mPreviousPresentFences[0];
2000 mPreviousPresentFences[0] = displayDevice
2001 ? getHwComposer().getPresentFence(*displayDevice->getId())
2002 : Fence::NO_FENCE;
2003 auto presentFenceTime = std::make_shared<FenceTime>(mPreviousPresentFences[0]);
David Sodman73beded2017-11-15 11:56:06 -08002004 getBE().mDisplayTimeline.push(presentFenceTime);
Brian Anderson3d4039d2016-09-23 16:31:30 -07002005
Ana Krulece588e312018-09-18 12:32:24 -07002006 DisplayStatInfo stats;
Ana Krulecc2870422019-01-29 19:00:58 -08002007 mScheduler->getDisplayStatInfo(&stats);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002008
David Sodman2b406362017-12-15 13:33:47 -08002009 // We use the mRefreshStartTime which might be sampled a little later than
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002010 // when we started doing work for this frame, but that should be okay
2011 // since updateCompositorTiming has snapping logic.
Ana Krulece588e312018-09-18 12:32:24 -07002012 updateCompositorTiming(stats, mRefreshStartTime, presentFenceTime);
Brian Andersond0010582017-03-07 13:20:31 -08002013 CompositorTiming compositorTiming;
2014 {
David Sodman99974d22017-11-28 12:04:33 -08002015 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
2016 compositorTiming = getBE().mCompositorTiming;
Brian Andersond0010582017-03-07 13:20:31 -08002017 }
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002018
Robert Carr2047fae2016-11-28 14:09:09 -08002019 mDrawingState.traverseInZOrder([&](Layer* layer) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07002020 bool frameLatched =
2021 layer->onPostComposition(displayDevice->getId(), glCompositionDoneFenceTime,
2022 presentFenceTime, compositorTiming);
Dan Stozae77c7662016-05-13 11:37:28 -07002023 if (frameLatched) {
Robert Carr2047fae2016-11-28 14:09:09 -08002024 recordBufferingStats(layer->getName().string(),
2025 layer->getOccupancyHistory(false));
Dan Stozae77c7662016-05-13 11:37:28 -07002026 }
Robert Carr2047fae2016-11-28 14:09:09 -08002027 });
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002028
Brian Andersonfbc80ae2017-05-26 16:23:54 -07002029 if (presentFenceTime->isValid()) {
Ana Krulecc2870422019-01-29 19:00:58 -08002030 mScheduler->addPresentFence(presentFenceTime);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07002031 }
2032
Fabien Sanglardcbf153b2017-03-10 17:57:12 -08002033 if (!hasSyncFramework) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07002034 if (displayDevice && getHwComposer().isConnected(*displayDevice->getId()) &&
2035 displayDevice->isPoweredOn()) {
Ana Krulecc2870422019-01-29 19:00:58 -08002036 mScheduler->enableHardwareVsync();
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07002037 }
2038 }
2039
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002040 if (mAnimCompositionPending) {
2041 mAnimCompositionPending = false;
2042
Brian Anderson4e606e32017-03-16 15:34:57 -07002043 if (presentFenceTime->isValid()) {
Brian Anderson3d4039d2016-09-23 16:31:30 -07002044 mAnimFrameTracker.setActualPresentFence(
Brian Anderson4e606e32017-03-16 15:34:57 -07002045 std::move(presentFenceTime));
Lloyd Pique32cbe282018-10-19 13:09:22 -07002046 } else if (displayDevice && getHwComposer().isConnected(*displayDevice->getId())) {
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002047 // The HWC doesn't support present fences, so use the refresh
2048 // timestamp instead.
Lloyd Pique32cbe282018-10-19 13:09:22 -07002049 const nsecs_t presentTime =
2050 getHwComposer().getRefreshTimestamp(*displayDevice->getId());
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002051 mAnimFrameTracker.setActualPresentTime(presentTime);
2052 }
2053 mAnimFrameTracker.advanceFrame();
2054 }
Dan Stozab90cf072015-03-05 11:05:59 -08002055
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002056 mTimeStats->incrementTotalFrames();
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07002057 if (mHadClientComposition) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002058 mTimeStats->incrementClientCompositionFrames();
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07002059 }
2060
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002061 mTimeStats->setPresentFenceGlobal(presentFenceTime);
Yiwei Zhangce6ebc02018-10-20 12:42:38 -07002062
Lloyd Pique32cbe282018-10-19 13:09:22 -07002063 if (displayDevice && getHwComposer().isConnected(*displayDevice->getId()) &&
2064 !displayDevice->isPoweredOn()) {
Dan Stozab90cf072015-03-05 11:05:59 -08002065 return;
2066 }
2067
2068 nsecs_t currentTime = systemTime();
2069 if (mHasPoweredOff) {
2070 mHasPoweredOff = false;
2071 } else {
David Sodman4a36e932017-11-07 14:29:47 -08002072 nsecs_t elapsedTime = currentTime - getBE().mLastSwapTime;
Ana Krulece588e312018-09-18 12:32:24 -07002073 size_t numPeriods = static_cast<size_t>(elapsedTime / stats.vsyncPeriod);
David Sodman4a36e932017-11-07 14:29:47 -08002074 if (numPeriods < SurfaceFlingerBE::NUM_BUCKETS - 1) {
2075 getBE().mFrameBuckets[numPeriods] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002076 } else {
David Sodman4a36e932017-11-07 14:29:47 -08002077 getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002078 }
David Sodman4a36e932017-11-07 14:29:47 -08002079 getBE().mTotalTime += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002080 }
David Sodman4a36e932017-11-07 14:29:47 -08002081 getBE().mLastSwapTime = currentTime;
Dan Stoza436ccf32018-06-21 12:10:12 -07002082
2083 {
2084 std::lock_guard lock(mTexturePoolMutex);
2085 const size_t refillCount = mTexturePoolSize - mTexturePool.size();
2086 if (refillCount > 0) {
2087 const size_t offset = mTexturePool.size();
2088 mTexturePool.resize(mTexturePoolSize);
2089 getRenderEngine().genTextures(refillCount, mTexturePool.data() + offset);
2090 ATRACE_INT("TexturePoolSize", mTexturePool.size());
2091 }
2092 }
Marissa Walle2ffb422018-10-12 11:33:52 -07002093
Ady Abrahambe0f9482019-04-24 15:41:53 -07002094 mTransactionCompletedThread.addPresentFence(mPreviousPresentFences[0]);
Marissa Walle2ffb422018-10-12 11:33:52 -07002095 mTransactionCompletedThread.sendCallbacks();
Ady Abraham8164d482019-01-11 14:47:59 -08002096
Kevin DuBois413287f2019-02-25 08:46:47 -08002097 if (mLumaSampling && mRegionSamplingThread) {
2098 mRegionSamplingThread->notifyNewContent();
Dan Stozaec460082018-12-17 15:35:09 -08002099 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07002100}
2101
Vishnu Nair4351ad52019-02-11 14:13:02 -08002102void SurfaceFlinger::computeLayerBounds() {
2103 for (const auto& pair : mDisplays) {
2104 const auto& displayDevice = pair.second;
2105 const auto display = displayDevice->getCompositionDisplay();
2106 for (const auto& layer : mDrawingState.layersSortedByZ) {
2107 // only consider the layers on the given layer stack
2108 if (!display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
Vishnu Nair01ace762019-02-12 14:25:24 -08002109 continue;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002110 }
2111
2112 layer->computeBounds(displayDevice->getViewport().toFloatRect(), ui::Transform());
2113 }
2114 }
2115}
2116
Mathias Agopiancd60f992012-08-16 16:28:27 -07002117void SurfaceFlinger::rebuildLayerStacks() {
Dan Stoza9e56aa02015-11-02 13:00:03 -08002118 ATRACE_CALL();
2119 ALOGV("rebuildLayerStacks");
2120
Mathias Agopiancd60f992012-08-16 16:28:27 -07002121 // rebuild the visible layer list per screen
Jeff Sharkey76488112017-02-27 14:15:18 -07002122 if (CC_UNLIKELY(mVisibleRegionsDirty)) {
Siarhei Vishniakoufc2589e2017-09-21 15:35:13 -07002123 ATRACE_NAME("rebuildLayerStacks VR Dirty");
Jeff Sharkey76488112017-02-27 14:15:18 -07002124 mVisibleRegionsDirty = false;
2125 invalidateHwcGeometry();
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002126
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002127 for (const auto& pair : mDisplays) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07002128 const auto& displayDevice = pair.second;
2129 auto display = displayDevice->getCompositionDisplay();
2130 const auto& displayState = display->getState();
Jeff Sharkey76488112017-02-27 14:15:18 -07002131 Region opaqueRegion;
2132 Region dirtyRegion;
Lloyd Piquecc01a452018-12-04 17:24:00 -08002133 compositionengine::Output::OutputLayers layersSortedByZ;
2134 Vector<sp<Layer>> deprecated_layersSortedByZ;
Chia-I Wu83806892017-11-16 10:50:20 -08002135 Vector<sp<Layer>> layersNeedingFences;
Lloyd Pique32cbe282018-10-19 13:09:22 -07002136 const ui::Transform& tr = displayState.transform;
2137 const Rect bounds = displayState.bounds;
2138 if (displayState.isEnabled) {
2139 computeVisibleRegions(displayDevice, dirtyRegion, opaqueRegion);
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002140
Jeff Sharkey76488112017-02-27 14:15:18 -07002141 mDrawingState.traverseInZOrder([&](Layer* layer) {
Lloyd Piquecc01a452018-12-04 17:24:00 -08002142 auto compositionLayer = layer->getCompositionLayer();
2143 if (compositionLayer == nullptr) {
2144 return;
2145 }
2146
Lloyd Pique32cbe282018-10-19 13:09:22 -07002147 const auto displayId = displayDevice->getId();
Lloyd Piquecc01a452018-12-04 17:24:00 -08002148 sp<compositionengine::LayerFE> layerFE = compositionLayer->getLayerFE();
2149 LOG_ALWAYS_FATAL_IF(layerFE.get() == nullptr);
2150
Lloyd Pique07e33212018-12-18 16:33:37 -08002151 bool needsOutputLayer = false;
2152
Lloyd Piqueef36b002019-01-23 17:52:04 -08002153 if (display->belongsInOutput(layer->getLayerStack(),
2154 layer->getPrimaryDisplayOnly())) {
Jeff Sharkey76488112017-02-27 14:15:18 -07002155 Region drawRegion(tr.transform(
2156 layer->visibleNonTransparentRegion));
2157 drawRegion.andSelf(bounds);
2158 if (!drawRegion.isEmpty()) {
Lloyd Pique07e33212018-12-18 16:33:37 -08002159 needsOutputLayer = true;
Jeff Sharkey76488112017-02-27 14:15:18 -07002160 }
Chia-I Wu83806892017-11-16 10:50:20 -08002161 }
2162
Lloyd Pique07e33212018-12-18 16:33:37 -08002163 if (needsOutputLayer) {
2164 layersSortedByZ.emplace_back(
2165 display->getOrCreateOutputLayer(displayId, compositionLayer,
2166 layerFE));
2167 deprecated_layersSortedByZ.add(layer);
2168
2169 auto& outputLayerState = layersSortedByZ.back()->editState();
2170 outputLayerState.visibleRegion =
2171 tr.transform(layer->visibleRegion.intersect(displayState.viewport));
2172 } else if (displayId) {
2173 // For layers that are being removed from a HWC display,
2174 // and that have queued frames, add them to a a list of
2175 // released layers so we can properly set a fence.
2176 bool hasExistingOutputLayer =
2177 display->getOutputLayerForLayer(compositionLayer.get()) != nullptr;
2178 bool hasQueuedFrames = std::find(mLayersWithQueuedFrames.cbegin(),
2179 mLayersWithQueuedFrames.cend(),
2180 layer) != mLayersWithQueuedFrames.cend();
2181
2182 if (hasExistingOutputLayer && hasQueuedFrames) {
Chia-I Wu83806892017-11-16 10:50:20 -08002183 layersNeedingFences.add(layer);
2184 }
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002185 }
Jeff Sharkey76488112017-02-27 14:15:18 -07002186 });
2187 }
Lloyd Piquecc01a452018-12-04 17:24:00 -08002188
2189 display->setOutputLayersOrderedByZ(std::move(layersSortedByZ));
2190
2191 displayDevice->setVisibleLayersSortedByZ(deprecated_layersSortedByZ);
Lloyd Pique32cbe282018-10-19 13:09:22 -07002192 displayDevice->setLayersNeedingFences(layersNeedingFences);
2193
2194 Region undefinedRegion{bounds};
2195 undefinedRegion.subtractSelf(tr.transform(opaqueRegion));
2196
2197 display->editState().undefinedRegion = undefinedRegion;
2198 display->editState().dirtyRegion.orSelf(dirtyRegion);
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002199 }
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002200 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07002201}
Mathias Agopian3b1d2b62012-07-11 13:48:17 -07002202
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002203// Returns a data space that fits all visible layers. The returned data space
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002204// can only be one of
Chia-I Wu7a28ecb2018-05-04 10:38:39 -07002205// - Dataspace::SRGB (use legacy dataspace and let HWC saturate when colors are enhanced)
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002206// - Dataspace::DISPLAY_P3
Valerie Hau9758ae02018-10-09 16:05:09 -07002207// - Dataspace::DISPLAY_BT2020
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002208// The returned HDR data space is one of
2209// - Dataspace::UNKNOWN
2210// - Dataspace::BT2020_HLG
2211// - Dataspace::BT2020_PQ
Peiyong Lin03912882019-04-16 15:34:46 -07002212Dataspace SurfaceFlinger::getBestDataspace(const sp<DisplayDevice>& display,
2213 Dataspace* outHdrDataSpace,
2214 bool* outIsHdrClientComposition) const {
Peiyong Lin14724e62018-12-05 07:27:30 -08002215 Dataspace bestDataSpace = Dataspace::V0_SRGB;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002216 *outHdrDataSpace = Dataspace::UNKNOWN;
2217
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002218 for (const auto& layer : display->getVisibleLayersSortedByZ()) {
Chia-I Wu01591c92018-05-22 12:03:00 -07002219 switch (layer->getDataSpace()) {
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002220 case Dataspace::V0_SCRGB:
2221 case Dataspace::V0_SCRGB_LINEAR:
Valerie Hau9758ae02018-10-09 16:05:09 -07002222 case Dataspace::BT2020:
2223 case Dataspace::BT2020_ITU:
2224 case Dataspace::BT2020_LINEAR:
2225 case Dataspace::DISPLAY_BT2020:
2226 bestDataSpace = Dataspace::DISPLAY_BT2020;
2227 break;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002228 case Dataspace::DISPLAY_P3:
Chia-I Wube02ec02018-05-18 10:59:36 -07002229 bestDataSpace = Dataspace::DISPLAY_P3;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002230 break;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002231 case Dataspace::BT2020_PQ:
2232 case Dataspace::BT2020_ITU_PQ:
Peiyong Linf6eb7662019-02-05 15:39:15 -08002233 bestDataSpace = Dataspace::DISPLAY_P3;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002234 *outHdrDataSpace = Dataspace::BT2020_PQ;
Peiyong Lin03912882019-04-16 15:34:46 -07002235 *outIsHdrClientComposition = layer->getForceClientComposition(display);
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002236 break;
Peiyong Linf59a7192018-04-25 11:19:31 -07002237 case Dataspace::BT2020_HLG:
2238 case Dataspace::BT2020_ITU_HLG:
Peiyong Linf6eb7662019-02-05 15:39:15 -08002239 bestDataSpace = Dataspace::DISPLAY_P3;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002240 // When there's mixed PQ content and HLG content, we set the HDR
2241 // data space to be BT2020_PQ and convert HLG to PQ.
2242 if (*outHdrDataSpace == Dataspace::UNKNOWN) {
2243 *outHdrDataSpace = Dataspace::BT2020_HLG;
Peiyong Linf59a7192018-04-25 11:19:31 -07002244 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002245 break;
2246 default:
2247 break;
2248 }
Romain Guy54f154a2017-10-24 21:40:32 +01002249 }
2250
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002251 return bestDataSpace;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06002252}
2253
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002254// Pick the ColorMode / Dataspace for the display device.
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002255void SurfaceFlinger::pickColorMode(const sp<DisplayDevice>& display, ColorMode* outMode,
2256 Dataspace* outDataSpace, RenderIntent* outRenderIntent) const {
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002257 if (mDisplayColorSetting == DisplayColorSetting::UNMANAGED) {
2258 *outMode = ColorMode::NATIVE;
2259 *outDataSpace = Dataspace::UNKNOWN;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002260 *outRenderIntent = RenderIntent::COLORIMETRIC;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002261 return;
Chia-I Wu5c6e4632018-01-11 08:54:38 -08002262 }
Romain Guy88d37dd2017-05-26 17:57:05 -07002263
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002264 Dataspace hdrDataSpace;
Peiyong Lin03912882019-04-16 15:34:46 -07002265 bool isHdrClientComposition = false;
2266 Dataspace bestDataSpace = getBestDataspace(display, &hdrDataSpace, &isHdrClientComposition);
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002267
Lloyd Pique3d0c02e2018-10-19 18:38:12 -07002268 auto* profile = display->getCompositionDisplay()->getDisplayColorProfile();
2269
Peiyong Lina3ea5592019-02-10 14:45:00 -08002270 switch (mForceColorMode) {
2271 case ColorMode::SRGB:
2272 bestDataSpace = Dataspace::V0_SRGB;
2273 break;
2274 case ColorMode::DISPLAY_P3:
2275 bestDataSpace = Dataspace::DISPLAY_P3;
2276 break;
2277 default:
2278 break;
2279 }
2280
Peiyong Lindfde5112018-06-05 10:58:41 -07002281 // respect hdrDataSpace only when there is no legacy HDR support
Peiyong Lin03912882019-04-16 15:34:46 -07002282 const bool isHdr = hdrDataSpace != Dataspace::UNKNOWN &&
2283 !profile->hasLegacyHdrSupport(hdrDataSpace) && !isHdrClientComposition;
Chia-I Wuc4b08bd2018-05-29 12:57:23 -07002284 if (isHdr) {
2285 bestDataSpace = hdrDataSpace;
2286 }
2287
Chia-I Wu0d711262018-05-21 15:19:35 -07002288 RenderIntent intent;
2289 switch (mDisplayColorSetting) {
2290 case DisplayColorSetting::MANAGED:
2291 case DisplayColorSetting::UNMANAGED:
Chia-I Wuc4b08bd2018-05-29 12:57:23 -07002292 intent = isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC;
Chia-I Wu0d711262018-05-21 15:19:35 -07002293 break;
2294 case DisplayColorSetting::ENHANCED:
Chia-I Wuc4b08bd2018-05-29 12:57:23 -07002295 intent = isHdr ? RenderIntent::TONE_MAP_ENHANCE : RenderIntent::ENHANCE;
Chia-I Wu0d711262018-05-21 15:19:35 -07002296 break;
2297 default: // vendor display color setting
2298 intent = static_cast<RenderIntent>(mDisplayColorSetting);
2299 break;
2300 }
Chia-I Wube02ec02018-05-18 10:59:36 -07002301
Lloyd Pique3d0c02e2018-10-19 18:38:12 -07002302 profile->getBestColorMode(bestDataSpace, intent, outDataSpace, outMode, outRenderIntent);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06002303}
2304
Lloyd Pique32cbe282018-10-19 13:09:22 -07002305void SurfaceFlinger::beginFrame(const sp<DisplayDevice>& displayDevice) {
2306 auto display = displayDevice->getCompositionDisplay();
2307 const auto& displayState = display->getState();
2308
Alec Mourie7d1d4a2019-02-05 01:13:46 +00002309 bool dirty = !display->getDirtyRegion(false).isEmpty();
Lloyd Pique32cbe282018-10-19 13:09:22 -07002310 bool empty = displayDevice->getVisibleLayersSortedByZ().size() == 0;
2311 bool wasEmpty = !displayState.lastCompositionHadVisibleLayers;
David Sodman2b406362017-12-15 13:33:47 -08002312
David Sodmanfa9b2af2017-12-24 13:28:59 -08002313 // If nothing has changed (!dirty), don't recompose.
2314 // If something changed, but we don't currently have any visible layers,
2315 // and didn't when we last did a composition, then skip it this time.
2316 // The second rule does two things:
2317 // - When all layers are removed from a display, we'll emit one black
2318 // frame, then nothing more until we get new layers.
2319 // - When a display is created with a private layer stack, we won't
2320 // emit any black frames until a layer is added to the layer stack.
2321 bool mustRecompose = dirty && !(empty && wasEmpty);
David Sodman2b406362017-12-15 13:33:47 -08002322
Dominik Laskowski075d3172018-05-24 15:50:06 -07002323 const char flagPrefix[] = {'-', '+'};
2324 static_cast<void>(flagPrefix);
Lloyd Pique32cbe282018-10-19 13:09:22 -07002325 ALOGV_IF(displayDevice->isVirtual(), "%s: %s composition for %s (%cdirty %cempty %cwasEmpty)",
2326 __FUNCTION__, mustRecompose ? "doing" : "skipping",
2327 displayDevice->getDebugName().c_str(), flagPrefix[dirty], flagPrefix[empty],
2328 flagPrefix[wasEmpty]);
David Sodman2b406362017-12-15 13:33:47 -08002329
Lloyd Pique31cb2942018-10-19 17:23:03 -07002330 display->getRenderSurface()->beginFrame(mustRecompose);
David Sodman2b406362017-12-15 13:33:47 -08002331
David Sodmanfa9b2af2017-12-24 13:28:59 -08002332 if (mustRecompose) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07002333 display->editState().lastCompositionHadVisibleLayers = !empty;
David Sodman2b406362017-12-15 13:33:47 -08002334 }
2335}
2336
Lloyd Pique32cbe282018-10-19 13:09:22 -07002337void SurfaceFlinger::prepareFrame(const sp<DisplayDevice>& displayDevice) {
2338 auto display = displayDevice->getCompositionDisplay();
2339 const auto& displayState = display->getState();
2340
2341 if (!displayState.isEnabled) {
David Sodmanfa9b2af2017-12-24 13:28:59 -08002342 return;
David Sodman2b406362017-12-15 13:33:47 -08002343 }
David Sodmanfa9b2af2017-12-24 13:28:59 -08002344
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08002345 status_t result = display->getRenderSurface()->prepareFrame();
Dominik Laskowski075d3172018-05-24 15:50:06 -07002346 ALOGE_IF(result != NO_ERROR, "prepareFrame failed for %s: %d (%s)",
Lloyd Pique32cbe282018-10-19 13:09:22 -07002347 displayDevice->getDebugName().c_str(), result, strerror(-result));
David Sodman2b406362017-12-15 13:33:47 -08002348}
Mathias Agopian52bbb1a2012-07-31 19:01:53 -07002349
Lloyd Pique32cbe282018-10-19 13:09:22 -07002350void SurfaceFlinger::doComposition(const sp<DisplayDevice>& displayDevice, bool repaintEverything) {
Mathias Agopiancd60f992012-08-16 16:28:27 -07002351 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08002352 ALOGV("doComposition");
2353
Lloyd Pique32cbe282018-10-19 13:09:22 -07002354 auto display = displayDevice->getCompositionDisplay();
2355 const auto& displayState = display->getState();
2356
2357 if (displayState.isEnabled) {
David Sodmanfa9b2af2017-12-24 13:28:59 -08002358 // transform the dirty region into this screen's coordinate space
Alec Mourie7d1d4a2019-02-05 01:13:46 +00002359 const Region dirtyRegion = display->getDirtyRegion(repaintEverything);
Mathias Agopian02b95102012-11-05 17:50:57 -08002360
David Sodmanfa9b2af2017-12-24 13:28:59 -08002361 // repaint the framebuffer (if needed)
Lloyd Pique32cbe282018-10-19 13:09:22 -07002362 doDisplayComposition(displayDevice, dirtyRegion);
Mathias Agopian02b95102012-11-05 17:50:57 -08002363
Lloyd Pique32cbe282018-10-19 13:09:22 -07002364 display->editState().dirtyRegion.clear();
Lloyd Pique31cb2942018-10-19 17:23:03 -07002365 display->getRenderSurface()->flip();
Mathias Agopian4fec8732012-06-29 14:12:52 -07002366 }
Lloyd Pique32cbe282018-10-19 13:09:22 -07002367 postFramebuffer(displayDevice);
Mathias Agopian4fec8732012-06-29 14:12:52 -07002368}
2369
David Sodmanfa9b2af2017-12-24 13:28:59 -08002370void SurfaceFlinger::postFrame()
2371{
2372 // |mStateLock| not needed as we are on the main thread
Dominik Laskowski075d3172018-05-24 15:50:06 -07002373 const auto display = getDefaultDisplayDeviceLocked();
2374 if (display && getHwComposer().isConnected(*display->getId())) {
2375 uint32_t flipCount = display->getPageFlipCount();
David Sodmanfa9b2af2017-12-24 13:28:59 -08002376 if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
2377 logFrameStats();
2378 }
2379 }
2380}
2381
Lloyd Pique32cbe282018-10-19 13:09:22 -07002382void SurfaceFlinger::postFramebuffer(const sp<DisplayDevice>& displayDevice) {
Mathias Agopian841cde52012-03-01 15:44:37 -08002383 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08002384 ALOGV("postFramebuffer");
Mathias Agopianb048cef2012-02-04 15:44:04 -08002385
Lloyd Pique32cbe282018-10-19 13:09:22 -07002386 auto display = displayDevice->getCompositionDisplay();
2387 const auto& displayState = display->getState();
2388 const auto displayId = display->getId();
2389
Lloyd Pique32cbe282018-10-19 13:09:22 -07002390 if (displayState.isEnabled) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002391 if (displayId) {
2392 getHwComposer().presentAndGetReleaseFences(*displayId);
Mathias Agopian2a231842012-09-24 18:12:35 -07002393 }
Lloyd Pique31cb2942018-10-19 17:23:03 -07002394 display->getRenderSurface()->onPresentDisplayCompleted();
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002395 for (auto& layer : display->getOutputLayersOrderedByZ()) {
Chia-I Wu0f509fb2018-06-21 15:52:50 +08002396 sp<Fence> releaseFence = Fence::NO_FENCE;
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002397 bool usedClientComposition = true;
David Sodman15094112018-10-11 09:39:37 -07002398
Chia-I Wu7b549592017-11-15 09:14:57 -08002399 // The layer buffer from the previous frame (if any) is released
2400 // by HWC only when the release fence from this frame (if any) is
2401 // signaled. Always get the release fence from HWC first.
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002402 if (layer->getState().hwc) {
2403 const auto& hwcState = *layer->getState().hwc;
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08002404 releaseFence =
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002405 getHwComposer().getLayerReleaseFence(*displayId, hwcState.hwcLayer.get());
2406 usedClientComposition =
2407 hwcState.hwcCompositionType == Hwc2::IComposerClient::Composition::CLIENT;
Chia-I Wu0f509fb2018-06-21 15:52:50 +08002408 }
Chia-I Wu7b549592017-11-15 09:14:57 -08002409
2410 // If the layer was client composited in the previous frame, we
2411 // need to merge with the previous client target acquire fence.
2412 // Since we do not track that, always merge with the current
2413 // client target acquire fence when it is available, even though
2414 // this is suboptimal.
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002415 if (usedClientComposition) {
Lloyd Pique31cb2942018-10-19 17:23:03 -07002416 releaseFence =
2417 Fence::merge("LayerRelease", releaseFence,
2418 display->getRenderSurface()->getClientTargetAcquireFence());
Mathias Agopian52bbb1a2012-07-31 19:01:53 -07002419 }
Chia-I Wu7b549592017-11-15 09:14:57 -08002420
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002421 layer->getLayerFE().onLayerDisplayed(releaseFence);
Dan Stoza9e56aa02015-11-02 13:00:03 -08002422 }
Chia-I Wu83806892017-11-16 10:50:20 -08002423
2424 // We've got a list of layers needing fences, that are disjoint with
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002425 // display->getVisibleLayersSortedByZ. The best we can do is to
Chia-I Wu83806892017-11-16 10:50:20 -08002426 // supply them with the present fence.
Lloyd Pique32cbe282018-10-19 13:09:22 -07002427 if (!displayDevice->getLayersNeedingFences().isEmpty()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002428 sp<Fence> presentFence =
Lloyd Pique441d5042018-10-18 16:49:51 -07002429 displayId ? getHwComposer().getPresentFence(*displayId) : Fence::NO_FENCE;
Lloyd Pique32cbe282018-10-19 13:09:22 -07002430 for (auto& layer : displayDevice->getLayersNeedingFences()) {
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002431 layer->getCompositionLayer()->getLayerFE()->onLayerDisplayed(presentFence);
Chia-I Wu83806892017-11-16 10:50:20 -08002432 }
2433 }
2434
Dominik Laskowski075d3172018-05-24 15:50:06 -07002435 if (displayId) {
2436 getHwComposer().clearReleaseFences(*displayId);
Jesse Hallef194142012-06-14 14:45:17 -07002437 }
Jamie Gennise8696a42012-01-15 18:54:57 -08002438 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002439}
2440
Mathias Agopian87baae12012-07-31 12:38:26 -07002441void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002442{
Mathias Agopian841cde52012-03-01 15:44:37 -08002443 ATRACE_CALL();
2444
Mathias Agopian7cc6df52013-06-05 14:30:54 -07002445 // here we keep a copy of the drawing state (that is the state that's
2446 // going to be overwritten by handleTransactionLocked()) outside of
2447 // mStateLock so that the side-effects of the State assignment
2448 // don't happen with mStateLock held (which can cause deadlocks).
2449 State drawingState(mDrawingState);
2450
Mathias Agopianca4d3602011-05-19 15:38:14 -07002451 Mutex::Autolock _l(mStateLock);
Dominik Laskowski9dab3432019-03-27 13:21:10 -07002452 mDebugInTransaction = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002453
Mathias Agopianca4d3602011-05-19 15:38:14 -07002454 // Here we're guaranteed that some transaction flags are set
2455 // so we can call handleTransactionLocked() unconditionally.
2456 // We call getTransactionFlags(), which will also clear the flags,
2457 // with mStateLock held to guarantee that mCurrentState won't change
2458 // until the transaction is committed.
Mathias Agopian4da75192010-08-10 17:19:56 -07002459
Jorim Jaggif15c3be2018-04-12 12:56:58 +01002460 mVsyncModulator.onTransactionHandled();
Mathias Agopiane57f2922012-08-09 16:29:12 -07002461 transactionFlags = getTransactionFlags(eTransactionMask);
Mathias Agopian87baae12012-07-31 12:38:26 -07002462 handleTransactionLocked(transactionFlags);
Mathias Agopiandea20b12011-05-03 17:04:02 -07002463
Mathias Agopianca4d3602011-05-19 15:38:14 -07002464 mDebugInTransaction = 0;
2465 invalidateHwcGeometry();
2466 // here the transaction has been committed
Mathias Agopian3d579642009-06-04 18:46:21 -07002467}
2468
Lloyd Piqueba04e622017-12-14 17:11:26 -08002469void SurfaceFlinger::processDisplayHotplugEventsLocked() {
2470 for (const auto& event : mPendingHotplugEvents) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002471 const std::optional<DisplayIdentificationInfo> info =
2472 getHwComposer().onHotplug(event.hwcDisplayId, event.connection);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002473
Dominik Laskowski075d3172018-05-24 15:50:06 -07002474 if (!info) {
Lloyd Piqueba04e622017-12-14 17:11:26 -08002475 continue;
2476 }
2477
Lloyd Piqueba04e622017-12-14 17:11:26 -08002478 if (event.connection == HWC2::Connection::Connected) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002479 if (!mPhysicalDisplayTokens.count(info->id)) {
Dominik Laskowski34157762018-10-31 13:07:19 -07002480 ALOGV("Creating display %s", to_string(info->id).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07002481 mPhysicalDisplayTokens[info->id] = new BBinder();
2482 DisplayDeviceState state;
2483 state.displayId = info->id;
2484 state.isSecure = true; // All physical displays are currently considered secure.
2485 state.displayName = info->name;
2486 mCurrentState.displays.add(mPhysicalDisplayTokens[info->id], state);
2487 mInterceptor->saveDisplayCreation(state);
Steven Thomaseb6d2052018-03-20 15:40:48 -07002488 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08002489 } else {
Dominik Laskowski34157762018-10-31 13:07:19 -07002490 ALOGV("Removing display %s", to_string(info->id).c_str());
Lloyd Piqueba04e622017-12-14 17:11:26 -08002491
Dominik Laskowski075d3172018-05-24 15:50:06 -07002492 ssize_t index = mCurrentState.displays.indexOfKey(mPhysicalDisplayTokens[info->id]);
2493 if (index >= 0) {
2494 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
2495 mInterceptor->saveDisplayDeletion(state.sequenceId);
2496 mCurrentState.displays.removeItemsAt(index);
Lloyd Piquefcd86612017-12-14 17:15:36 -08002497 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07002498 mPhysicalDisplayTokens.erase(info->id);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002499 }
2500
2501 processDisplayChangesLocked();
2502 }
2503
2504 mPendingHotplugEvents.clear();
2505}
2506
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002507void SurfaceFlinger::dispatchDisplayHotplugEvent(PhysicalDisplayId displayId, bool connected) {
Ana Krulecc2870422019-01-29 19:00:58 -08002508 mScheduler->hotplugReceived(mAppConnectionHandle, displayId, connected);
2509 mScheduler->hotplugReceived(mSfConnectionHandle, displayId, connected);
Dominik Laskowski1eba0202019-01-24 09:14:40 -08002510}
2511
Lloyd Pique99d3da52018-01-22 17:48:03 -08002512sp<DisplayDevice> SurfaceFlinger::setupNewDisplayDeviceInternal(
Dominik Laskowski075d3172018-05-24 15:50:06 -07002513 const wp<IBinder>& displayToken, const std::optional<DisplayId>& displayId,
Lloyd Pique542307f2018-10-19 13:24:08 -07002514 const DisplayDeviceState& state, const sp<compositionengine::DisplaySurface>& dispSurface,
Dominik Laskowski075d3172018-05-24 15:50:06 -07002515 const sp<IGraphicBufferProducer>& producer) {
2516 DisplayDeviceCreationArgs creationArgs(this, displayToken, displayId);
Dominik Laskowskie9774092018-12-11 10:04:24 -08002517 creationArgs.sequenceId = state.sequenceId;
Dominik Laskowski075d3172018-05-24 15:50:06 -07002518 creationArgs.isVirtual = state.isVirtual();
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002519 creationArgs.isSecure = state.isSecure;
2520 creationArgs.displaySurface = dispSurface;
2521 creationArgs.hasWideColorGamut = false;
2522 creationArgs.supportedPerFrameMetadata = 0;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002523
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002524 const bool isInternalDisplay = displayId && displayId == getInternalDisplayIdLocked();
Dominik Laskowski075d3172018-05-24 15:50:06 -07002525 creationArgs.isPrimary = isInternalDisplay;
2526
2527 if (useColorManagement && displayId) {
2528 std::vector<ColorMode> modes = getHwComposer().getColorModes(*displayId);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002529 for (ColorMode colorMode : modes) {
Peiyong Linfca547f2018-07-09 13:03:33 -07002530 if (isWideColorMode(colorMode)) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002531 creationArgs.hasWideColorGamut = true;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002532 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002533
Dominik Laskowski7e045462018-05-30 13:02:02 -07002534 std::vector<RenderIntent> renderIntents =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002535 getHwComposer().getRenderIntents(*displayId, colorMode);
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002536 creationArgs.hwcColorModes.emplace(colorMode, renderIntents);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002537 }
tangrobin6753a022018-08-10 10:58:54 +08002538 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002539
Dominik Laskowski075d3172018-05-24 15:50:06 -07002540 if (displayId) {
2541 getHwComposer().getHdrCapabilities(*displayId, &creationArgs.hdrCapabilities);
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002542 creationArgs.supportedPerFrameMetadata =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002543 getHwComposer().getSupportedPerFrameMetadata(*displayId);
Chia-I Wu0f509fb2018-06-21 15:52:50 +08002544 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002545
Lloyd Pique90c115d2018-09-18 21:39:42 -07002546 auto nativeWindowSurface = getFactory().createNativeWindowSurface(producer);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002547 auto nativeWindow = nativeWindowSurface->getNativeWindow();
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002548 creationArgs.nativeWindow = nativeWindow;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002549
Lloyd Pique99d3da52018-01-22 17:48:03 -08002550 // Make sure that composition can never be stalled by a virtual display
2551 // consumer that isn't processing buffers fast enough. We have to do this
Alec Mouri0a9c7b82018-11-16 13:05:25 -08002552 // here, in case the display is composed entirely by HWC.
Dominik Laskowski281644e2018-04-19 15:47:35 -07002553 if (state.isVirtual()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002554 nativeWindow->setSwapInterval(nativeWindow.get(), 0);
2555 }
2556
Dominik Laskowski075d3172018-05-24 15:50:06 -07002557 creationArgs.displayInstallOrientation =
2558 isInternalDisplay ? primaryDisplayOrientation : DisplayState::eOrientationDefault;
Chia-I Wua02871c2018-08-27 14:38:23 -07002559
Lloyd Pique99d3da52018-01-22 17:48:03 -08002560 // virtual displays are always considered enabled
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002561 creationArgs.initialPowerMode = state.isVirtual() ? HWC_POWER_MODE_NORMAL : HWC_POWER_MODE_OFF;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002562
Lloyd Pique90c115d2018-09-18 21:39:42 -07002563 sp<DisplayDevice> display = getFactory().createDisplayDevice(std::move(creationArgs));
Lloyd Pique99d3da52018-01-22 17:48:03 -08002564
2565 if (maxFrameBufferAcquiredBuffers >= 3) {
2566 nativeWindowSurface->preallocateBuffers();
2567 }
2568
2569 ColorMode defaultColorMode = ColorMode::NATIVE;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002570 Dataspace defaultDataSpace = Dataspace::UNKNOWN;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002571 if (display->hasWideColorGamut()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002572 defaultColorMode = ColorMode::SRGB;
Peiyong Lin14724e62018-12-05 07:27:30 -08002573 defaultDataSpace = Dataspace::V0_SRGB;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002574 }
Lloyd Pique32cbe282018-10-19 13:09:22 -07002575 display->getCompositionDisplay()->setColorMode(defaultColorMode, defaultDataSpace,
2576 RenderIntent::COLORIMETRIC);
Dominik Laskowski075d3172018-05-24 15:50:06 -07002577 if (!state.isVirtual()) {
2578 LOG_ALWAYS_FATAL_IF(!displayId);
2579 display->setActiveConfig(getHwComposer().getActiveConfigIndex(*displayId));
Lloyd Pique3c085a02018-05-09 19:38:32 -07002580 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07002581
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002582 display->setLayerStack(state.layerStack);
2583 display->setProjection(state.orientation, state.viewport, state.frame);
2584 display->setDisplayName(state.displayName);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002585
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002586 return display;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002587}
2588
Lloyd Pique347200f2017-12-14 17:00:15 -08002589void SurfaceFlinger::processDisplayChangesLocked() {
2590 // here we take advantage of Vector's copy-on-write semantics to
2591 // improve performance by skipping the transaction entirely when
2592 // know that the lists are identical
2593 const KeyedVector<wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
2594 const KeyedVector<wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
2595 if (!curr.isIdenticalTo(draw)) {
2596 mVisibleRegionsDirty = true;
2597 const size_t cc = curr.size();
2598 size_t dc = draw.size();
2599
2600 // find the displays that were removed
2601 // (ie: in drawing state but not in current state)
2602 // also handle displays that changed
2603 // (ie: displays that are in both lists)
2604 for (size_t i = 0; i < dc;) {
2605 const ssize_t j = curr.indexOfKey(draw.keyAt(i));
2606 if (j < 0) {
2607 // in drawing state but not in current state
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002608 if (const auto display = getDisplayDeviceLocked(draw.keyAt(i))) {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002609 // Save display ID before disconnecting.
2610 const auto displayId = display->getId();
Lloyd Pique45a165a2018-10-19 11:54:47 -07002611 display->disconnect();
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002612
2613 if (!display->isVirtual()) {
2614 LOG_ALWAYS_FATAL_IF(!displayId);
2615 dispatchDisplayHotplugEvent(displayId->value, false);
2616 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002617 }
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002618
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002619 mDisplays.erase(draw.keyAt(i));
Lloyd Pique347200f2017-12-14 17:00:15 -08002620 } else {
2621 // this display is in both lists. see if something changed.
2622 const DisplayDeviceState& state(curr[j]);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002623 const wp<IBinder>& displayToken = curr.keyAt(j);
Lloyd Pique347200f2017-12-14 17:00:15 -08002624 const sp<IBinder> state_binder = IInterface::asBinder(state.surface);
2625 const sp<IBinder> draw_binder = IInterface::asBinder(draw[i].surface);
2626 if (state_binder != draw_binder) {
2627 // changing the surface is like destroying and
2628 // recreating the DisplayDevice, so we just remove it
2629 // from the drawing state, so that it get re-added
2630 // below.
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002631 if (const auto display = getDisplayDeviceLocked(displayToken)) {
Lloyd Pique45a165a2018-10-19 11:54:47 -07002632 display->disconnect();
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002633 }
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002634 mDisplays.erase(displayToken);
Lloyd Pique347200f2017-12-14 17:00:15 -08002635 mDrawingState.displays.removeItemsAt(i);
2636 dc--;
2637 // at this point we must loop to the next item
2638 continue;
2639 }
2640
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002641 if (const auto display = getDisplayDeviceLocked(displayToken)) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002642 if (state.layerStack != draw[i].layerStack) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002643 display->setLayerStack(state.layerStack);
Lloyd Pique347200f2017-12-14 17:00:15 -08002644 }
2645 if ((state.orientation != draw[i].orientation) ||
2646 (state.viewport != draw[i].viewport) || (state.frame != draw[i].frame)) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002647 display->setProjection(state.orientation, state.viewport, state.frame);
Lloyd Pique347200f2017-12-14 17:00:15 -08002648 }
2649 if (state.width != draw[i].width || state.height != draw[i].height) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002650 display->setDisplaySize(state.width, state.height);
Lloyd Pique347200f2017-12-14 17:00:15 -08002651 }
2652 }
2653 }
2654 ++i;
2655 }
2656
2657 // find displays that were added
2658 // (ie: in current state but not in drawing state)
2659 for (size_t i = 0; i < cc; i++) {
2660 if (draw.indexOfKey(curr.keyAt(i)) < 0) {
2661 const DisplayDeviceState& state(curr[i]);
2662
Lloyd Pique542307f2018-10-19 13:24:08 -07002663 sp<compositionengine::DisplaySurface> dispSurface;
Lloyd Pique347200f2017-12-14 17:00:15 -08002664 sp<IGraphicBufferProducer> producer;
2665 sp<IGraphicBufferProducer> bqProducer;
2666 sp<IGraphicBufferConsumer> bqConsumer;
Lloyd Pique90c115d2018-09-18 21:39:42 -07002667 getFactory().createBufferQueue(&bqProducer, &bqConsumer, false);
Lloyd Pique347200f2017-12-14 17:00:15 -08002668
Dominik Laskowski075d3172018-05-24 15:50:06 -07002669 std::optional<DisplayId> displayId;
Dominik Laskowski663bd282018-04-19 15:26:54 -07002670 if (state.isVirtual()) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002671 // Virtual displays without a surface are dormant:
2672 // they have external state (layer stack, projection,
2673 // etc.) but no internal state (i.e. a DisplayDevice).
2674 if (state.surface != nullptr) {
2675 // Allow VR composer to use virtual displays.
Dominik Laskowski075d3172018-05-24 15:50:06 -07002676 if (mUseHwcVirtualDisplays || getHwComposer().isUsingVrComposer()) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002677 int width = 0;
2678 int status = state.surface->query(NATIVE_WINDOW_WIDTH, &width);
2679 ALOGE_IF(status != NO_ERROR, "Unable to query width (%d)", status);
2680 int height = 0;
2681 status = state.surface->query(NATIVE_WINDOW_HEIGHT, &height);
2682 ALOGE_IF(status != NO_ERROR, "Unable to query height (%d)", status);
2683 int intFormat = 0;
2684 status = state.surface->query(NATIVE_WINDOW_FORMAT, &intFormat);
2685 ALOGE_IF(status != NO_ERROR, "Unable to query format (%d)", status);
Peiyong Lin34beb7a2018-03-28 11:57:12 -07002686 auto format = static_cast<ui::PixelFormat>(intFormat);
Lloyd Pique347200f2017-12-14 17:00:15 -08002687
Dominik Laskowski075d3172018-05-24 15:50:06 -07002688 displayId =
2689 getHwComposer().allocateVirtualDisplay(width, height, &format);
Lloyd Pique347200f2017-12-14 17:00:15 -08002690 }
2691
2692 // TODO: Plumb requested format back up to consumer
2693
2694 sp<VirtualDisplaySurface> vds =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002695 new VirtualDisplaySurface(getHwComposer(), displayId, state.surface,
Lloyd Pique347200f2017-12-14 17:00:15 -08002696 bqProducer, bqConsumer,
2697 state.displayName);
2698
2699 dispSurface = vds;
2700 producer = vds;
2701 }
2702 } else {
2703 ALOGE_IF(state.surface != nullptr,
2704 "adding a supported display, but rendering "
2705 "surface is provided (%p), ignoring it",
2706 state.surface.get());
2707
Dominik Laskowski075d3172018-05-24 15:50:06 -07002708 displayId = state.displayId;
2709 LOG_ALWAYS_FATAL_IF(!displayId);
2710 dispSurface = new FramebufferSurface(getHwComposer(), *displayId, bqConsumer);
Lloyd Pique347200f2017-12-14 17:00:15 -08002711 producer = bqProducer;
2712 }
2713
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002714 const wp<IBinder>& displayToken = curr.keyAt(i);
Lloyd Pique347200f2017-12-14 17:00:15 -08002715 if (dispSurface != nullptr) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002716 mDisplays.emplace(displayToken,
Dominik Laskowski7e045462018-05-30 13:02:02 -07002717 setupNewDisplayDeviceInternal(displayToken, displayId, state,
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002718 dispSurface, producer));
Dominik Laskowski663bd282018-04-19 15:26:54 -07002719 if (!state.isVirtual()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002720 LOG_ALWAYS_FATAL_IF(!displayId);
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002721 dispatchDisplayHotplugEvent(displayId->value, true);
Lloyd Pique347200f2017-12-14 17:00:15 -08002722 }
2723 }
2724 }
2725 }
2726 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08002727
2728 mDrawingState.displays = mCurrentState.displays;
Lloyd Pique347200f2017-12-14 17:00:15 -08002729}
2730
Mathias Agopian87baae12012-07-31 12:38:26 -07002731void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
Mathias Agopian3d579642009-06-04 18:46:21 -07002732{
Dan Stoza7dde5992015-05-22 09:51:44 -07002733 // Notify all layers of available frames
Robert Carr2047fae2016-11-28 14:09:09 -08002734 mCurrentState.traverseInZOrder([](Layer* layer) {
2735 layer->notifyAvailableFrames();
2736 });
Dan Stoza7dde5992015-05-22 09:51:44 -07002737
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002738 /*
2739 * Traversal of the children
2740 * (perform the transaction for each of them if needed)
2741 */
2742
Marissa Wall06255332019-03-27 13:48:27 -07002743 if ((transactionFlags & eTraversalNeeded) || mTraversalNeededMainThread) {
Robert Carr2047fae2016-11-28 14:09:09 -08002744 mCurrentState.traverseInZOrder([&](Layer* layer) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002745 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
Robert Carr2047fae2016-11-28 14:09:09 -08002746 if (!trFlags) return;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002747
2748 const uint32_t flags = layer->doTransaction(0);
2749 if (flags & Layer::eVisibleRegion)
2750 mVisibleRegionsDirty = true;
Robert Carr720e5062018-07-30 17:45:14 -07002751
2752 if (flags & Layer::eInputInfoChanged) {
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002753 mInputInfoChanged = true;
Robert Carr720e5062018-07-30 17:45:14 -07002754 }
Robert Carr2047fae2016-11-28 14:09:09 -08002755 });
Marissa Wall06255332019-03-27 13:48:27 -07002756 mTraversalNeededMainThread = false;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002757 }
2758
2759 /*
Mathias Agopian3559b072012-08-15 13:46:03 -07002760 * Perform display own transactions if needed
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002761 */
2762
Mathias Agopiane57f2922012-08-09 16:29:12 -07002763 if (transactionFlags & eDisplayTransactionNeeded) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002764 processDisplayChangesLocked();
Lloyd Piqueba04e622017-12-14 17:11:26 -08002765 processDisplayHotplugEventsLocked();
Mathias Agopian3559b072012-08-15 13:46:03 -07002766 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002767
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002768 if (transactionFlags & (eDisplayLayerStackChanged|eDisplayTransactionNeeded)) {
Mathias Agopian84300952012-11-21 16:02:13 -08002769 // The transform hint might have changed for some layers
2770 // (either because a display has changed, or because a layer
2771 // as changed).
2772 //
2773 // Walk through all the layers in currentLayers,
2774 // and update their transform hint.
2775 //
2776 // If a layer is visible only on a single display, then that
2777 // display is used to calculate the hint, otherwise we use the
2778 // default display.
2779 //
2780 // NOTE: we do this here, rather than in rebuildLayerStacks() so that
2781 // the hint is set before we acquire a buffer from the surface texture.
2782 //
2783 // NOTE: layer transactions have taken place already, so we use their
2784 // drawing state. However, SurfaceFlinger's own transaction has not
2785 // happened yet, so we must use the current state layer list
2786 // (soon to become the drawing state list).
2787 //
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002788 sp<const DisplayDevice> hintDisplay;
Mathias Agopian84300952012-11-21 16:02:13 -08002789 uint32_t currentlayerStack = 0;
Robert Carr2047fae2016-11-28 14:09:09 -08002790 bool first = true;
2791 mCurrentState.traverseInZOrder([&](Layer* layer) {
Mathias Agopian84300952012-11-21 16:02:13 -08002792 // NOTE: we rely on the fact that layers are sorted by
2793 // layerStack first (so we don't have to traverse the list
2794 // of displays for every layer).
Robert Carr1f0a16a2016-10-24 16:27:39 -07002795 uint32_t layerStack = layer->getLayerStack();
Robert Carr2047fae2016-11-28 14:09:09 -08002796 if (first || currentlayerStack != layerStack) {
Mathias Agopian84300952012-11-21 16:02:13 -08002797 currentlayerStack = layerStack;
2798 // figure out if this layerstack is mirrored
2799 // (more than one display) if so, pick the default display,
2800 // if not, pick the only display it's on.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002801 hintDisplay = nullptr;
2802 for (const auto& [token, display] : mDisplays) {
Lloyd Piqueef36b002019-01-23 17:52:04 -08002803 if (display->getCompositionDisplay()
2804 ->belongsInOutput(layer->getLayerStack(),
2805 layer->getPrimaryDisplayOnly())) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002806 if (hintDisplay) {
2807 hintDisplay = nullptr;
Mathias Agopian84300952012-11-21 16:02:13 -08002808 break;
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002809 } else {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002810 hintDisplay = display;
Mathias Agopian84300952012-11-21 16:02:13 -08002811 }
2812 }
2813 }
2814 }
Chet Haase91d25932013-04-11 15:24:55 -07002815
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002816 if (!hintDisplay) {
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002817 // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
2818 // redraw after transform hint changes. See bug 8508397.
Robert Carr56a0b9a2017-12-04 16:06:13 -08002819
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002820 // could be null when this layer is using a layerStack
2821 // that is not visible on any display. Also can occur at
2822 // screen off/on times.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002823 hintDisplay = getDefaultDisplayDeviceLocked();
Mathias Agopian84300952012-11-21 16:02:13 -08002824 }
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002825
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002826 // could be null if there is no display available at all to get
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002827 // the transform hint from.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002828 if (hintDisplay) {
2829 layer->updateTransformHint(hintDisplay);
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08002830 }
Robert Carr2047fae2016-11-28 14:09:09 -08002831
2832 first = false;
2833 });
Mathias Agopian84300952012-11-21 16:02:13 -08002834 }
2835
2836
Mathias Agopian3559b072012-08-15 13:46:03 -07002837 /*
2838 * Perform our own transaction if needed
2839 */
Robert Carr1f0a16a2016-10-24 16:27:39 -07002840
2841 if (mLayersAdded) {
2842 mLayersAdded = false;
2843 // Layers have been added.
Mathias Agopian3559b072012-08-15 13:46:03 -07002844 mVisibleRegionsDirty = true;
2845 }
2846
2847 // some layers might have been removed, so
2848 // we need to update the regions they're exposing.
2849 if (mLayersRemoved) {
2850 mLayersRemoved = false;
2851 mVisibleRegionsDirty = true;
Robert Carr2047fae2016-11-28 14:09:09 -08002852 mDrawingState.traverseInZOrder([&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07002853 if (mLayersPendingRemoval.indexOf(layer) >= 0) {
Mathias Agopian3559b072012-08-15 13:46:03 -07002854 // this layer is not visible anymore
Robert Carr1f0a16a2016-10-24 16:27:39 -07002855 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002856 visibleReg.set(layer->getScreenBounds());
Chia-I Wuab0c3192017-08-01 11:29:00 -07002857 invalidateLayerStack(layer, visibleReg);
Mathias Agopian0aa758d2009-04-22 15:23:34 -07002858 }
Robert Carr2047fae2016-11-28 14:09:09 -08002859 });
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002860 }
2861
Vishnu Nairec0ab382019-02-13 15:32:56 -08002862 commitInputWindowCommands();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002863 commitTransaction();
Riley Andrews03414a12014-07-01 14:22:59 -07002864}
2865
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002866void SurfaceFlinger::updateInputFlinger() {
Robert Carr720e5062018-07-30 17:45:14 -07002867 ATRACE_CALL();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002868 if (!mInputFlinger) {
Vishnu Nairde19f852018-12-18 16:11:53 -08002869 return;
2870 }
2871
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002872 if (mVisibleRegionsDirty || mInputInfoChanged) {
2873 mInputInfoChanged = false;
2874 updateInputWindowInfo();
chaviw95ef3c42019-02-14 10:55:09 -08002875 } else if (mInputWindowCommands.syncInputWindows) {
2876 // If the caller requested to sync input windows, but there are no
2877 // changes to input windows, notify immediately.
2878 setInputWindowsFinished();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002879 }
2880
2881 executeInputWindowCommands();
2882}
2883
2884void SurfaceFlinger::updateInputWindowInfo() {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002885 std::vector<InputWindowInfo> inputHandles;
Robert Carr720e5062018-07-30 17:45:14 -07002886
2887 mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
2888 if (layer->hasInput()) {
Vishnu Nair51625fa2018-12-06 13:54:33 -08002889 // When calculating the screen bounds we ignore the transparent region since it may
2890 // result in an unwanted offset.
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002891 inputHandles.push_back(layer->fillInputInfo());
Robert Carr720e5062018-07-30 17:45:14 -07002892 }
2893 });
chaviw291d88a2019-02-14 10:33:58 -08002894
2895 mInputFlinger->setInputWindows(inputHandles,
2896 mInputWindowCommands.syncInputWindows ? mSetInputWindowsListener
2897 : nullptr);
Robert Carr720e5062018-07-30 17:45:14 -07002898}
2899
Vishnu Nairec0ab382019-02-13 15:32:56 -08002900void SurfaceFlinger::commitInputWindowCommands() {
chaviw4fe36852019-04-15 16:25:49 -07002901 mInputWindowCommands = mPendingInputWindowCommands;
Vishnu Nairec0ab382019-02-13 15:32:56 -08002902 mPendingInputWindowCommands.clear();
2903}
2904
chaviwfbe5d9c2018-12-26 12:23:37 -08002905void SurfaceFlinger::executeInputWindowCommands() {
chaviwfbe5d9c2018-12-26 12:23:37 -08002906 for (const auto& transferTouchFocusCommand : mInputWindowCommands.transferTouchFocusCommands) {
2907 if (transferTouchFocusCommand.fromToken != nullptr &&
2908 transferTouchFocusCommand.toToken != nullptr &&
2909 transferTouchFocusCommand.fromToken != transferTouchFocusCommand.toToken) {
2910 mInputFlinger->transferTouchFocus(transferTouchFocusCommand.fromToken,
2911 transferTouchFocusCommand.toToken);
2912 }
2913 }
2914
2915 mInputWindowCommands.clear();
2916}
2917
Riley Andrews03414a12014-07-01 14:22:59 -07002918void SurfaceFlinger::updateCursorAsync()
2919{
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002920 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002921 if (!display->getId()) {
Riley Andrews03414a12014-07-01 14:22:59 -07002922 continue;
2923 }
Dan Stoza9e56aa02015-11-02 13:00:03 -08002924
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002925 for (auto& layer : display->getVisibleLayersSortedByZ()) {
2926 layer->updateCursorPosition(display);
Riley Andrews03414a12014-07-01 14:22:59 -07002927 }
2928 }
Mathias Agopian4fec8732012-06-29 14:12:52 -07002929}
2930
chaviw61626f22018-11-15 16:26:27 -08002931void SurfaceFlinger::latchAndReleaseBuffer(const sp<Layer>& layer) {
2932 if (layer->hasReadyFrame()) {
Robert Carra0629232019-02-07 15:28:54 -08002933 bool ignored = false;
Alec Mouri56e538f2019-01-14 15:22:01 -08002934 layer->latchBuffer(ignored, systemTime());
chaviw61626f22018-11-15 16:26:27 -08002935 }
2936 layer->releasePendingBuffer(systemTime());
2937}
2938
Mathias Agopian4fec8732012-06-29 14:12:52 -07002939void SurfaceFlinger::commitTransaction()
2940{
Steve Pfetsch598f6d52016-10-25 21:47:58 +00002941 if (!mLayersPendingRemoval.isEmpty()) {
Mathias Agopian4fec8732012-06-29 14:12:52 -07002942 // Notify removed layers now that they can't be drawn from
Robert Carr1f0a16a2016-10-24 16:27:39 -07002943 for (const auto& l : mLayersPendingRemoval) {
2944 recordBufferingStats(l->getName().string(),
2945 l->getOccupancyHistory(true));
Robert Carr2e102c92018-10-23 12:11:15 -07002946
Lloyd Pique07e33212018-12-18 16:33:37 -08002947 // Ensure any buffers set to display on any children are released.
Robert Carr2e102c92018-10-23 12:11:15 -07002948 if (l->isRemovedFromCurrentState()) {
Robert Carr6fb1a7e2018-12-11 12:07:25 -08002949 latchAndReleaseBuffer(l);
Robert Carr2e102c92018-10-23 12:11:15 -07002950 }
Mathias Agopian4fec8732012-06-29 14:12:52 -07002951 }
2952 mLayersPendingRemoval.clear();
2953 }
2954
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002955 // If this transaction is part of a window animation then the next frame
2956 // we composite should be considered an animation as well.
2957 mAnimCompositionPending = mAnimTransactionPending;
2958
Nataniel Borges2b796da2019-02-15 13:32:18 -08002959 withTracingLock([&]() {
2960 mDrawingState = mCurrentState;
2961 // clear the "changed" flags in current state
2962 mCurrentState.colorMatrixChanged = false;
Chia-I Wu28f320b2018-05-03 11:02:56 -07002963
Nataniel Borges2b796da2019-02-15 13:32:18 -08002964 mDrawingState.traverseInZOrder([](Layer* layer) { layer->commitChildList(); });
Robert Carr1f0a16a2016-10-24 16:27:39 -07002965 });
Nataniel Borges2b796da2019-02-15 13:32:18 -08002966
Jamie Gennis2d5e2302012-10-15 18:24:43 -07002967 mTransactionPending = false;
2968 mAnimTransactionPending = false;
Mathias Agopian4fec8732012-06-29 14:12:52 -07002969 mTransactionCV.broadcast();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002970}
2971
Nataniel Borges2b796da2019-02-15 13:32:18 -08002972void SurfaceFlinger::withTracingLock(std::function<void()> lockedOperation) {
2973 if (mTracingEnabledChanged) {
2974 mTracingEnabled = mTracing.isEnabled();
2975 mTracingEnabledChanged = false;
2976 }
2977
2978 // Synchronize with Tracing thread
2979 std::unique_lock<std::mutex> lock;
2980 if (mTracingEnabled) {
2981 lock = std::unique_lock<std::mutex>(mDrawingStateLock);
2982 }
2983
2984 lockedOperation();
2985
2986 // Synchronize with Tracing thread
2987 if (mTracingEnabled) {
2988 lock.unlock();
2989 }
2990}
2991
Lloyd Pique32cbe282018-10-19 13:09:22 -07002992void SurfaceFlinger::computeVisibleRegions(const sp<const DisplayDevice>& displayDevice,
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002993 Region& outDirtyRegion, Region& outOpaqueRegion) {
Mathias Agopian841cde52012-03-01 15:44:37 -08002994 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08002995 ALOGV("computeVisibleRegions");
Mathias Agopian841cde52012-03-01 15:44:37 -08002996
Lloyd Pique32cbe282018-10-19 13:09:22 -07002997 auto display = displayDevice->getCompositionDisplay();
2998
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002999 Region aboveOpaqueLayers;
3000 Region aboveCoveredLayers;
3001 Region dirty;
3002
Mathias Agopian87baae12012-07-31 12:38:26 -07003003 outDirtyRegion.clear();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003004
Robert Carr2047fae2016-11-28 14:09:09 -08003005 mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08003006 // start with the whole surface at its current location
3007 const Layer::State& s(layer->getDrawingState());
3008
Jesse Hall01e29052013-02-19 16:13:35 -08003009 // only consider the layers on the given layer stack
Lloyd Piqueef36b002019-01-23 17:52:04 -08003010 if (!display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
Robert Carr2047fae2016-11-28 14:09:09 -08003011 return;
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003012 }
Mathias Agopian87baae12012-07-31 12:38:26 -07003013
Mathias Agopianab028732010-03-16 16:41:46 -07003014 /*
3015 * opaqueRegion: area of a surface that is fully opaque.
3016 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003017 Region opaqueRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07003018
3019 /*
3020 * visibleRegion: area of a surface that is visible on screen
3021 * and not fully transparent. This is essentially the layer's
3022 * footprint minus the opaque regions above it.
3023 * Areas covered by a translucent surface are considered visible.
3024 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003025 Region visibleRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07003026
3027 /*
3028 * coveredRegion: area of a surface that is covered by all
3029 * visible regions above it (which includes the translucent areas).
3030 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003031 Region coveredRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07003032
Jesse Halla8026d22012-09-25 13:25:04 -07003033 /*
3034 * transparentRegion: area of a surface that is hinted to be completely
3035 * transparent. This is only used to tell when the layer has no visible
3036 * non-transparent regions and can be removed from the layer list. It
3037 * does not affect the visibleRegion of this layer or any layers
3038 * beneath it. The hint may not be correct if apps don't respect the
3039 * SurfaceView restrictions (which, sadly, some don't).
3040 */
3041 Region transparentRegion;
3042
Mathias Agopianab028732010-03-16 16:41:46 -07003043
3044 // handle hidden surfaces by setting the visible region to empty
Mathias Agopianda27af92012-09-13 18:17:13 -07003045 if (CC_LIKELY(layer->isVisible())) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08003046 const bool translucent = !layer->isOpaque(s);
Vishnu Nair4351ad52019-02-11 14:13:02 -08003047 Rect bounds(layer->getScreenBounds());
Robert Carr720e5062018-07-30 17:45:14 -07003048
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003049 visibleRegion.set(bounds);
Peiyong Linefefaac2018-08-17 12:27:51 -07003050 ui::Transform tr = layer->getTransform();
Mathias Agopianab028732010-03-16 16:41:46 -07003051 if (!visibleRegion.isEmpty()) {
3052 // Remove the transparent area from the visible region
3053 if (translucent) {
Dan Stoza22f7fc42016-05-10 16:19:53 -07003054 if (tr.preserveRects()) {
3055 // transform the transparent region
Lloyd Pique0449b0f2018-12-20 16:23:45 -08003056 transparentRegion = tr.transform(layer->getActiveTransparentRegion(s));
Mathias Agopian4fec8732012-06-29 14:12:52 -07003057 } else {
Dan Stoza22f7fc42016-05-10 16:19:53 -07003058 // transformation too complex, can't do the
3059 // transparent region optimization.
3060 transparentRegion.clear();
Mathias Agopian4fec8732012-06-29 14:12:52 -07003061 }
Mathias Agopianab028732010-03-16 16:41:46 -07003062 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003063
Mathias Agopianab028732010-03-16 16:41:46 -07003064 // compute the opaque region
Robert Carr1f0a16a2016-10-24 16:27:39 -07003065 const int32_t layerOrientation = tr.getOrientation();
Jorim Jaggi039bbb82017-09-06 18:12:05 +02003066 if (layer->getAlpha() == 1.0f && !translucent &&
Lucas Dupin1b6531c2018-07-05 17:18:21 -07003067 layer->getRoundedCornerState().radius == 0.0f &&
Peiyong Linefefaac2018-08-17 12:27:51 -07003068 ((layerOrientation & ui::Transform::ROT_INVALID) == false)) {
Mathias Agopianab028732010-03-16 16:41:46 -07003069 // the opaque region is the layer's footprint
3070 opaqueRegion = visibleRegion;
3071 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003072 }
3073 }
3074
Robert Carre5f4f692018-01-12 13:12:28 -08003075 if (visibleRegion.isEmpty()) {
3076 layer->clearVisibilityRegions();
3077 return;
3078 }
3079
Mathias Agopianab028732010-03-16 16:41:46 -07003080 // Clip the covered region to the visible region
3081 coveredRegion = aboveCoveredLayers.intersect(visibleRegion);
3082
3083 // Update aboveCoveredLayers for next (lower) layer
3084 aboveCoveredLayers.orSelf(visibleRegion);
3085
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003086 // subtract the opaque region covered by the layers above us
3087 visibleRegion.subtractSelf(aboveOpaqueLayers);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003088
3089 // compute this layer's dirty region
3090 if (layer->contentDirty) {
3091 // we need to invalidate the whole region
3092 dirty = visibleRegion;
3093 // as well, as the old visible region
Mathias Agopian4fec8732012-06-29 14:12:52 -07003094 dirty.orSelf(layer->visibleRegion);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003095 layer->contentDirty = false;
3096 } else {
Mathias Agopiana8d44f72009-06-28 02:54:16 -07003097 /* compute the exposed region:
Mathias Agopianab028732010-03-16 16:41:46 -07003098 * the exposed region consists of two components:
3099 * 1) what's VISIBLE now and was COVERED before
3100 * 2) what's EXPOSED now less what was EXPOSED before
3101 *
3102 * note that (1) is conservative, we start with the whole
3103 * visible region but only keep what used to be covered by
3104 * something -- which mean it may have been exposed.
3105 *
3106 * (2) handles areas that were not covered by anything but got
3107 * exposed because of a resize.
Mathias Agopiana8d44f72009-06-28 02:54:16 -07003108 */
Mathias Agopianab028732010-03-16 16:41:46 -07003109 const Region newExposed = visibleRegion - coveredRegion;
Mathias Agopian4fec8732012-06-29 14:12:52 -07003110 const Region oldVisibleRegion = layer->visibleRegion;
3111 const Region oldCoveredRegion = layer->coveredRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07003112 const Region oldExposed = oldVisibleRegion - oldCoveredRegion;
3113 dirty = (visibleRegion&oldCoveredRegion) | (newExposed-oldExposed);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003114 }
3115 dirty.subtractSelf(aboveOpaqueLayers);
3116
3117 // accumulate to the screen dirty region
Mathias Agopian87baae12012-07-31 12:38:26 -07003118 outDirtyRegion.orSelf(dirty);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003119
Mathias Agopianab028732010-03-16 16:41:46 -07003120 // Update aboveOpaqueLayers for next (lower) layer
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003121 aboveOpaqueLayers.orSelf(opaqueRegion);
Andreas Huber8b42e8a2010-08-16 08:49:37 -07003122
Jesse Halla8026d22012-09-25 13:25:04 -07003123 // Store the visible region in screen space
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003124 layer->setVisibleRegion(visibleRegion);
3125 layer->setCoveredRegion(coveredRegion);
Jesse Halla8026d22012-09-25 13:25:04 -07003126 layer->setVisibleNonTransparentRegion(
3127 visibleRegion.subtract(transparentRegion));
Robert Carr2047fae2016-11-28 14:09:09 -08003128 });
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003129
Mathias Agopian87baae12012-07-31 12:38:26 -07003130 outOpaqueRegion = aboveOpaqueLayers;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003131}
3132
Chia-I Wuab0c3192017-08-01 11:29:00 -07003133void SurfaceFlinger::invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003134 for (const auto& [token, displayDevice] : mDisplays) {
3135 auto display = displayDevice->getCompositionDisplay();
Lloyd Piqueef36b002019-01-23 17:52:04 -08003136 if (display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003137 display->editState().dirtyRegion.orSelf(dirty);
Mathias Agopian92a979a2012-08-02 18:32:23 -07003138 }
3139 }
Mathias Agopian87baae12012-07-31 12:38:26 -07003140}
3141
Dan Stoza6b9454d2014-11-07 16:00:59 -08003142bool SurfaceFlinger::handlePageFlip()
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003143{
Ady Abraham09bd3922019-04-08 10:44:56 -07003144 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08003145 ALOGV("handlePageFlip");
3146
Brian Andersond6927fb2016-07-23 23:37:30 -07003147 nsecs_t latchTime = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003148
Mathias Agopian4fec8732012-06-29 14:12:52 -07003149 bool visibleRegions = false;
Dan Stoza6b9454d2014-11-07 16:00:59 -08003150 bool frameQueued = false;
Mike Stroyan0cd76192017-04-20 12:10:48 -06003151 bool newDataLatched = false;
Eric Penner51c59cd2014-07-28 19:51:58 -07003152
3153 // Store the set of layers that need updates. This set must not change as
3154 // buffers are being latched, as this could result in a deadlock.
3155 // Example: Two producers share the same command stream and:
3156 // 1.) Layer 0 is latched
3157 // 2.) Layer 0 gets a new frame
3158 // 2.) Layer 1 gets a new frame
3159 // 3.) Layer 1 is latched.
3160 // Display is now waiting on Layer 1's frame, which is behind layer 0's
3161 // second frame. But layer 0's second frame could be waiting on display.
Robert Carr2047fae2016-11-28 14:09:09 -08003162 mDrawingState.traverseInZOrder([&](Layer* layer) {
Marissa Wallfd668622018-05-10 10:21:13 -07003163 if (layer->hasReadyFrame()) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08003164 frameQueued = true;
Ady Abrahamc3e21312019-02-07 14:30:23 -08003165 nsecs_t expectedPresentTime;
Ana Krulecc2870422019-01-29 19:00:58 -08003166 expectedPresentTime = mScheduler->expectedPresentTime();
Ana Krulec010d2192018-10-08 06:29:54 -07003167 if (layer->shouldPresentNow(expectedPresentTime)) {
Robert Carr2047fae2016-11-28 14:09:09 -08003168 mLayersWithQueuedFrames.push_back(layer);
Dan Stozaee44edd2015-03-23 15:50:23 -07003169 } else {
Ady Abraham09bd3922019-04-08 10:44:56 -07003170 ATRACE_NAME("!layer->shouldPresentNow()");
Dan Stozaee44edd2015-03-23 15:50:23 -07003171 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08003172 }
Dan Stozaee44edd2015-03-23 15:50:23 -07003173 } else {
3174 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08003175 }
Robert Carr2047fae2016-11-28 14:09:09 -08003176 });
3177
Lloyd Piquef2c79392018-12-20 16:23:33 -08003178 if (!mLayersWithQueuedFrames.empty()) {
3179 // mStateLock is needed for latchBuffer as LayerRejecter::reject()
3180 // writes to Layer current state. See also b/119481871
3181 Mutex::Autolock lock(mStateLock);
3182
3183 for (auto& layer : mLayersWithQueuedFrames) {
Alec Mouri56e538f2019-01-14 15:22:01 -08003184 if (layer->latchBuffer(visibleRegions, latchTime)) {
Vishnu Nair6194e2e2019-02-06 12:58:39 -08003185 mLayersPendingRefresh.push_back(layer);
3186 }
Lloyd Piquef2c79392018-12-20 16:23:33 -08003187 layer->useSurfaceDamage();
Lloyd Piquef2c79392018-12-20 16:23:33 -08003188 if (layer->isBufferLatched()) {
3189 newDataLatched = true;
3190 }
Mike Stroyan0cd76192017-04-20 12:10:48 -06003191 }
Mathias Agopian4fec8732012-06-29 14:12:52 -07003192 }
Mathias Agopian4da75192010-08-10 17:19:56 -07003193
Mathias Agopian3b1d2b62012-07-11 13:48:17 -07003194 mVisibleRegionsDirty |= visibleRegions;
Dan Stoza6b9454d2014-11-07 16:00:59 -08003195
3196 // If we will need to wake up at some time in the future to deal with a
3197 // queued frame that shouldn't be displayed during this vsync period, wake
3198 // up during the next vsync period to check again.
Chia-I Wua36bf922017-06-30 12:51:05 -07003199 if (frameQueued && (mLayersWithQueuedFrames.empty() || !newDataLatched)) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08003200 signalLayerUpdate();
3201 }
3202
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08003203 // enter boot animation on first buffer latch
3204 if (CC_UNLIKELY(mBootStage == BootStage::BOOTLOADER && newDataLatched)) {
3205 ALOGI("Enter boot animation");
3206 mBootStage = BootStage::BOOTANIMATION;
3207 }
3208
Dan Stoza6b9454d2014-11-07 16:00:59 -08003209 // Only continue with the refresh if there is actually new work to do
Mike Stroyan0cd76192017-04-20 12:10:48 -06003210 return !mLayersWithQueuedFrames.empty() && newDataLatched;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003211}
3212
Mathias Agopianad456f92011-01-13 17:53:01 -08003213void SurfaceFlinger::invalidateHwcGeometry()
3214{
Dan Stoza9e56aa02015-11-02 13:00:03 -08003215 mGeometryInvalid = true;
Mathias Agopianad456f92011-01-13 17:53:01 -08003216}
3217
Lloyd Pique32cbe282018-10-19 13:09:22 -07003218void SurfaceFlinger::doDisplayComposition(const sp<DisplayDevice>& displayDevice,
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003219 const Region& inDirtyRegion) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003220 auto display = displayDevice->getCompositionDisplay();
Dan Stoza71433162014-02-04 16:22:36 -08003221 // We only need to actually compose the display if:
3222 // 1) It is being handled by hardware composer, which may need this to
3223 // keep its virtual display state machine in sync, or
3224 // 2) There is work to be done (the dirty region isn't empty)
Lloyd Pique32cbe282018-10-19 13:09:22 -07003225 if (!displayDevice->getId() && inDirtyRegion.isEmpty()) {
Dan Stoza9e56aa02015-11-02 13:00:03 -08003226 ALOGV("Skipping display composition");
Dan Stoza71433162014-02-04 16:22:36 -08003227 return;
3228 }
3229
Dan Stoza9e56aa02015-11-02 13:00:03 -08003230 ALOGV("doDisplayComposition");
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003231 base::unique_fd readyFence;
3232 if (!doComposeSurfaces(displayDevice, Region::INVALID_REGION, &readyFence)) return;
Mathias Agopianda27af92012-09-13 18:17:13 -07003233
3234 // swap buffers (presentation)
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003235 display->getRenderSurface()->queueBuffer(std::move(readyFence));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003236}
3237
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003238bool SurfaceFlinger::doComposeSurfaces(const sp<DisplayDevice>& displayDevice,
3239 const Region& debugRegion, base::unique_fd* readyFence) {
Alec Mouri820c7402019-01-23 13:02:39 -08003240 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08003241 ALOGV("doComposeSurfaces");
Mathias Agopiancd20eb02011-09-22 20:57:04 -07003242
Lloyd Pique32cbe282018-10-19 13:09:22 -07003243 auto display = displayDevice->getCompositionDisplay();
3244 const auto& displayState = display->getState();
Dominik Laskowski7e045462018-05-30 13:02:02 -07003245 const auto displayId = display->getId();
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08003246 auto& renderEngine = getRenderEngine();
Peiyong Lin548d4fa2019-04-02 18:14:44 -07003247 const bool supportProtectedContent = renderEngine.supportsProtectedContent();
Lloyd Pique32cbe282018-10-19 13:09:22 -07003248
3249 const Region bounds(displayState.bounds);
3250 const DisplayRenderArea renderArea(displayDevice);
Lloyd Pique441d5042018-10-18 16:49:51 -07003251 const bool hasClientComposition = getHwComposer().hasClientComposition(displayId);
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08003252 ATRACE_INT("hasClientComposition", hasClientComposition);
Dan Stoza9f26a9c2016-06-22 14:51:09 -07003253
Chia-I Wu8e50e692018-05-04 10:12:37 -07003254 bool applyColorMatrix = false;
Dan Stoza9f26a9c2016-06-22 14:51:09 -07003255
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003256 renderengine::DisplaySettings clientCompositionDisplay;
3257 std::vector<renderengine::LayerSettings> clientCompositionLayers;
3258 sp<GraphicBuffer> buf;
Alec Mouri6338c9d2019-02-07 16:57:51 -08003259 base::unique_fd fd;
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003260
Dan Stoza9e56aa02015-11-02 13:00:03 -08003261 if (hasClientComposition) {
3262 ALOGV("hasClientComposition");
3263
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08003264 if (displayDevice->isPrimary() && supportProtectedContent) {
3265 bool needsProtected = false;
3266 for (auto& layer : displayDevice->getVisibleLayersSortedByZ()) {
3267 // If the layer is a protected layer, mark protected context is needed.
3268 if (layer->isProtected()) {
3269 needsProtected = true;
3270 break;
3271 }
3272 }
3273 if (needsProtected != renderEngine.isProtected() &&
3274 renderEngine.useProtectedContext(needsProtected)) {
3275 display->getRenderSurface()->setProtected(needsProtected);
3276 }
3277 }
3278
Alec Mouri6338c9d2019-02-07 16:57:51 -08003279 buf = display->getRenderSurface()->dequeueBuffer(&fd);
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08003280
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003281 if (buf == nullptr) {
3282 ALOGW("Dequeuing buffer for display [%s] failed, bailing out of "
3283 "client composition for this frame",
Lloyd Pique32cbe282018-10-19 13:09:22 -07003284 displayDevice->getDisplayName().c_str());
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003285 return false;
3286 }
3287
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003288 clientCompositionDisplay.physicalDisplay = displayState.scissor;
3289 clientCompositionDisplay.clip = displayState.scissor;
3290 const ui::Transform& displayTransform = displayState.transform;
Lloyd Pique7e06e7f2019-03-15 18:36:44 -07003291 clientCompositionDisplay.globalTransform = displayTransform.asMatrix4();
Peiyong Linb1925962019-04-01 16:37:10 -07003292 clientCompositionDisplay.orientation = displayState.orientation;
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003293
Lloyd Pique3d0c02e2018-10-19 18:38:12 -07003294 const auto* profile = display->getDisplayColorProfile();
Peiyong Lin34beb7a2018-03-28 11:57:12 -07003295 Dataspace outputDataspace = Dataspace::UNKNOWN;
Lloyd Pique3d0c02e2018-10-19 18:38:12 -07003296 if (profile->hasWideColorGamut()) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003297 outputDataspace = displayState.dataspace;
Chia-I Wu69bf10f2018-02-20 13:04:50 -08003298 }
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003299 clientCompositionDisplay.outputDataspace = outputDataspace;
3300 clientCompositionDisplay.maxLuminance =
3301 profile->getHdrCapabilities().getDesiredMaxLuminance();
Chia-I Wu69bf10f2018-02-20 13:04:50 -08003302
Lloyd Pique441d5042018-10-18 16:49:51 -07003303 const bool hasDeviceComposition = getHwComposer().hasDeviceComposition(displayId);
Peiyong Lined531a32018-10-26 18:27:56 -07003304 const bool skipClientColorTransform =
Lloyd Pique441d5042018-10-18 16:49:51 -07003305 getHwComposer()
3306 .hasDisplayCapability(displayId,
3307 HWC2::DisplayCapability::SkipClientColorTransform);
Chia-I Wu8e50e692018-05-04 10:12:37 -07003308
Peiyong Lind3788632018-09-18 16:01:31 -07003309 // Compute the global color transform matrix.
Chia-I Wu8e50e692018-05-04 10:12:37 -07003310 applyColorMatrix = !hasDeviceComposition && !skipClientColorTransform;
3311 if (applyColorMatrix) {
Alec Mouric7e8ce82019-04-02 12:28:05 -07003312 clientCompositionDisplay.colorTransform = displayState.colorTransformMat;
Mathias Agopianf45c5102012-10-24 16:29:17 -07003313 }
Mathias Agopian85d751c2012-08-29 16:59:24 -07003314 }
Mathias Agopian4b2ba532012-03-29 12:23:51 -07003315
Mathias Agopian85d751c2012-08-29 16:59:24 -07003316 /*
3317 * and then, render the layers targeted at the framebuffer
3318 */
Mathias Agopian4b2ba532012-03-29 12:23:51 -07003319
Dan Stoza9e56aa02015-11-02 13:00:03 -08003320 ALOGV("Rendering client layers");
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003321 bool firstLayer = true;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003322 Region clearRegion = Region::INVALID_REGION;
Lloyd Pique32cbe282018-10-19 13:09:22 -07003323 for (auto& layer : displayDevice->getVisibleLayersSortedByZ()) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003324 const Region viewportRegion(displayState.viewport);
3325 const Region clip(viewportRegion.intersect(layer->visibleRegion));
David Sodmanc1498e62018-09-12 14:36:26 -07003326 ALOGV("Layer: %s", layer->getName().string());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08003327 ALOGV(" Composition type: %s", toString(layer->getCompositionType(displayDevice)).c_str());
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003328 if (!clip.isEmpty()) {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08003329 switch (layer->getCompositionType(displayDevice)) {
3330 case Hwc2::IComposerClient::Composition::CURSOR:
3331 case Hwc2::IComposerClient::Composition::DEVICE:
3332 case Hwc2::IComposerClient::Composition::SIDEBAND:
3333 case Hwc2::IComposerClient::Composition::SOLID_COLOR: {
Dominik Laskowski075d3172018-05-24 15:50:06 -07003334 LOG_ALWAYS_FATAL_IF(!displayId);
Lloyd Pique0449b0f2018-12-20 16:23:45 -08003335 const Layer::State& state(layer->getDrawingState());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08003336 if (layer->getClearClientTarget(displayDevice) && !firstLayer &&
Lloyd Pique0449b0f2018-12-20 16:23:45 -08003337 layer->isOpaque(state) && (layer->getAlpha() == 1.0f) &&
Lucas Dupin1b6531c2018-07-05 17:18:21 -07003338 layer->getRoundedCornerState().radius == 0.0f && hasClientComposition) {
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003339 // never clear the very first layer since we're
3340 // guaranteed the FB is already cleared
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003341 renderengine::LayerSettings layerSettings;
3342 Region dummyRegion;
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08003343 bool prepared =
3344 layer->prepareClientLayer(renderArea, clip, dummyRegion,
3345 supportProtectedContent, layerSettings);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003346
3347 if (prepared) {
3348 layerSettings.source.buffer.buffer = nullptr;
3349 layerSettings.source.solidColor = half3(0.0, 0.0, 0.0);
3350 layerSettings.alpha = half(0.0);
3351 layerSettings.disableBlending = true;
3352 clientCompositionLayers.push_back(layerSettings);
3353 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07003354 }
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003355 break;
Mathias Agopiancd60f992012-08-16 16:28:27 -07003356 }
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08003357 case Hwc2::IComposerClient::Composition::CLIENT: {
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003358 renderengine::LayerSettings layerSettings;
3359 bool prepared =
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08003360 layer->prepareClientLayer(renderArea, clip, clearRegion,
3361 supportProtectedContent, layerSettings);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003362 if (prepared) {
3363 clientCompositionLayers.push_back(layerSettings);
Peiyong Lind3788632018-09-18 16:01:31 -07003364 }
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003365 break;
3366 }
3367 default:
3368 break;
Mathias Agopian85d751c2012-08-29 16:59:24 -07003369 }
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003370 } else {
3371 ALOGV(" Skipping for empty clip");
Mathias Agopian85d751c2012-08-29 16:59:24 -07003372 }
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003373 firstLayer = false;
Mathias Agopian4b2ba532012-03-29 12:23:51 -07003374 }
Mathias Agopianf45c5102012-10-24 16:29:17 -07003375
Alec Mouri820c7402019-01-23 13:02:39 -08003376 // Perform some cleanup steps if we used client composition.
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003377 if (hasClientComposition) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003378 clientCompositionDisplay.clearRegion = clearRegion;
Peiyong Lin74ca2f42019-01-14 19:36:57 -08003379
3380 // We boost GPU frequency here because there will be color spaces conversion
3381 // and it's expensive. We boost the GPU frequency so that GPU composition can
3382 // finish in time. We must reset GPU frequency afterwards, because high frequency
3383 // consumes extra battery.
3384 const bool expensiveRenderingExpected =
3385 clientCompositionDisplay.outputDataspace == Dataspace::DISPLAY_P3;
3386 if (expensiveRenderingExpected && displayId) {
3387 mPowerAdvisor.setExpensiveRenderingExpected(*displayId, true);
3388 }
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003389 if (!debugRegion.isEmpty()) {
3390 Region::const_iterator it = debugRegion.begin();
3391 Region::const_iterator end = debugRegion.end();
3392 while (it != end) {
3393 const Rect& rect = *it++;
3394 renderengine::LayerSettings layerSettings;
3395 layerSettings.source.buffer.buffer = nullptr;
3396 layerSettings.source.solidColor = half3(1.0, 0.0, 1.0);
3397 layerSettings.geometry.boundaries = rect.toFloatRect();
3398 layerSettings.alpha = half(1.0);
3399 clientCompositionLayers.push_back(layerSettings);
3400 }
3401 }
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08003402 renderEngine.drawLayers(clientCompositionDisplay, clientCompositionLayers,
Alec Mourife0d72b2019-03-21 14:05:56 -07003403 buf->getNativeBuffer(), /*useFramebufferCache=*/true, std::move(fd),
3404 readyFence);
Peiyong Lin8ec87f82019-04-05 11:30:51 -07003405 } else if (displayId) {
3406 mPowerAdvisor.setExpensiveRenderingExpected(*displayId, false);
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003407 }
Michael Lentine3f121fc2014-10-01 11:17:28 -07003408 return true;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003409}
3410
Chia-I Wu28e3a252018-09-07 12:05:02 -07003411void SurfaceFlinger::drawWormhole(const Region& region) const {
Lloyd Pique144e1162017-12-20 16:44:52 -08003412 auto& engine(getRenderEngine());
Chia-I Wu28e3a252018-09-07 12:05:02 -07003413 engine.fillRegionWithColor(region, 0, 0, 0, 0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003414}
3415
Robert Carrc0df3122019-04-11 13:18:21 -07003416status_t SurfaceFlinger::addClientLayer(const sp<Client>& client, const sp<IBinder>& handle,
3417 const sp<IGraphicBufferProducer>& gbc, const sp<Layer>& lbc,
3418 const sp<IBinder>& parentHandle,
3419 const sp<Layer>& parentLayer, bool addToCurrentState) {
Dan Stoza7d89d062015-04-30 13:29:25 -07003420 // add this layer to the current state list
3421 {
3422 Mutex::Autolock _l(mStateLock);
Robert Carrc0df3122019-04-11 13:18:21 -07003423 sp<Layer> parent;
3424 if (parentHandle != nullptr) {
3425 parent = fromHandle(parentHandle);
3426 if (parent == nullptr) {
3427 return NAME_NOT_FOUND;
3428 }
3429 } else {
3430 parent = parentLayer;
3431 }
3432
Robert Carr1f0a16a2016-10-24 16:27:39 -07003433 if (mNumLayers >= MAX_LAYERS) {
Courtney Goeltzenleuchterab702f52017-04-19 15:14:02 -06003434 ALOGE("AddClientLayer failed, mNumLayers (%zu) >= MAX_LAYERS (%zu)", mNumLayers,
3435 MAX_LAYERS);
Dan Stoza7d89d062015-04-30 13:29:25 -07003436 return NO_MEMORY;
3437 }
Robert Carrc0df3122019-04-11 13:18:21 -07003438
3439 mLayersByLocalBinderToken.emplace(handle->localBinder(), lbc);
3440
Robert Carrb89ea9d2018-12-10 13:01:14 -08003441 if (parent == nullptr && addToCurrentState) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003442 mCurrentState.layersSortedByZ.add(lbc);
chaviwac841852019-01-16 16:04:43 -08003443 } else if (parent == nullptr) {
3444 lbc->onRemovedFromCurrentState();
3445 } else if (parent->isRemovedFromCurrentState()) {
3446 parent->addChild(lbc);
3447 lbc->onRemovedFromCurrentState();
Robert Carrb89ea9d2018-12-10 13:01:14 -08003448 } else {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003449 parent->addChild(lbc);
3450 }
Chia-I Wu98f1c102017-05-30 14:54:08 -07003451
Yiwei Zhang243b3782018-05-15 17:40:04 -07003452 if (gbc != nullptr) {
3453 mGraphicBufferProducerList.insert(IInterface::asBinder(gbc).get());
3454 LOG_ALWAYS_FATAL_IF(mGraphicBufferProducerList.size() >
3455 mMaxGraphicBufferProducerListSize,
3456 "Suspected IGBP leak: %zu IGBPs (%zu max), %zu Layers",
3457 mGraphicBufferProducerList.size(),
3458 mMaxGraphicBufferProducerListSize, mNumLayers);
3459 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07003460 mLayersAdded = true;
Dan Stoza7d89d062015-04-30 13:29:25 -07003461 }
3462
Mathias Agopian96f08192010-06-02 23:28:45 -07003463 // attach this layer to the client
Mathias Agopianac9fa422013-02-11 16:40:36 -08003464 client->attachLayer(handle, lbc);
Mathias Agopian4f113742011-05-03 16:21:41 -07003465
Dan Stoza7d89d062015-04-30 13:29:25 -07003466 return NO_ERROR;
Mathias Agopian96f08192010-06-02 23:28:45 -07003467}
3468
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08003469uint32_t SurfaceFlinger::peekTransactionFlags() {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003470 return mTransactionFlags;
Mathias Agopiandea20b12011-05-03 17:04:02 -07003471}
3472
Mathias Agopian3f844832013-08-07 21:24:32 -07003473uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003474 return mTransactionFlags.fetch_and(~flags) & flags;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003475}
3476
Mathias Agopian3f844832013-08-07 21:24:32 -07003477uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) {
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003478 return setTransactionFlags(flags, Scheduler::TransactionStart::NORMAL);
Dan Stoza84d619e2018-03-28 17:07:36 -07003479}
3480
3481uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags,
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003482 Scheduler::TransactionStart transactionStart) {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003483 uint32_t old = mTransactionFlags.fetch_or(flags);
Dan Stoza84d619e2018-03-28 17:07:36 -07003484 mVsyncModulator.setTransactionStart(transactionStart);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003485 if ((old & flags)==0) { // wake the server up
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08003486 signalTransaction();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003487 }
3488 return old;
3489}
3490
Marissa Wall713b63f2018-10-17 15:42:43 -07003491bool SurfaceFlinger::flushTransactionQueues() {
3492 Mutex::Autolock _l(mStateLock);
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003493 bool flushedATransaction = false;
3494
Marissa Wall713b63f2018-10-17 15:42:43 -07003495 auto it = mTransactionQueues.begin();
3496 while (it != mTransactionQueues.end()) {
3497 auto& [applyToken, transactionQueue] = *it;
3498
3499 while (!transactionQueue.empty()) {
Marissa Wall78b72202019-03-15 14:58:34 -07003500 const auto&
Marissa Wall3dad52d2019-03-22 14:03:19 -07003501 [states, displays, flags, desiredPresentTime, uncacheBuffer, listenerCallbacks,
3502 postTime, privileged] = transactionQueue.front();
Marissa Wall17b4e452018-12-26 16:32:34 -08003503 if (!transactionIsReadyToBeApplied(desiredPresentTime, states)) {
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003504 setTransactionFlags(eTransactionFlushNeeded);
Marissa Wall713b63f2018-10-17 15:42:43 -07003505 break;
3506 }
Valerie Haubc6ddb12019-03-08 11:10:15 -08003507 applyTransactionState(states, displays, flags, mPendingInputWindowCommands,
Marissa Wall3dad52d2019-03-22 14:03:19 -07003508 desiredPresentTime, uncacheBuffer, listenerCallbacks, postTime,
3509 privileged, /*isMainThread*/ true);
Marissa Wall713b63f2018-10-17 15:42:43 -07003510 transactionQueue.pop();
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003511 flushedATransaction = true;
Marissa Wall713b63f2018-10-17 15:42:43 -07003512 }
3513
3514 it = (transactionQueue.empty()) ? mTransactionQueues.erase(it) : std::next(it, 1);
3515 }
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003516 return flushedATransaction;
3517}
3518
3519bool SurfaceFlinger::transactionFlushNeeded() {
3520 return !mTransactionQueues.empty();
Marissa Wall713b63f2018-10-17 15:42:43 -07003521}
3522
chaviwca27f252018-02-06 16:46:39 -08003523bool SurfaceFlinger::containsAnyInvalidClientState(const Vector<ComposerState>& states) {
3524 for (const ComposerState& state : states) {
3525 // Here we need to check that the interface we're given is indeed
3526 // one of our own. A malicious client could give us a nullptr
3527 // IInterface, or one of its own or even one of our own but a
3528 // different type. All these situations would cause us to crash.
3529 if (state.client == nullptr) {
3530 return true;
3531 }
3532
3533 sp<IBinder> binder = IInterface::asBinder(state.client);
3534 if (binder == nullptr) {
3535 return true;
3536 }
3537
3538 if (binder->queryLocalInterface(ISurfaceComposerClient::descriptor) == nullptr) {
3539 return true;
3540 }
3541 }
3542 return false;
3543}
3544
Marissa Wall17b4e452018-12-26 16:32:34 -08003545bool SurfaceFlinger::transactionIsReadyToBeApplied(int64_t desiredPresentTime,
3546 const Vector<ComposerState>& states) {
Ana Krulecc2870422019-01-29 19:00:58 -08003547 nsecs_t expectedPresentTime = mScheduler->expectedPresentTime();
Marissa Wall17b4e452018-12-26 16:32:34 -08003548 // Do not present if the desiredPresentTime has not passed unless it is more than one second
3549 // in the future. We ignore timestamps more than 1 second in the future for stability reasons.
3550 if (desiredPresentTime >= 0 && desiredPresentTime >= expectedPresentTime &&
3551 desiredPresentTime < expectedPresentTime + s2ns(1)) {
3552 return false;
3553 }
3554
Marissa Wall713b63f2018-10-17 15:42:43 -07003555 for (const ComposerState& state : states) {
3556 const layer_state_t& s = state.state;
3557 if (!(s.what & layer_state_t::eAcquireFenceChanged)) {
3558 continue;
3559 }
3560 if (s.acquireFence && s.acquireFence->getStatus() == Fence::Status::Unsignaled) {
Marissa Wall17b4e452018-12-26 16:32:34 -08003561 return false;
Marissa Wall713b63f2018-10-17 15:42:43 -07003562 }
3563 }
Marissa Wall17b4e452018-12-26 16:32:34 -08003564 return true;
Marissa Wall713b63f2018-10-17 15:42:43 -07003565}
3566
3567void SurfaceFlinger::setTransactionState(const Vector<ComposerState>& states,
3568 const Vector<DisplayState>& displays, uint32_t flags,
chaviw273171b2018-12-26 11:46:30 -08003569 const sp<IBinder>& applyToken,
Marissa Wall17b4e452018-12-26 16:32:34 -08003570 const InputWindowCommands& inputWindowCommands,
Marissa Wall78b72202019-03-15 14:58:34 -07003571 int64_t desiredPresentTime,
Marissa Wall947d34e2019-03-29 14:03:53 -07003572 const client_cache_t& uncacheBuffer,
Marissa Wall3dad52d2019-03-22 14:03:19 -07003573 const std::vector<ListenerCallbacks>& listenerCallbacks) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003574 ATRACE_CALL();
Robert Carr14167e02019-02-13 13:50:55 -08003575
Valerie Haubc6ddb12019-03-08 11:10:15 -08003576 const int64_t postTime = systemTime();
3577
Robert Carr14167e02019-02-13 13:50:55 -08003578 bool privileged = callingThreadHasUnscopedSurfaceFlingerAccess();
3579
Mathias Agopian698c0872011-06-28 19:09:31 -07003580 Mutex::Autolock _l(mStateLock);
Mathias Agopiane57f2922012-08-09 16:29:12 -07003581
chaviwca27f252018-02-06 16:46:39 -08003582 if (containsAnyInvalidClientState(states)) {
3583 return;
3584 }
3585
Marissa Wall713b63f2018-10-17 15:42:43 -07003586 // If its TransactionQueue already has a pending TransactionState or if it is pending
3587 if (mTransactionQueues.find(applyToken) != mTransactionQueues.end() ||
Marissa Wall17b4e452018-12-26 16:32:34 -08003588 !transactionIsReadyToBeApplied(desiredPresentTime, states)) {
Robert Carr14167e02019-02-13 13:50:55 -08003589 mTransactionQueues[applyToken].emplace(states, displays, flags, desiredPresentTime,
Marissa Wall3dad52d2019-03-22 14:03:19 -07003590 uncacheBuffer, listenerCallbacks, postTime,
3591 privileged);
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003592 setTransactionFlags(eTransactionFlushNeeded);
Marissa Wall713b63f2018-10-17 15:42:43 -07003593 return;
3594 }
3595
Valerie Haubc6ddb12019-03-08 11:10:15 -08003596 applyTransactionState(states, displays, flags, inputWindowCommands, desiredPresentTime,
Marissa Wall3dad52d2019-03-22 14:03:19 -07003597 uncacheBuffer, listenerCallbacks, postTime, privileged);
Marissa Wall713b63f2018-10-17 15:42:43 -07003598}
3599
3600void SurfaceFlinger::applyTransactionState(const Vector<ComposerState>& states,
chaviw273171b2018-12-26 11:46:30 -08003601 const Vector<DisplayState>& displays, uint32_t flags,
Robert Carr14167e02019-02-13 13:50:55 -08003602 const InputWindowCommands& inputWindowCommands,
Marissa Wall78b72202019-03-15 14:58:34 -07003603 const int64_t desiredPresentTime,
Marissa Wall947d34e2019-03-29 14:03:53 -07003604 const client_cache_t& uncacheBuffer,
Marissa Wall3dad52d2019-03-22 14:03:19 -07003605 const std::vector<ListenerCallbacks>& listenerCallbacks,
Marissa Wall78b72202019-03-15 14:58:34 -07003606 const int64_t postTime, bool privileged,
3607 bool isMainThread) {
Marissa Wall713b63f2018-10-17 15:42:43 -07003608 uint32_t transactionFlags = 0;
3609
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003610 if (flags & eAnimation) {
3611 // For window updates that are part of an animation we must wait for
3612 // previous animation "frames" to be handled.
Valerie Hau38448362019-04-11 14:49:33 -07003613 while (!isMainThread && mAnimTransactionPending) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003614 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003615 if (CC_UNLIKELY(err != NO_ERROR)) {
3616 // just in case something goes wrong in SF, return to the
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003617 // caller after a few seconds.
3618 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out "
3619 "waiting for previous animation frame");
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003620 mAnimTransactionPending = false;
3621 break;
3622 }
3623 }
3624 }
3625
chaviwca27f252018-02-06 16:46:39 -08003626 for (const DisplayState& display : displays) {
3627 transactionFlags |= setDisplayStateLocked(display);
Jamie Gennisb8d69a52011-10-10 15:48:06 -07003628 }
3629
Marissa Walld600d572019-03-26 15:38:50 -07003630 // In case the client has sent a Transaction that should receive callbacks but without any
3631 // SurfaceControls that should be included in the callback, send the listener and callbackIds
3632 // to the callback thread so it can send an empty callback
3633 if (!listenerCallbacks.empty()) {
3634 mTransactionCompletedThread.run();
3635 }
3636 for (const auto& [listener, callbackIds] : listenerCallbacks) {
3637 mTransactionCompletedThread.addCallback(listener, callbackIds);
3638 }
3639
Marissa Walle2ffb422018-10-12 11:33:52 -07003640 uint32_t clientStateFlags = 0;
chaviwca27f252018-02-06 16:46:39 -08003641 for (const ComposerState& state : states) {
Marissa Wall3dad52d2019-03-22 14:03:19 -07003642 clientStateFlags |= setClientStateLocked(state, desiredPresentTime, listenerCallbacks,
3643 postTime, privileged);
3644 }
3645
Marissa Walle2ffb422018-10-12 11:33:52 -07003646 // If the state doesn't require a traversal and there are callbacks, send them now
Marissa Wallb0022cc2019-04-16 14:19:55 -07003647 if (!(clientStateFlags & eTraversalNeeded) && !listenerCallbacks.empty()) {
Marissa Walle2ffb422018-10-12 11:33:52 -07003648 mTransactionCompletedThread.sendCallbacks();
3649 }
3650 transactionFlags |= clientStateFlags;
chaviwca27f252018-02-06 16:46:39 -08003651
chaviw273171b2018-12-26 11:46:30 -08003652 transactionFlags |= addInputWindowCommands(inputWindowCommands);
3653
Marissa Wall947d34e2019-03-29 14:03:53 -07003654 if (uncacheBuffer.isValid()) {
3655 ClientCache::getInstance().erase(uncacheBuffer);
Marissa Wall78b72202019-03-15 14:58:34 -07003656 }
3657
Jorim Jaggibdcf09c2017-08-08 15:22:08 +02003658 // If a synchronous transaction is explicitly requested without any changes, force a transaction
3659 // anyway. This can be used as a flush mechanism for previous async transactions.
3660 // Empty animation transaction can be used to simulate back-pressure, so also force a
3661 // transaction for empty animation transactions.
3662 if (transactionFlags == 0 &&
3663 ((flags & eSynchronous) || (flags & eAnimation))) {
Robert Carr2a7dbb42016-05-24 11:41:28 -07003664 transactionFlags = eTransactionNeeded;
3665 }
3666
Marissa Wall06255332019-03-27 13:48:27 -07003667 // If we are on the main thread, we are about to preform a traversal. Clear the traversal bit
3668 // so we don't have to wake up again next frame to preform an uneeded traversal.
3669 if (isMainThread && (transactionFlags & eTraversalNeeded)) {
3670 transactionFlags = transactionFlags & (~eTraversalNeeded);
3671 mTraversalNeededMainThread = true;
3672 }
3673
Mathias Agopian386aa982011-11-07 21:58:03 -08003674 if (transactionFlags) {
Lloyd Pique4dccc412018-01-22 17:21:36 -08003675 if (mInterceptor->isEnabled()) {
3676 mInterceptor->saveTransaction(states, mCurrentState.displays, displays, flags);
Irvelffc9efc2016-07-27 15:16:37 -07003677 }
Irvel468051e2016-06-13 16:44:44 -07003678
Mathias Agopian386aa982011-11-07 21:58:03 -08003679 // this triggers the transaction
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003680 const auto start = (flags & eEarlyWakeup) ? Scheduler::TransactionStart::EARLY
3681 : Scheduler::TransactionStart::NORMAL;
Dan Stoza84d619e2018-03-28 17:07:36 -07003682 setTransactionFlags(transactionFlags, start);
Mathias Agopian386aa982011-11-07 21:58:03 -08003683
3684 // if this is a synchronous transaction, wait for it to take effect
3685 // before returning.
3686 if (flags & eSynchronous) {
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003687 mTransactionPending = true;
Mathias Agopian386aa982011-11-07 21:58:03 -08003688 }
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003689 if (flags & eAnimation) {
3690 mAnimTransactionPending = true;
3691 }
chaviw4fe36852019-04-15 16:25:49 -07003692 if (mPendingInputWindowCommands.syncInputWindows) {
3693 mPendingSyncInputWindows = true;
3694 }
Valerie Hau0779ded2019-03-19 12:43:04 -07003695
3696 // applyTransactionState can be called by either the main SF thread or by
3697 // another process through setTransactionState. While a given process may wish
3698 // to wait on synchronous transactions, the main SF thread should never
3699 // be blocked. Therefore, we only wait if isMainThread is false.
3700 while (!isMainThread && (mTransactionPending || mPendingSyncInputWindows)) {
Mathias Agopian386aa982011-11-07 21:58:03 -08003701 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
3702 if (CC_UNLIKELY(err != NO_ERROR)) {
3703 // just in case something goes wrong in SF, return to the
3704 // called after a few seconds.
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003705 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");
3706 mTransactionPending = false;
chaviw95ef3c42019-02-14 10:55:09 -08003707 mPendingSyncInputWindows = false;
Mathias Agopian386aa982011-11-07 21:58:03 -08003708 break;
3709 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -07003710 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003711 }
3712}
3713
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003714uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s) {
3715 const ssize_t index = mCurrentState.displays.indexOfKey(s.token);
3716 if (index < 0) return 0;
Jesse Hall9a143922012-10-04 16:29:19 -07003717
Mathias Agopiane57f2922012-08-09 16:29:12 -07003718 uint32_t flags = 0;
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003719 DisplayDeviceState& state = mCurrentState.displays.editValueAt(index);
3720
3721 const uint32_t what = s.what;
3722 if (what & DisplayState::eSurfaceChanged) {
3723 if (IInterface::asBinder(state.surface) != IInterface::asBinder(s.surface)) {
3724 state.surface = s.surface;
3725 flags |= eDisplayTransactionNeeded;
Michael Lentine47e45402014-07-18 15:34:25 -07003726 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07003727 }
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003728 if (what & DisplayState::eLayerStackChanged) {
3729 if (state.layerStack != s.layerStack) {
3730 state.layerStack = s.layerStack;
3731 flags |= eDisplayTransactionNeeded;
3732 }
3733 }
3734 if (what & DisplayState::eDisplayProjectionChanged) {
3735 if (state.orientation != s.orientation) {
3736 state.orientation = s.orientation;
3737 flags |= eDisplayTransactionNeeded;
3738 }
3739 if (state.frame != s.frame) {
3740 state.frame = s.frame;
3741 flags |= eDisplayTransactionNeeded;
3742 }
3743 if (state.viewport != s.viewport) {
3744 state.viewport = s.viewport;
3745 flags |= eDisplayTransactionNeeded;
3746 }
3747 }
3748 if (what & DisplayState::eDisplaySizeChanged) {
3749 if (state.width != s.width) {
3750 state.width = s.width;
3751 flags |= eDisplayTransactionNeeded;
3752 }
3753 if (state.height != s.height) {
3754 state.height = s.height;
3755 flags |= eDisplayTransactionNeeded;
3756 }
3757 }
3758
Mathias Agopiane57f2922012-08-09 16:29:12 -07003759 return flags;
3760}
3761
Robert Carr14167e02019-02-13 13:50:55 -08003762bool SurfaceFlinger::callingThreadHasUnscopedSurfaceFlingerAccess() {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003763 IPCThreadState* ipc = IPCThreadState::self();
3764 const int pid = ipc->getCallingPid();
3765 const int uid = ipc->getCallingUid();
Robert Carrd4ae7f32018-06-07 16:10:57 -07003766 if ((uid != AID_GRAPHICS && uid != AID_SYSTEM) &&
Ana Krulec13be8ad2018-08-21 02:43:56 +00003767 !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003768 return false;
3769 }
3770 return true;
3771}
3772
Marissa Wall3dad52d2019-03-22 14:03:19 -07003773uint32_t SurfaceFlinger::setClientStateLocked(
3774 const ComposerState& composerState, int64_t desiredPresentTime,
3775 const std::vector<ListenerCallbacks>& listenerCallbacks, int64_t postTime,
3776 bool privileged) {
chaviwca27f252018-02-06 16:46:39 -08003777 const layer_state_t& s = composerState.state;
3778 sp<Client> client(static_cast<Client*>(composerState.client.get()));
3779
Mathias Agopian13127d82013-03-05 17:47:11 -08003780 sp<Layer> layer(client->getLayerUser(s.surface));
chaviw8b3871a2017-11-01 17:41:01 -07003781 if (layer == nullptr) {
3782 return 0;
3783 }
3784
chaviw8b3871a2017-11-01 17:41:01 -07003785 uint32_t flags = 0;
3786
Garfield Tan8a3083e2018-12-03 13:21:07 -08003787 const uint64_t what = s.what;
chaviw8b3871a2017-11-01 17:41:01 -07003788 bool geometryAppliesWithResize =
3789 what & layer_state_t::eGeometryAppliesWithResize;
Jorim Jaggidba32732018-05-28 17:43:52 +02003790
3791 // If we are deferring transaction, make sure to push the pending state, as otherwise the
3792 // pending state will also be deferred.
Marissa Wallf58c14b2018-07-24 10:50:43 -07003793 if (what & layer_state_t::eDeferTransaction_legacy) {
Jorim Jaggidba32732018-05-28 17:43:52 +02003794 layer->pushPendingState();
3795 }
3796
chaviw8b3871a2017-11-01 17:41:01 -07003797 if (what & layer_state_t::ePositionChanged) {
3798 if (layer->setPosition(s.x, s.y, !geometryAppliesWithResize)) {
3799 flags |= eTraversalNeeded;
Mathias Agopiane57f2922012-08-09 16:29:12 -07003800 }
chaviw8b3871a2017-11-01 17:41:01 -07003801 }
3802 if (what & layer_state_t::eLayerChanged) {
3803 // NOTE: index needs to be calculated before we update the state
3804 const auto& p = layer->getParent();
3805 if (p == nullptr) {
chaviw64f7b422017-07-12 10:31:58 -07003806 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
chaviw8b3871a2017-11-01 17:41:01 -07003807 if (layer->setLayer(s.z) && idx >= 0) {
Mathias Agopiane57f2922012-08-09 16:29:12 -07003808 mCurrentState.layersSortedByZ.removeAt(idx);
3809 mCurrentState.layersSortedByZ.add(layer);
3810 // we need traversal (state changed)
3811 // AND transaction (list changed)
3812 flags |= eTransactionNeeded|eTraversalNeeded;
3813 }
chaviw8b3871a2017-11-01 17:41:01 -07003814 } else {
3815 if (p->setChildLayer(layer, s.z)) {
chaviw06178942017-07-27 10:25:59 -07003816 flags |= eTransactionNeeded|eTraversalNeeded;
3817 }
3818 }
chaviw8b3871a2017-11-01 17:41:01 -07003819 }
3820 if (what & layer_state_t::eRelativeLayerChanged) {
Robert Carr503c7042017-09-27 15:06:08 -07003821 // NOTE: index needs to be calculated before we update the state
3822 const auto& p = layer->getParent();
3823 if (p == nullptr) {
3824 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
3825 if (layer->setRelativeLayer(s.relativeLayerHandle, s.z) && idx >= 0) {
3826 mCurrentState.layersSortedByZ.removeAt(idx);
3827 mCurrentState.layersSortedByZ.add(layer);
3828 // we need traversal (state changed)
3829 // AND transaction (list changed)
3830 flags |= eTransactionNeeded|eTraversalNeeded;
3831 }
3832 } else {
3833 if (p->setChildRelativeLayer(layer, s.relativeLayerHandle, s.z)) {
3834 flags |= eTransactionNeeded|eTraversalNeeded;
3835 }
chaviw8b3871a2017-11-01 17:41:01 -07003836 }
3837 }
3838 if (what & layer_state_t::eSizeChanged) {
3839 if (layer->setSize(s.w, s.h)) {
3840 flags |= eTraversalNeeded;
3841 }
3842 }
3843 if (what & layer_state_t::eAlphaChanged) {
3844 if (layer->setAlpha(s.alpha))
3845 flags |= eTraversalNeeded;
3846 }
3847 if (what & layer_state_t::eColorChanged) {
3848 if (layer->setColor(s.color))
3849 flags |= eTraversalNeeded;
3850 }
Peiyong Lind3788632018-09-18 16:01:31 -07003851 if (what & layer_state_t::eColorTransformChanged) {
3852 if (layer->setColorTransform(s.colorTransform)) {
3853 flags |= eTraversalNeeded;
3854 }
3855 }
Valerie Haudd0b7572019-01-29 14:59:27 -08003856 if (what & layer_state_t::eBackgroundColorChanged) {
3857 if (layer->setBackgroundColor(s.color, s.bgColorAlpha, s.bgColorDataspace)) {
3858 flags |= eTraversalNeeded;
3859 }
3860 }
chaviw8b3871a2017-11-01 17:41:01 -07003861 if (what & layer_state_t::eMatrixChanged) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003862 // TODO: b/109894387
3863 //
3864 // SurfaceFlinger's renderer is not prepared to handle cropping in the face of arbitrary
3865 // rotation. To see the problem observe that if we have a square parent, and a child
3866 // of the same size, then we rotate the child 45 degrees around it's center, the child
3867 // must now be cropped to a non rectangular 8 sided region.
3868 //
3869 // Of course we can fix this in the future. For now, we are lucky, SurfaceControl is
3870 // private API, and the WindowManager only uses rotation in one case, which is on a top
3871 // level layer in which cropping is not an issue.
3872 //
3873 // However given that abuse of rotation matrices could lead to surfaces extending outside
3874 // of cropped areas, we need to prevent non-root clients without permission ACCESS_SURFACE_FLINGER
3875 // (a.k.a. everyone except WindowManager and tests) from setting non rectangle preserving
3876 // transformations.
Robert Carr14167e02019-02-13 13:50:55 -08003877 if (layer->setMatrix(s.matrix, privileged))
chaviw8b3871a2017-11-01 17:41:01 -07003878 flags |= eTraversalNeeded;
3879 }
3880 if (what & layer_state_t::eTransparentRegionChanged) {
3881 if (layer->setTransparentRegionHint(s.transparentRegion))
3882 flags |= eTraversalNeeded;
3883 }
3884 if (what & layer_state_t::eFlagsChanged) {
3885 if (layer->setFlags(s.flags, s.mask))
3886 flags |= eTraversalNeeded;
3887 }
Marissa Wallf58c14b2018-07-24 10:50:43 -07003888 if (what & layer_state_t::eCropChanged_legacy) {
3889 if (layer->setCrop_legacy(s.crop_legacy, !geometryAppliesWithResize))
chaviw8b3871a2017-11-01 17:41:01 -07003890 flags |= eTraversalNeeded;
3891 }
Lucas Dupin1b6531c2018-07-05 17:18:21 -07003892 if (what & layer_state_t::eCornerRadiusChanged) {
3893 if (layer->setCornerRadius(s.cornerRadius))
3894 flags |= eTraversalNeeded;
3895 }
chaviw8b3871a2017-11-01 17:41:01 -07003896 if (what & layer_state_t::eLayerStackChanged) {
3897 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
3898 // We only allow setting layer stacks for top level layers,
3899 // everything else inherits layer stack from its parent.
3900 if (layer->hasParent()) {
3901 ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
3902 layer->getName().string());
3903 } else if (idx < 0) {
3904 ALOGE("Attempt to set layer stack on layer without parent (%s) that "
3905 "that also does not appear in the top level layer list. Something"
3906 " has gone wrong.", layer->getName().string());
3907 } else if (layer->setLayerStack(s.layerStack)) {
3908 mCurrentState.layersSortedByZ.removeAt(idx);
3909 mCurrentState.layersSortedByZ.add(layer);
3910 // we need traversal (state changed)
3911 // AND transaction (list changed)
Lloyd Piqued432a7c2018-03-23 16:05:31 -07003912 flags |= eTransactionNeeded|eTraversalNeeded|eDisplayLayerStackChanged;
chaviw8b3871a2017-11-01 17:41:01 -07003913 }
3914 }
Marissa Wallf58c14b2018-07-24 10:50:43 -07003915 if (what & layer_state_t::eDeferTransaction_legacy) {
3916 if (s.barrierHandle_legacy != nullptr) {
3917 layer->deferTransactionUntil_legacy(s.barrierHandle_legacy, s.frameNumber_legacy);
3918 } else if (s.barrierGbp_legacy != nullptr) {
3919 const sp<IGraphicBufferProducer>& gbp = s.barrierGbp_legacy;
chaviw8b3871a2017-11-01 17:41:01 -07003920 if (authenticateSurfaceTextureLocked(gbp)) {
3921 const auto& otherLayer =
3922 (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
Marissa Wallf58c14b2018-07-24 10:50:43 -07003923 layer->deferTransactionUntil_legacy(otherLayer, s.frameNumber_legacy);
chaviw8b3871a2017-11-01 17:41:01 -07003924 } else {
3925 ALOGE("Attempt to defer transaction to to an"
3926 " unrecognized GraphicBufferProducer");
Robert Carr1db73f62016-12-21 12:58:51 -08003927 }
3928 }
chaviw8b3871a2017-11-01 17:41:01 -07003929 // We don't trigger a traversal here because if no other state is
3930 // changed, we don't want this to cause any more work
3931 }
3932 if (what & layer_state_t::eReparent) {
chaviw8ea97bb2017-11-29 10:05:15 -08003933 bool hadParent = layer->hasParent();
chaviw8b3871a2017-11-01 17:41:01 -07003934 if (layer->reparent(s.parentHandleForChild)) {
chaviw8ea97bb2017-11-29 10:05:15 -08003935 if (!hadParent) {
3936 mCurrentState.layersSortedByZ.remove(layer);
3937 }
chaviw8b3871a2017-11-01 17:41:01 -07003938 flags |= eTransactionNeeded|eTraversalNeeded;
Robert Carr9524cb32017-02-13 11:32:32 -08003939 }
chaviw8b3871a2017-11-01 17:41:01 -07003940 }
3941 if (what & layer_state_t::eReparentChildren) {
3942 if (layer->reparentChildren(s.reparentHandle)) {
3943 flags |= eTransactionNeeded|eTraversalNeeded;
Robert Carrc3574f72016-03-24 12:19:32 -07003944 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07003945 }
chaviw8b3871a2017-11-01 17:41:01 -07003946 if (what & layer_state_t::eDetachChildren) {
3947 layer->detachChildren();
3948 }
3949 if (what & layer_state_t::eOverrideScalingModeChanged) {
3950 layer->setOverrideScalingMode(s.overrideScalingMode);
3951 // We don't trigger a traversal here because if no other state is
3952 // changed, we don't want this to cause any more work
3953 }
Marissa Wall61c58622018-07-18 10:12:20 -07003954 if (what & layer_state_t::eTransformChanged) {
3955 if (layer->setTransform(s.transform)) flags |= eTraversalNeeded;
3956 }
3957 if (what & layer_state_t::eTransformToDisplayInverseChanged) {
3958 if (layer->setTransformToDisplayInverse(s.transformToDisplayInverse))
3959 flags |= eTraversalNeeded;
3960 }
3961 if (what & layer_state_t::eCropChanged) {
3962 if (layer->setCrop(s.crop)) flags |= eTraversalNeeded;
3963 }
Marissa Wall861616d2018-10-22 12:52:23 -07003964 if (what & layer_state_t::eFrameChanged) {
3965 if (layer->setFrame(s.frame)) flags |= eTraversalNeeded;
3966 }
Marissa Wall61c58622018-07-18 10:12:20 -07003967 if (what & layer_state_t::eAcquireFenceChanged) {
3968 if (layer->setAcquireFence(s.acquireFence)) flags |= eTraversalNeeded;
3969 }
3970 if (what & layer_state_t::eDataspaceChanged) {
3971 if (layer->setDataspace(s.dataspace)) flags |= eTraversalNeeded;
3972 }
3973 if (what & layer_state_t::eHdrMetadataChanged) {
3974 if (layer->setHdrMetadata(s.hdrMetadata)) flags |= eTraversalNeeded;
3975 }
3976 if (what & layer_state_t::eSurfaceDamageRegionChanged) {
3977 if (layer->setSurfaceDamageRegion(s.surfaceDamageRegion)) flags |= eTraversalNeeded;
3978 }
3979 if (what & layer_state_t::eApiChanged) {
3980 if (layer->setApi(s.api)) flags |= eTraversalNeeded;
3981 }
3982 if (what & layer_state_t::eSidebandStreamChanged) {
3983 if (layer->setSidebandStream(s.sidebandStream)) flags |= eTraversalNeeded;
3984 }
Robert Carr720e5062018-07-30 17:45:14 -07003985 if (what & layer_state_t::eInputInfoChanged) {
Vishnu Nairce5d0cc2019-02-28 14:38:41 -08003986 if (privileged) {
Robert Carr11ac2012019-01-22 09:05:25 -08003987 layer->setInputInfo(s.inputInfo);
3988 flags |= eTraversalNeeded;
3989 } else {
3990 ALOGE("Attempt to update InputWindowInfo without permission ACCESS_SURFACE_FLINGER");
3991 }
Robert Carr720e5062018-07-30 17:45:14 -07003992 }
Evan Rosky1f6d6d52018-12-06 10:47:26 -08003993 if (what & layer_state_t::eMetadataChanged) {
3994 if (layer->setMetadata(s.metadata)) flags |= eTraversalNeeded;
3995 }
Peiyong Linc502cb72019-03-01 15:00:23 -08003996 if (what & layer_state_t::eColorSpaceAgnosticChanged) {
3997 if (layer->setColorSpaceAgnostic(s.colorSpaceAgnostic)) {
3998 flags |= eTraversalNeeded;
3999 }
4000 }
Marissa Walle2ffb422018-10-12 11:33:52 -07004001 std::vector<sp<CallbackHandle>> callbackHandles;
Marissa Wall3dad52d2019-03-22 14:03:19 -07004002 if ((what & layer_state_t::eHasListenerCallbacksChanged) && (!listenerCallbacks.empty())) {
Marissa Wall3dad52d2019-03-22 14:03:19 -07004003 for (const auto& [listener, callbackIds] : listenerCallbacks) {
Marissa Walle2ffb422018-10-12 11:33:52 -07004004 callbackHandles.emplace_back(new CallbackHandle(listener, callbackIds, s.surface));
4005 }
4006 }
Marissa Wall78b72202019-03-15 14:58:34 -07004007 bool bufferChanged = what & layer_state_t::eBufferChanged;
4008 bool cacheIdChanged = what & layer_state_t::eCachedBufferChanged;
4009 sp<GraphicBuffer> buffer;
4010 if (bufferChanged && cacheIdChanged) {
Marissa Wall947d34e2019-03-29 14:03:53 -07004011 ClientCache::getInstance().add(s.cachedBuffer, s.buffer);
Marissa Wall78b72202019-03-15 14:58:34 -07004012 buffer = s.buffer;
4013 } else if (cacheIdChanged) {
Marissa Wall947d34e2019-03-29 14:03:53 -07004014 buffer = ClientCache::getInstance().get(s.cachedBuffer);
Marissa Wall78b72202019-03-15 14:58:34 -07004015 } else if (bufferChanged) {
4016 buffer = s.buffer;
Marissa Wall73411622019-01-25 10:45:41 -08004017 }
Marissa Wall78b72202019-03-15 14:58:34 -07004018 if (buffer) {
Marissa Wall947d34e2019-03-29 14:03:53 -07004019 if (layer->setBuffer(buffer, postTime, desiredPresentTime, s.cachedBuffer)) {
Valerie Haubc6ddb12019-03-08 11:10:15 -08004020 flags |= eTraversalNeeded;
Valerie Haubc6ddb12019-03-08 11:10:15 -08004021 }
Marissa Wallebc2c052019-01-16 19:16:55 -08004022 }
Marissa Walle2ffb422018-10-12 11:33:52 -07004023 if (layer->setTransactionCompletedListeners(callbackHandles)) flags |= eTraversalNeeded;
4024 // Do not put anything that updates layer state or modifies flags after
4025 // setTransactionCompletedListener
Mathias Agopiane57f2922012-08-09 16:29:12 -07004026 return flags;
4027}
4028
chaviw273171b2018-12-26 11:46:30 -08004029uint32_t SurfaceFlinger::addInputWindowCommands(const InputWindowCommands& inputWindowCommands) {
4030 uint32_t flags = 0;
4031 if (!inputWindowCommands.transferTouchFocusCommands.empty()) {
4032 flags |= eTraversalNeeded;
4033 }
4034
chaviwa911b102019-02-14 10:18:33 -08004035 if (inputWindowCommands.syncInputWindows) {
4036 flags |= eTraversalNeeded;
4037 }
4038
Vishnu Nairec0ab382019-02-13 15:32:56 -08004039 mPendingInputWindowCommands.merge(inputWindowCommands);
chaviw273171b2018-12-26 11:46:30 -08004040 return flags;
4041}
4042
Marissa Wall2d814fb2019-04-09 18:52:57 +00004043status_t SurfaceFlinger::createLayer(const String8& name, const sp<Client>& client, uint32_t w,
4044 uint32_t h, PixelFormat format, uint32_t flags,
4045 LayerMetadata metadata, sp<IBinder>* handle,
Robert Carrc0df3122019-04-11 13:18:21 -07004046 sp<IGraphicBufferProducer>* gbp,
4047 const sp<IBinder>& parentHandle,
4048 const sp<Layer>& parentLayer) {
Mathias Agopian6e2d6482009-07-09 18:16:43 -07004049 if (int32_t(w|h) < 0) {
Mathias Agopian921e6ac2012-07-23 23:11:29 -07004050 ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
Mathias Agopian6e2d6482009-07-09 18:16:43 -07004051 int(w), int(h));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004052 return BAD_VALUE;
Mathias Agopian6e2d6482009-07-09 18:16:43 -07004053 }
Andreas Huber8b42e8a2010-08-16 08:49:37 -07004054
Robert Carrc0df3122019-04-11 13:18:21 -07004055 ALOG_ASSERT(parentLayer == nullptr || parentHandle == nullptr,
4056 "Expected only one of parentLayer or parentHandle to be non-null. "
4057 "Programmer error?");
4058
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004059 status_t result = NO_ERROR;
4060
4061 sp<Layer> layer;
4062
Cody Northropbc755282017-03-31 12:00:08 -06004063 String8 uniqueName = getUniqueLayerName(name);
4064
Evan Roskya1f1e152019-01-24 16:17:46 -08004065 bool primaryDisplayOnly = false;
4066
4067 // window type is WINDOW_TYPE_DONT_SCREENSHOT from SurfaceControl.java
4068 // TODO b/64227542
4069 if (metadata.has(METADATA_WINDOW_TYPE)) {
4070 int32_t windowType = metadata.getInt32(METADATA_WINDOW_TYPE, 0);
4071 if (windowType == 441731) {
Ady Abraham8f1ee7f2019-04-05 10:32:50 -07004072 metadata.setInt32(METADATA_WINDOW_TYPE, InputWindowInfo::TYPE_NAVIGATION_BAR_PANEL);
Evan Roskya1f1e152019-01-24 16:17:46 -08004073 primaryDisplayOnly = true;
4074 }
4075 }
4076
Mathias Agopian3165cc22012-08-08 19:42:09 -07004077 switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
Marissa Wall61c58622018-07-18 10:12:20 -07004078 case ISurfaceComposerClient::eFXSurfaceBufferQueue:
Evan Roskya1f1e152019-01-24 16:17:46 -08004079 result = createBufferQueueLayer(client, uniqueName, w, h, flags, std::move(metadata),
4080 format, handle, gbp, &layer);
David Sodman0c69cad2017-08-21 12:12:51 -07004081
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004082 break;
Marissa Wall61c58622018-07-18 10:12:20 -07004083 case ISurfaceComposerClient::eFXSurfaceBufferState:
Evan Roskya1f1e152019-01-24 16:17:46 -08004084 result = createBufferStateLayer(client, uniqueName, w, h, flags, std::move(metadata),
4085 handle, &layer);
Marissa Wall61c58622018-07-18 10:12:20 -07004086 break;
chaviw13fdc492017-06-27 12:40:18 -07004087 case ISurfaceComposerClient::eFXSurfaceColor:
Vishnu Nair88a11f22018-11-28 18:30:57 -08004088 // check if buffer size is set for color layer.
4089 if (w > 0 || h > 0) {
4090 ALOGE("createLayer() failed, w or h cannot be set for color layer (w=%d, h=%d)",
4091 int(w), int(h));
4092 return BAD_VALUE;
4093 }
4094
Evan Roskya1f1e152019-01-24 16:17:46 -08004095 result = createColorLayer(client, uniqueName, w, h, flags, std::move(metadata), handle,
4096 &layer);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004097 break;
Robert Carr6b3f6c52018-08-13 13:05:17 -07004098 case ISurfaceComposerClient::eFXSurfaceContainer:
Vishnu Nair88a11f22018-11-28 18:30:57 -08004099 // check if buffer size is set for container layer.
4100 if (w > 0 || h > 0) {
4101 ALOGE("createLayer() failed, w or h cannot be set for container layer (w=%d, h=%d)",
4102 int(w), int(h));
4103 return BAD_VALUE;
4104 }
Evan Roskya1f1e152019-01-24 16:17:46 -08004105 result = createContainerLayer(client, uniqueName, w, h, flags, std::move(metadata),
4106 handle, &layer);
Robert Carr6b3f6c52018-08-13 13:05:17 -07004107 break;
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004108 default:
4109 result = BAD_VALUE;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004110 break;
4111 }
4112
Dan Stoza7d89d062015-04-30 13:29:25 -07004113 if (result != NO_ERROR) {
4114 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004115 }
Dan Stoza7d89d062015-04-30 13:29:25 -07004116
Evan Roskya1f1e152019-01-24 16:17:46 -08004117 if (primaryDisplayOnly) {
4118 layer->setPrimaryDisplayOnly();
Chia-I Wuab0c3192017-08-01 11:29:00 -07004119 }
4120
Robert Carrb89ea9d2018-12-10 13:01:14 -08004121 bool addToCurrentState = callingThreadHasUnscopedSurfaceFlingerAccess();
Robert Carrc0df3122019-04-11 13:18:21 -07004122 result = addClientLayer(client, *handle, *gbp, layer, parentHandle, parentLayer,
4123 addToCurrentState);
Dan Stoza7d89d062015-04-30 13:29:25 -07004124 if (result != NO_ERROR) {
4125 return result;
4126 }
Lloyd Pique4dccc412018-01-22 17:21:36 -08004127 mInterceptor->saveSurfaceCreation(layer);
Dan Stoza7d89d062015-04-30 13:29:25 -07004128
4129 setTransactionFlags(eTransactionNeeded);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004130 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004131}
4132
Cody Northropbc755282017-03-31 12:00:08 -06004133String8 SurfaceFlinger::getUniqueLayerName(const String8& name)
4134{
4135 bool matchFound = true;
4136 uint32_t dupeCounter = 0;
4137
4138 // Tack on our counter whether there is a hit or not, so everyone gets a tag
4139 String8 uniqueName = name + "#" + String8(std::to_string(dupeCounter).c_str());
4140
Dan Stoza436ccf32018-06-21 12:10:12 -07004141 // Grab the state lock since we're accessing mCurrentState
4142 Mutex::Autolock lock(mStateLock);
4143
Cody Northropbc755282017-03-31 12:00:08 -06004144 // Loop over layers until we're sure there is no matching name
4145 while (matchFound) {
4146 matchFound = false;
Dan Stoza436ccf32018-06-21 12:10:12 -07004147 mCurrentState.traverseInZOrder([&](Layer* layer) {
Cody Northropbc755282017-03-31 12:00:08 -06004148 if (layer->getName() == uniqueName) {
4149 matchFound = true;
4150 uniqueName = name + "#" + String8(std::to_string(++dupeCounter).c_str());
4151 }
4152 });
4153 }
4154
Marissa Wallf1de4bd2018-05-22 13:05:01 -07004155 ALOGV_IF(dupeCounter > 0, "duplicate layer name: changing %s to %s", name.c_str(),
4156 uniqueName.c_str());
Cody Northropbc755282017-03-31 12:00:08 -06004157
4158 return uniqueName;
4159}
4160
Marissa Wallfd668622018-05-10 10:21:13 -07004161status_t SurfaceFlinger::createBufferQueueLayer(const sp<Client>& client, const String8& name,
4162 uint32_t w, uint32_t h, uint32_t flags,
Evan Roskya1f1e152019-01-24 16:17:46 -08004163 LayerMetadata metadata, PixelFormat& format,
4164 sp<IBinder>* handle,
Marissa Wallfd668622018-05-10 10:21:13 -07004165 sp<IGraphicBufferProducer>* gbp,
4166 sp<Layer>* outLayer) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004167 // initialize the surfaces
Mathias Agopian92a979a2012-08-02 18:32:23 -07004168 switch (format) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004169 case PIXEL_FORMAT_TRANSPARENT:
4170 case PIXEL_FORMAT_TRANSLUCENT:
4171 format = PIXEL_FORMAT_RGBA_8888;
4172 break;
4173 case PIXEL_FORMAT_OPAQUE:
Mathias Agopian8f105402010-04-05 18:01:24 -07004174 format = PIXEL_FORMAT_RGBX_8888;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004175 break;
4176 }
4177
Evan Roskya1f1e152019-01-24 16:17:46 -08004178 sp<BufferQueueLayer> layer = getFactory().createBufferQueueLayer(
4179 LayerCreationArgs(this, client, name, w, h, flags, std::move(metadata)));
Marissa Wallfd668622018-05-10 10:21:13 -07004180 status_t err = layer->setDefaultBufferProperties(w, h, format);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004181 if (err == NO_ERROR) {
David Sodman0c69cad2017-08-21 12:12:51 -07004182 *handle = layer->getHandle();
4183 *gbp = layer->getProducer();
4184 *outLayer = layer;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004185 }
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004186
Marissa Wallfd668622018-05-10 10:21:13 -07004187 ALOGE_IF(err, "createBufferQueueLayer() failed (%s)", strerror(-err));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004188 return err;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004189}
4190
Marissa Wall61c58622018-07-18 10:12:20 -07004191status_t SurfaceFlinger::createBufferStateLayer(const sp<Client>& client, const String8& name,
4192 uint32_t w, uint32_t h, uint32_t flags,
Evan Roskya1f1e152019-01-24 16:17:46 -08004193 LayerMetadata metadata, sp<IBinder>* handle,
4194 sp<Layer>* outLayer) {
4195 sp<BufferStateLayer> layer = getFactory().createBufferStateLayer(
4196 LayerCreationArgs(this, client, name, w, h, flags, std::move(metadata)));
Marissa Wall61c58622018-07-18 10:12:20 -07004197 *handle = layer->getHandle();
4198 *outLayer = layer;
4199
4200 return NO_ERROR;
4201}
4202
Evan Roskya1f1e152019-01-24 16:17:46 -08004203status_t SurfaceFlinger::createColorLayer(const sp<Client>& client, const String8& name, uint32_t w,
4204 uint32_t h, uint32_t flags, LayerMetadata metadata,
4205 sp<IBinder>* handle, sp<Layer>* outLayer) {
4206 *outLayer = getFactory().createColorLayer(
4207 LayerCreationArgs(this, client, name, w, h, flags, std::move(metadata)));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004208 *handle = (*outLayer)->getHandle();
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004209 return NO_ERROR;
Mathias Agopian118d0242011-10-13 16:02:48 -07004210}
4211
Evan Roskya1f1e152019-01-24 16:17:46 -08004212status_t SurfaceFlinger::createContainerLayer(const sp<Client>& client, const String8& name,
4213 uint32_t w, uint32_t h, uint32_t flags,
4214 LayerMetadata metadata, sp<IBinder>* handle,
4215 sp<Layer>* outLayer) {
4216 *outLayer = getFactory().createContainerLayer(
4217 LayerCreationArgs(this, client, name, w, h, flags, std::move(metadata)));
Robert Carr6b3f6c52018-08-13 13:05:17 -07004218 *handle = (*outLayer)->getHandle();
4219 return NO_ERROR;
4220}
4221
4222
Robert Carr6fb1a7e2018-12-11 12:07:25 -08004223void SurfaceFlinger::markLayerPendingRemovalLocked(const sp<Layer>& layer) {
Robert Carr2e102c92018-10-23 12:11:15 -07004224 mLayersPendingRemoval.add(layer);
4225 mLayersRemoved = true;
4226 setTransactionFlags(eTransactionNeeded);
4227}
4228
Robert Carr695d5282018-12-18 15:27:58 -08004229void SurfaceFlinger::onHandleDestroyed(sp<Layer>& layer)
Rob Carr4bba3702018-10-08 21:53:30 +00004230{
Robert Carr2e102c92018-10-23 12:11:15 -07004231 Mutex::Autolock lock(mStateLock);
Robert Carr6fb1a7e2018-12-11 12:07:25 -08004232 // If a layer has a parent, we allow it to out-live it's handle
4233 // with the idea that the parent holds a reference and will eventually
4234 // be cleaned up. However no one cleans up the top-level so we do so
4235 // here.
4236 if (layer->getParent() == nullptr) {
4237 mCurrentState.layersSortedByZ.remove(layer);
4238 }
4239 markLayerPendingRemovalLocked(layer);
Robert Carrc0df3122019-04-11 13:18:21 -07004240
4241 auto it = mLayersByLocalBinderToken.begin();
4242 while (it != mLayersByLocalBinderToken.end()) {
4243 if (it->second == layer) {
4244 it = mLayersByLocalBinderToken.erase(it);
4245 } else {
4246 it++;
4247 }
4248 }
4249
Robert Carr695d5282018-12-18 15:27:58 -08004250 layer.clear();
Rob Carr4bba3702018-10-08 21:53:30 +00004251}
4252
Mathias Agopianb60314a2012-04-10 22:09:54 -07004253// ---------------------------------------------------------------------------
4254
Andy McFadden13a082e2012-08-24 10:16:42 -07004255void SurfaceFlinger::onInitializeDisplays() {
Dominik Laskowski83b88212018-12-11 13:34:06 -08004256 const auto display = getDefaultDisplayDeviceLocked();
4257 if (!display) return;
4258
4259 const sp<IBinder> token = display->getDisplayToken().promote();
4260 LOG_ALWAYS_FATAL_IF(token == nullptr);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004261
Jesse Hall01e29052013-02-19 16:13:35 -08004262 // reset screen orientation and use primary layer stack
Andy McFadden13a082e2012-08-24 10:16:42 -07004263 Vector<ComposerState> state;
4264 Vector<DisplayState> displays;
4265 DisplayState d;
Jesse Hall01e29052013-02-19 16:13:35 -08004266 d.what = DisplayState::eDisplayProjectionChanged |
4267 DisplayState::eLayerStackChanged;
Dominik Laskowski83b88212018-12-11 13:34:06 -08004268 d.token = token;
Jesse Hall01e29052013-02-19 16:13:35 -08004269 d.layerStack = 0;
Andy McFadden13a082e2012-08-24 10:16:42 -07004270 d.orientation = DisplayState::eOrientationDefault;
Jeff Brown4c05dd12012-09-09 00:07:17 -07004271 d.frame.makeInvalid();
4272 d.viewport.makeInvalid();
Michael Lentine47e45402014-07-18 15:34:25 -07004273 d.width = 0;
4274 d.height = 0;
Andy McFadden13a082e2012-08-24 10:16:42 -07004275 displays.add(d);
Marissa Wall3dad52d2019-03-22 14:03:19 -07004276 setTransactionState(state, displays, 0, nullptr, mPendingInputWindowCommands, -1, {}, {});
Jamie Gennis6547ff42013-07-16 20:12:42 -07004277
Dominik Laskowskie9774092018-12-11 10:04:24 -08004278 setPowerModeInternal(display, HWC_POWER_MODE_NORMAL);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004279
Dominik Laskowski83b88212018-12-11 13:34:06 -08004280 const nsecs_t vsyncPeriod = getVsyncPeriod();
4281 mAnimFrameTracker.setDisplayRefreshPeriod(vsyncPeriod);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08004282
Brian Andersond0010582017-03-07 13:20:31 -08004283 // Use phase of 0 since phase is not known.
4284 // Use latency of 0, which will snap to the ideal latency.
Dominik Laskowski83b88212018-12-11 13:34:06 -08004285 DisplayStatInfo stats{0 /* vsyncTime */, vsyncPeriod};
Ana Krulece588e312018-09-18 12:32:24 -07004286 setCompositorTimingSnapped(stats, 0);
Andy McFadden13a082e2012-08-24 10:16:42 -07004287}
4288
4289void SurfaceFlinger::initializeDisplays() {
Dominik Laskowski8c001672018-05-30 16:52:06 -07004290 // Async since we may be called from the main thread.
Dominik Laskowski83b88212018-12-11 13:34:06 -08004291 postMessageAsync(
4292 new LambdaMessage([this]() NO_THREAD_SAFETY_ANALYSIS { onInitializeDisplays(); }));
Andy McFadden13a082e2012-08-24 10:16:42 -07004293}
4294
Dominik Laskowskie9774092018-12-11 10:04:24 -08004295void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& display, int mode) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004296 if (display->isVirtual()) {
4297 ALOGE("%s: Invalid operation on virtual display", __FUNCTION__);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004298 return;
4299 }
4300
Dominik Laskowski075d3172018-05-24 15:50:06 -07004301 const auto displayId = display->getId();
4302 LOG_ALWAYS_FATAL_IF(!displayId);
4303
Dominik Laskowski34157762018-10-31 13:07:19 -07004304 ALOGD("Setting power mode %d on display %s", mode, to_string(*displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004305
4306 int currentMode = display->getPowerMode();
4307 if (mode == currentMode) {
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004308 return;
4309 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004310
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004311 display->setPowerMode(mode);
4312
Lloyd Pique4dccc412018-01-22 17:21:36 -08004313 if (mInterceptor->isEnabled()) {
Dominik Laskowskie9774092018-12-11 10:04:24 -08004314 mInterceptor->savePowerModeUpdate(display->getSequenceId(), mode);
Irvelffc9efc2016-07-27 15:16:37 -07004315 }
4316
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004317 if (currentMode == HWC_POWER_MODE_OFF) {
Tim Murrayf9d4e442016-08-02 15:43:59 -07004318 // Turn on the display
Dominik Laskowski075d3172018-05-24 15:50:06 -07004319 getHwComposer().setPowerMode(*displayId, mode);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004320 if (display->isPrimary() && mode != HWC_POWER_MODE_DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08004321 mScheduler->onScreenAcquired(mAppConnectionHandle);
4322 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004323 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004324
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004325 mVisibleRegionsDirty = true;
Dan Stozab90cf072015-03-05 11:05:59 -08004326 mHasPoweredOff = true;
Dan Stozac7a25ad2018-04-12 11:45:09 -07004327 repaintEverything();
Tim Murrayf9d4e442016-08-02 15:43:59 -07004328
4329 struct sched_param param = {0};
4330 param.sched_priority = 1;
4331 if (sched_setscheduler(0, SCHED_FIFO, &param) != 0) {
4332 ALOGW("Couldn't set SCHED_FIFO on display on");
4333 }
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004334 } else if (mode == HWC_POWER_MODE_OFF) {
Tim Murrayf9d4e442016-08-02 15:43:59 -07004335 // Turn off the display
4336 struct sched_param param = {0};
4337 if (sched_setscheduler(0, SCHED_OTHER, &param) != 0) {
4338 ALOGW("Couldn't set SCHED_OTHER on display off");
4339 }
4340
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004341 if (display->isPrimary() && currentMode != HWC_POWER_MODE_DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08004342 mScheduler->disableHardwareVsync(true);
4343 mScheduler->onScreenReleased(mAppConnectionHandle);
Mathias Agopiancde87a32012-09-13 14:09:01 -07004344 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004345
Dominik Laskowski075d3172018-05-24 15:50:06 -07004346 getHwComposer().setPowerMode(*displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004347 mVisibleRegionsDirty = true;
4348 // from this point on, SF will stop drawing on this display
Matthew Bouyack38d49612017-05-12 12:49:32 -07004349 } else if (mode == HWC_POWER_MODE_DOZE ||
4350 mode == HWC_POWER_MODE_NORMAL) {
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004351 // Update display while dozing
Dominik Laskowski075d3172018-05-24 15:50:06 -07004352 getHwComposer().setPowerMode(*displayId, mode);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004353 if (display->isPrimary() && currentMode == HWC_POWER_MODE_DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08004354 mScheduler->onScreenAcquired(mAppConnectionHandle);
4355 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004356 }
4357 } else if (mode == HWC_POWER_MODE_DOZE_SUSPEND) {
4358 // Leave display going to doze
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004359 if (display->isPrimary()) {
Ana Krulecc2870422019-01-29 19:00:58 -08004360 mScheduler->disableHardwareVsync(true);
4361 mScheduler->onScreenReleased(mAppConnectionHandle);
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004362 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07004363 getHwComposer().setPowerMode(*displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004364 } else {
Matthew Bouyack38d49612017-05-12 12:49:32 -07004365 ALOGE("Attempting to set unknown power mode: %d\n", mode);
Dominik Laskowski075d3172018-05-24 15:50:06 -07004366 getHwComposer().setPowerMode(*displayId, mode);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004367 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004368
Yiwei Zhang3a226d22018-10-16 09:23:03 -07004369 if (display->isPrimary()) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08004370 mTimeStats->setPowerMode(mode);
Dominik Laskowski22488f62019-03-28 09:53:04 -07004371 mRefreshRateStats.setPowerMode(mode);
Yiwei Zhang3a226d22018-10-16 09:23:03 -07004372 }
4373
Dominik Laskowski34157762018-10-31 13:07:19 -07004374 ALOGD("Finished setting power mode %d on display %s", mode, to_string(*displayId).c_str());
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004375}
4376
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004377void SurfaceFlinger::setPowerMode(const sp<IBinder>& displayToken, int mode) {
Dominik Laskowski83b88212018-12-11 13:34:06 -08004378 postMessageSync(new LambdaMessage([&]() NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004379 const auto display = getDisplayDevice(displayToken);
4380 if (!display) {
4381 ALOGE("Attempt to set power mode %d for invalid display token %p", mode,
4382 displayToken.get());
4383 } else if (display->isVirtual()) {
4384 ALOGW("Attempt to set power mode %d for virtual display", mode);
4385 } else {
Dominik Laskowskie9774092018-12-11 10:04:24 -08004386 setPowerModeInternal(display, mode);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004387 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004388 }));
Mathias Agopianb60314a2012-04-10 22:09:54 -07004389}
4390
4391// ---------------------------------------------------------------------------
4392
Dominik Laskowskic2867142019-01-21 11:33:38 -08004393status_t SurfaceFlinger::doDump(int fd, const DumpArgs& args,
4394 bool asProto) NO_THREAD_SAFETY_ANALYSIS {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004395 std::string result;
Mathias Agopian99b49842011-06-27 16:05:52 -07004396
Mathias Agopianbd115332013-04-18 16:41:04 -07004397 IPCThreadState* ipc = IPCThreadState::self();
4398 const int pid = ipc->getCallingPid();
4399 const int uid = ipc->getCallingUid();
Vishnu Nair6a408532017-10-24 09:11:27 -07004400
Mathias Agopianbd115332013-04-18 16:41:04 -07004401 if ((uid != AID_SHELL) &&
4402 !PermissionCache::checkPermission(sDump, pid, uid)) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004403 StringAppendF(&result, "Permission Denial: can't dump SurfaceFlinger from pid=%d, uid=%d\n",
4404 pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004405 } else {
Jesse Hallfcd15b42014-12-23 13:57:23 -08004406 // Try to get the main lock, but give up after one second
Mathias Agopian9795c422009-08-26 16:36:26 -07004407 // (this would indicate SF is stuck, but we want to be able to
4408 // print something in dumpsys).
Jesse Hallfcd15b42014-12-23 13:57:23 -08004409 status_t err = mStateLock.timedLock(s2ns(1));
4410 bool locked = (err == NO_ERROR);
Mathias Agopian9795c422009-08-26 16:36:26 -07004411 if (!locked) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004412 StringAppendF(&result,
4413 "SurfaceFlinger appears to be unresponsive (%s [%d]), dumping anyways "
4414 "(no locks held)\n",
4415 strerror(-err), err);
Mathias Agopian9795c422009-08-26 16:36:26 -07004416 }
4417
Dominik Laskowskic2867142019-01-21 11:33:38 -08004418 using namespace std::string_literals;
chaviwa3d7bd32017-11-03 09:41:53 -07004419
Dominik Laskowskic2867142019-01-21 11:33:38 -08004420 static const std::unordered_map<std::string, Dumper> dumpers = {
4421 {"--clear-layer-stats"s, dumper([this](std::string&) { mLayerStats.clear(); })},
4422 {"--disable-layer-stats"s, dumper([this](std::string&) { mLayerStats.disable(); })},
4423 {"--display-id"s, dumper(&SurfaceFlinger::dumpDisplayIdentificationData)},
Ady Abraham3aff9172019-02-07 19:10:26 -08004424 {"--dispsync"s, dumper([this](std::string& s) {
Ady Abraham3aff9172019-02-07 19:10:26 -08004425 mScheduler->dumpPrimaryDispSync(s);
Ady Abraham3aff9172019-02-07 19:10:26 -08004426 })},
Dominik Laskowskic2867142019-01-21 11:33:38 -08004427 {"--dump-layer-stats"s, dumper([this](std::string& s) { mLayerStats.dump(s); })},
4428 {"--enable-layer-stats"s, dumper([this](std::string&) { mLayerStats.enable(); })},
Dominik Laskowskic2867142019-01-21 11:33:38 -08004429 {"--frame-events"s, dumper(&SurfaceFlinger::dumpFrameEventsLocked)},
4430 {"--latency"s, argsDumper(&SurfaceFlinger::dumpStatsLocked)},
4431 {"--latency-clear"s, argsDumper(&SurfaceFlinger::clearStatsLocked)},
4432 {"--list"s, dumper(&SurfaceFlinger::listLayersLocked)},
4433 {"--static-screen"s, dumper(&SurfaceFlinger::dumpStaticScreenStats)},
4434 {"--timestats"s, protoDumper(&SurfaceFlinger::dumpTimeStats)},
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004435 {"--vsync"s, dumper(&SurfaceFlinger::dumpVSync)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08004436 {"--wide-color"s, dumper(&SurfaceFlinger::dumpWideColorInfo)},
4437 };
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004438
Dominik Laskowskic2867142019-01-21 11:33:38 -08004439 const auto flag = args.empty() ? ""s : std::string(String8(args[0]));
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004440
Dominik Laskowskic2867142019-01-21 11:33:38 -08004441 if (const auto it = dumpers.find(flag); it != dumpers.end()) {
4442 (it->second)(args, asProto, result);
4443 } else {
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07004444 if (asProto) {
4445 LayersProto layersProto = dumpProtoInfo(LayerVector::StateSet::Current);
4446 result.append(layersProto.SerializeAsString().c_str(), layersProto.ByteSize());
4447 } else {
Dominik Laskowskic2867142019-01-21 11:33:38 -08004448 dumpAllLocked(args, result);
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07004449 }
Mathias Agopian48b888a2011-01-19 16:15:53 -08004450 }
4451
Mathias Agopian9795c422009-08-26 16:36:26 -07004452 if (locked) {
4453 mStateLock.unlock();
4454 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004455 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08004456 write(fd, result.c_str(), result.size());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004457 return NO_ERROR;
4458}
4459
Nataniel Borges8e7dc722019-02-28 15:10:28 -08004460status_t SurfaceFlinger::dumpCritical(int fd, const DumpArgs&, bool asProto) {
4461 if (asProto && mTracing.isEnabled()) {
4462 mTracing.writeToFileAsync();
4463 }
4464
4465 return doDump(fd, DumpArgs(), asProto);
4466}
4467
Dominik Laskowskic2867142019-01-21 11:33:38 -08004468void SurfaceFlinger::listLayersLocked(std::string& result) const {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004469 mCurrentState.traverseInZOrder(
4470 [&](Layer* layer) { StringAppendF(&result, "%s\n", layer->getName().string()); });
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004471}
4472
Dominik Laskowskic2867142019-01-21 11:33:38 -08004473void SurfaceFlinger::dumpStatsLocked(const DumpArgs& args, std::string& result) const {
Dominik Laskowski83b88212018-12-11 13:34:06 -08004474 StringAppendF(&result, "%" PRId64 "\n", getVsyncPeriod());
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004475
Dominik Laskowskic2867142019-01-21 11:33:38 -08004476 if (args.size() > 1) {
4477 const auto name = String8(args[1]);
Robert Carr2047fae2016-11-28 14:09:09 -08004478 mCurrentState.traverseInZOrder([&](Layer* layer) {
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004479 if (name == layer->getName()) {
Svetoslavd85084b2014-03-20 10:28:31 -07004480 layer->dumpFrameStats(result);
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004481 }
Robert Carr2047fae2016-11-28 14:09:09 -08004482 });
Dominik Laskowskic2867142019-01-21 11:33:38 -08004483 } else {
4484 mAnimFrameTracker.dumpStats(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004485 }
4486}
4487
Dominik Laskowskic2867142019-01-21 11:33:38 -08004488void SurfaceFlinger::clearStatsLocked(const DumpArgs& args, std::string&) {
Robert Carr2047fae2016-11-28 14:09:09 -08004489 mCurrentState.traverseInZOrder([&](Layer* layer) {
Dominik Laskowskic2867142019-01-21 11:33:38 -08004490 if (args.size() < 2 || String8(args[1]) == layer->getName()) {
Svetoslavd85084b2014-03-20 10:28:31 -07004491 layer->clearFrameStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004492 }
Robert Carr2047fae2016-11-28 14:09:09 -08004493 });
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004494
Svetoslavd85084b2014-03-20 10:28:31 -07004495 mAnimFrameTracker.clearStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004496}
4497
Dominik Laskowskic2867142019-01-21 11:33:38 -08004498void SurfaceFlinger::dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const {
4499 mTimeStats->parseArgs(asProto, args, result);
4500}
4501
Jamie Gennis6547ff42013-07-16 20:12:42 -07004502// This should only be called from the main thread. Otherwise it would need
4503// the lock and should use mCurrentState rather than mDrawingState.
4504void SurfaceFlinger::logFrameStats() {
Robert Carr2047fae2016-11-28 14:09:09 -08004505 mDrawingState.traverseInZOrder([&](Layer* layer) {
Jamie Gennis6547ff42013-07-16 20:12:42 -07004506 layer->logFrameStats();
Robert Carr2047fae2016-11-28 14:09:09 -08004507 });
Jamie Gennis6547ff42013-07-16 20:12:42 -07004508
4509 mAnimFrameTracker.logAndResetStats(String8("<win-anim>"));
4510}
4511
Yiwei Zhang5434a782018-12-05 18:06:32 -08004512void SurfaceFlinger::appendSfConfigString(std::string& result) const {
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004513 result.append(" [sf");
Fabien Sanglardc93afd52017-03-13 13:02:42 -07004514
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004515 if (isLayerTripleBufferingDisabled())
4516 result.append(" DISABLE_TRIPLE_BUFFERING");
Fabien Sanglardc45a7d92017-03-14 13:24:22 -07004517
Yiwei Zhang5434a782018-12-05 18:06:32 -08004518 StringAppendF(&result, " PRESENT_TIME_OFFSET=%" PRId64, dispSyncPresentTimeOffset);
4519 StringAppendF(&result, " FORCE_HWC_FOR_RBG_TO_YUV=%d", useHwcForRgbToYuv);
4520 StringAppendF(&result, " MAX_VIRT_DISPLAY_DIM=%" PRIu64, maxVirtualDisplaySize);
4521 StringAppendF(&result, " RUNNING_WITHOUT_SYNC_FRAMEWORK=%d", !hasSyncFramework);
4522 StringAppendF(&result, " NUM_FRAMEBUFFER_SURFACE_BUFFERS=%" PRId64,
4523 maxFrameBufferAcquiredBuffers);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004524 result.append("]");
Andy McFadden4803b742012-09-24 19:07:20 -07004525}
4526
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004527void SurfaceFlinger::dumpVSync(std::string& result) const {
Ana Krulec757f63a2019-01-25 10:46:18 -08004528 mPhaseOffsets->dump(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004529 StringAppendF(&result,
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004530 " present offset: %9" PRId64 " ns\t VSYNC period: %9" PRId64 " ns\n\n",
Ana Krulec757f63a2019-01-25 10:46:18 -08004531 dispSyncPresentTimeOffset, getVsyncPeriod());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004532
Ady Abraham97d04232019-03-05 19:48:12 -08004533 StringAppendF(&result, "Scheduler enabled.");
Ana Krulecba13ab32019-02-20 14:14:12 -08004534 StringAppendF(&result, "+ Smart 90 for video detection: %s\n\n",
4535 mUseSmart90ForVideo ? "on" : "off");
Ana Krulecc2870422019-01-29 19:00:58 -08004536 mScheduler->dump(mAppConnectionHandle, result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004537}
4538
Yiwei Zhang5434a782018-12-05 18:06:32 -08004539void SurfaceFlinger::dumpStaticScreenStats(std::string& result) const {
4540 result.append("Static screen stats:\n");
David Sodman4a36e932017-11-07 14:29:47 -08004541 for (size_t b = 0; b < SurfaceFlingerBE::NUM_BUCKETS - 1; ++b) {
4542 float bucketTimeSec = getBE().mFrameBuckets[b] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08004543 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08004544 static_cast<float>(getBE().mFrameBuckets[b]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004545 StringAppendF(&result, " < %zd frames: %.3f s (%.1f%%)\n", b + 1, bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08004546 }
David Sodman4a36e932017-11-07 14:29:47 -08004547 float bucketTimeSec = getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08004548 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08004549 static_cast<float>(getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004550 StringAppendF(&result, " %zd+ frames: %.3f s (%.1f%%)\n", SurfaceFlingerBE::NUM_BUCKETS - 1,
4551 bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08004552}
4553
Dan Stozae77c7662016-05-13 11:37:28 -07004554void SurfaceFlinger::recordBufferingStats(const char* layerName,
4555 std::vector<OccupancyTracker::Segment>&& history) {
David Sodmancbaf0832017-11-07 14:21:36 -08004556 Mutex::Autolock lock(getBE().mBufferingStatsMutex);
4557 auto& stats = getBE().mBufferingStats[layerName];
Dan Stozae77c7662016-05-13 11:37:28 -07004558 for (const auto& segment : history) {
4559 if (!segment.usedThirdBuffer) {
4560 stats.twoBufferTime += segment.totalTime;
4561 }
4562 if (segment.occupancyAverage < 1.0f) {
4563 stats.doubleBufferedTime += segment.totalTime;
4564 } else if (segment.occupancyAverage < 2.0f) {
4565 stats.tripleBufferedTime += segment.totalTime;
4566 }
4567 ++stats.numSegments;
4568 stats.totalTime += segment.totalTime;
4569 }
4570}
4571
Yiwei Zhang5434a782018-12-05 18:06:32 -08004572void SurfaceFlinger::dumpFrameEventsLocked(std::string& result) {
4573 result.append("Layer frame timestamps:\n");
Brian Andersond6927fb2016-07-23 23:37:30 -07004574
4575 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
4576 const size_t count = currentLayers.size();
4577 for (size_t i=0 ; i<count ; i++) {
4578 currentLayers[i]->dumpFrameEvents(result);
4579 }
4580}
4581
Yiwei Zhang5434a782018-12-05 18:06:32 -08004582void SurfaceFlinger::dumpBufferingStats(std::string& result) const {
Dan Stozae77c7662016-05-13 11:37:28 -07004583 result.append("Buffering stats:\n");
4584 result.append(" [Layer name] <Active time> <Two buffer> "
4585 "<Double buffered> <Triple buffered>\n");
David Sodmancbaf0832017-11-07 14:21:36 -08004586 Mutex::Autolock lock(getBE().mBufferingStatsMutex);
Dan Stozae77c7662016-05-13 11:37:28 -07004587 typedef std::tuple<std::string, float, float, float> BufferTuple;
4588 std::map<float, BufferTuple, std::greater<float>> sorted;
David Sodmancbaf0832017-11-07 14:21:36 -08004589 for (const auto& statsPair : getBE().mBufferingStats) {
Dan Stozae77c7662016-05-13 11:37:28 -07004590 const char* name = statsPair.first.c_str();
David Sodmancbaf0832017-11-07 14:21:36 -08004591 const SurfaceFlingerBE::BufferingStats& stats = statsPair.second;
Dan Stozae77c7662016-05-13 11:37:28 -07004592 if (stats.numSegments == 0) {
4593 continue;
4594 }
4595 float activeTime = ns2ms(stats.totalTime) / 1000.0f;
4596 float twoBufferRatio = static_cast<float>(stats.twoBufferTime) /
4597 stats.totalTime;
4598 float doubleBufferRatio = static_cast<float>(
4599 stats.doubleBufferedTime) / stats.totalTime;
4600 float tripleBufferRatio = static_cast<float>(
4601 stats.tripleBufferedTime) / stats.totalTime;
4602 sorted.insert({activeTime, {name, twoBufferRatio,
4603 doubleBufferRatio, tripleBufferRatio}});
4604 }
4605 for (const auto& sortedPair : sorted) {
4606 float activeTime = sortedPair.first;
4607 const BufferTuple& values = sortedPair.second;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004608 StringAppendF(&result, " [%s] %.2f %.3f %.3f %.3f\n", std::get<0>(values).c_str(),
4609 activeTime, std::get<1>(values), std::get<2>(values), std::get<3>(values));
Dan Stozae77c7662016-05-13 11:37:28 -07004610 }
4611 result.append("\n");
4612}
4613
Yiwei Zhang5434a782018-12-05 18:06:32 -08004614void SurfaceFlinger::dumpDisplayIdentificationData(std::string& result) const {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004615 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004616 const auto displayId = display->getId();
4617 if (!displayId) {
4618 continue;
4619 }
4620 const auto hwcDisplayId = getHwComposer().fromPhysicalDisplayId(*displayId);
Dominik Laskowski7e045462018-05-30 13:02:02 -07004621 if (!hwcDisplayId) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004622 continue;
4623 }
4624
Yiwei Zhang5434a782018-12-05 18:06:32 -08004625 StringAppendF(&result,
4626 "Display %s (HWC display %" PRIu64 "): ", to_string(*displayId).c_str(),
4627 *hwcDisplayId);
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004628 uint8_t port;
4629 DisplayIdentificationData data;
Dominik Laskowski7e045462018-05-30 13:02:02 -07004630 if (!getHwComposer().getDisplayIdentificationData(*hwcDisplayId, &port, &data)) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004631 result.append("no identification data\n");
4632 continue;
4633 }
4634
4635 if (!isEdid(data)) {
4636 result.append("unknown identification data: ");
4637 for (uint8_t byte : data) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004638 StringAppendF(&result, "%x ", byte);
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004639 }
4640 result.append("\n");
4641 continue;
4642 }
4643
4644 const auto edid = parseEdid(data);
4645 if (!edid) {
4646 result.append("invalid EDID: ");
4647 for (uint8_t byte : data) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004648 StringAppendF(&result, "%x ", byte);
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004649 }
4650 result.append("\n");
4651 continue;
4652 }
4653
Yiwei Zhang5434a782018-12-05 18:06:32 -08004654 StringAppendF(&result, "port=%u pnpId=%s displayName=\"", port, edid->pnpId.data());
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004655 result.append(edid->displayName.data(), edid->displayName.length());
4656 result.append("\"\n");
4657 }
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004658}
4659
Yiwei Zhang5434a782018-12-05 18:06:32 -08004660void SurfaceFlinger::dumpWideColorInfo(std::string& result) const {
4661 StringAppendF(&result, "Device has wide color display: %d\n", hasWideColorDisplay);
4662 StringAppendF(&result, "Device uses color management: %d\n", useColorManagement);
4663 StringAppendF(&result, "DisplayColorSetting: %s\n",
4664 decodeDisplayColorSetting(mDisplayColorSetting).c_str());
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004665
4666 // TODO: print out if wide-color mode is active or not
4667
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004668 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004669 const auto displayId = display->getId();
4670 if (!displayId) {
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004671 continue;
4672 }
4673
Yiwei Zhang5434a782018-12-05 18:06:32 -08004674 StringAppendF(&result, "Display %s color modes:\n", to_string(*displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004675 std::vector<ColorMode> modes = getHwComposer().getColorModes(*displayId);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004676 for (auto&& mode : modes) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004677 StringAppendF(&result, " %s (%d)\n", decodeColorMode(mode).c_str(), mode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004678 }
4679
Lloyd Pique32cbe282018-10-19 13:09:22 -07004680 ColorMode currentMode = display->getCompositionDisplay()->getState().colorMode;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004681 StringAppendF(&result, " Current color mode: %s (%d)\n",
4682 decodeColorMode(currentMode).c_str(), currentMode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004683 }
4684 result.append("\n");
4685}
4686
Vishnu Nair9245d3b2019-03-22 13:38:56 -07004687LayersProto SurfaceFlinger::dumpProtoInfo(LayerVector::StateSet stateSet,
4688 uint32_t traceFlags) const {
chaviw1d044282017-09-27 12:19:28 -07004689 LayersProto layersProto;
Jorim Jaggi8e0af362017-11-14 16:28:28 +01004690 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
4691 const State& state = useDrawing ? mDrawingState : mCurrentState;
4692 state.traverseInZOrder([&](Layer* layer) {
chaviw1d044282017-09-27 12:19:28 -07004693 LayerProto* layerProto = layersProto.add_layers();
Vishnu Nair9245d3b2019-03-22 13:38:56 -07004694 layer->writeToProto(layerProto, stateSet, traceFlags);
chaviw1d044282017-09-27 12:19:28 -07004695 });
4696
4697 return layersProto;
4698}
4699
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004700LayersProto SurfaceFlinger::dumpVisibleLayersProtoInfo(
4701 const sp<DisplayDevice>& displayDevice) const {
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004702 LayersProto layersProto;
Yiwei Zhang60d1a192018-03-07 14:52:28 -08004703
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004704 SizeProto* resolution = layersProto.mutable_resolution();
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004705 resolution->set_w(displayDevice->getWidth());
4706 resolution->set_h(displayDevice->getHeight());
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004707
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004708 auto display = displayDevice->getCompositionDisplay();
Lloyd Pique32cbe282018-10-19 13:09:22 -07004709 const auto& displayState = display->getState();
Yiwei Zhang60d1a192018-03-07 14:52:28 -08004710
Lloyd Pique32cbe282018-10-19 13:09:22 -07004711 layersProto.set_color_mode(decodeColorMode(displayState.colorMode));
4712 layersProto.set_color_transform(decodeColorTransform(displayState.colorTransform));
4713 layersProto.set_global_transform(displayState.orientation);
4714
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004715 const auto displayId = displayDevice->getId();
Dominik Laskowski075d3172018-05-24 15:50:06 -07004716 LOG_ALWAYS_FATAL_IF(!displayId);
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004717 mDrawingState.traverseInZOrder([&](Layer* layer) {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004718 if (!layer->visibleRegion.isEmpty() && !display->getOutputLayersOrderedByZ().empty()) {
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004719 LayerProto* layerProto = layersProto.add_layers();
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004720 layer->writeToProto(layerProto, displayDevice);
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004721 }
4722 });
4723
4724 return layersProto;
4725}
4726
Dominik Laskowskic2867142019-01-21 11:33:38 -08004727void SurfaceFlinger::dumpAllLocked(const DumpArgs& args, std::string& result) const {
4728 const bool colorize = !args.empty() && args[0] == String16("--color");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004729 Colorizer colorizer(colorize);
4730
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004731 // figure out if we're stuck somewhere
4732 const nsecs_t now = systemTime();
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004733 const nsecs_t inTransaction(mDebugInTransaction);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004734 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
4735
4736 /*
Andy McFadden4803b742012-09-24 19:07:20 -07004737 * Dump library configuration.
4738 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004739
4740 colorizer.bold(result);
Andy McFadden4803b742012-09-24 19:07:20 -07004741 result.append("Build configuration:");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004742 colorizer.reset(result);
Andy McFadden4803b742012-09-24 19:07:20 -07004743 appendSfConfigString(result);
4744 appendUiConfigString(result);
4745 appendGuiConfigString(result);
4746 result.append("\n");
4747
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004748 result.append("\nDisplay identification data:\n");
4749 dumpDisplayIdentificationData(result);
4750
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004751 result.append("\nWide-Color information:\n");
4752 dumpWideColorInfo(result);
4753
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004754 colorizer.bold(result);
Mathias Agopianca088332013-03-28 17:44:13 -07004755 result.append("Sync configuration: ");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004756 colorizer.reset(result);
Mathias Agopianca088332013-03-28 17:44:13 -07004757 result.append(SyncFeatures::getInstance().toString());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004758 result.append("\n\n");
Mathias Agopianca088332013-03-28 17:44:13 -07004759
Andy McFadden41d67d72014-04-25 16:58:34 -07004760 colorizer.bold(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004761 result.append("VSYNC configuration:\n");
Andy McFadden41d67d72014-04-25 16:58:34 -07004762 colorizer.reset(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004763 dumpVSync(result);
Dan Stozab90cf072015-03-05 11:05:59 -08004764 result.append("\n");
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004765
Dan Stozab90cf072015-03-05 11:05:59 -08004766 dumpStaticScreenStats(result);
4767 result.append("\n");
4768
Alec Mouri40189b02019-03-05 15:07:54 -08004769 StringAppendF(&result, "Total missed frame count: %u\n", mFrameMissedCount.load());
4770 StringAppendF(&result, "HWC missed frame count: %u\n", mHwcFrameMissedCount.load());
4771 StringAppendF(&result, "GPU missed frame count: %u\n\n", mGpuFrameMissedCount.load());
Marissa Wallcfcdaa52018-05-21 15:45:59 -07004772
Dan Stozae77c7662016-05-13 11:37:28 -07004773 dumpBufferingStats(result);
4774
Andy McFadden4803b742012-09-24 19:07:20 -07004775 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004776 * Dump the visible layer list
4777 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004778 colorizer.bold(result);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004779 StringAppendF(&result, "Visible layers (count = %zu)\n", mNumLayers);
4780 StringAppendF(&result, "GraphicBufferProducers: %zu, max %zu\n",
4781 mGraphicBufferProducerList.size(), mMaxGraphicBufferProducerListSize);
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004782 colorizer.reset(result);
chaviw1d044282017-09-27 12:19:28 -07004783
Chia-I Wu2f884132018-09-13 15:17:58 -07004784 {
4785 LayersProto layersProto = dumpProtoInfo(LayerVector::StateSet::Current);
4786 auto layerTree = LayerProtoParser::generateLayerTree(layersProto);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004787 result.append(LayerProtoParser::layerTreeToString(layerTree));
Chia-I Wu2f884132018-09-13 15:17:58 -07004788 result.append("\n");
4789 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004790
Lloyd Pique207def92019-02-28 16:09:52 -08004791 {
4792 StringAppendF(&result, "Composition layers\n");
4793 mDrawingState.traverseInZOrder([&](Layer* layer) {
4794 auto compositionLayer = layer->getCompositionLayer();
4795 if (compositionLayer) compositionLayer->dump(result);
4796 });
4797 }
4798
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004799 /*
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004800 * Dump Display state
4801 */
4802
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004803 colorizer.bold(result);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004804 StringAppendF(&result, "Displays (%zu entries)\n", mDisplays.size());
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004805 colorizer.reset(result);
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004806 for (const auto& [token, display] : mDisplays) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004807 display->dump(result);
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004808 }
Chia-I Wu1e043612018-03-01 09:45:09 -08004809 result.append("\n");
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004810
4811 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004812 * Dump SurfaceFlinger global state
4813 */
4814
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004815 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02004816 result.append("SurfaceFlinger global state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004817 colorizer.reset(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004818
Lloyd Piqueb97e04f2018-10-18 17:07:05 -07004819 getRenderEngine().dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004820
Dominik Laskowski075d3172018-05-24 15:50:06 -07004821 if (const auto display = getDefaultDisplayDeviceLocked()) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07004822 display->getCompositionDisplay()->getState().undefinedRegion.dump(result,
4823 "undefinedRegion");
Yiwei Zhang5434a782018-12-05 18:06:32 -08004824 StringAppendF(&result, " orientation=%d, isPoweredOn=%d\n", display->getOrientation(),
4825 display->isPoweredOn());
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08004826 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08004827 StringAppendF(&result,
4828 " transaction-flags : %08x\n"
4829 " gpu_to_cpu_unsupported : %d\n",
4830 mTransactionFlags.load(), !mGpuToCpuSupported);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004831
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08004832 if (const auto displayId = getInternalDisplayIdLocked();
Dominik Laskowski075d3172018-05-24 15:50:06 -07004833 displayId && getHwComposer().isConnected(*displayId)) {
4834 const auto activeConfig = getHwComposer().getActiveConfig(*displayId);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004835 StringAppendF(&result,
4836 " refresh-rate : %f fps\n"
4837 " x-dpi : %f\n"
4838 " y-dpi : %f\n",
4839 1e9 / activeConfig->getVsyncPeriod(), activeConfig->getDpiX(),
4840 activeConfig->getDpiY());
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004841 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004842
Yiwei Zhang5434a782018-12-05 18:06:32 -08004843 StringAppendF(&result, " transaction time: %f us\n", inTransactionDuration / 1000.0);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004844
Dan Stozae22aec72016-08-01 13:20:59 -07004845 /*
Yichi Chenadc69612018-09-15 14:51:18 +08004846 * Tracing state
4847 */
4848 mTracing.dump(result);
4849 result.append("\n");
4850
4851 /*
Dan Stozae22aec72016-08-01 13:20:59 -07004852 * HWC layer minidump
4853 */
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004854 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004855 const auto displayId = display->getId();
4856 if (!displayId) {
Dan Stozae22aec72016-08-01 13:20:59 -07004857 continue;
4858 }
4859
Yiwei Zhang5434a782018-12-05 18:06:32 -08004860 StringAppendF(&result, "Display %s HWC layers:\n", to_string(*displayId).c_str());
Dan Stozae22aec72016-08-01 13:20:59 -07004861 Layer::miniDumpHeader(result);
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004862 const sp<DisplayDevice> displayDevice = display;
4863 mCurrentState.traverseInZOrder(
4864 [&](Layer* layer) { layer->miniDump(result, displayDevice); });
Dan Stozae22aec72016-08-01 13:20:59 -07004865 result.append("\n");
4866 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004867
4868 /*
4869 * Dump HWComposer state
4870 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004871 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02004872 result.append("h/w composer state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004873 colorizer.reset(result);
Dan Stoza9f26a9c2016-06-22 14:51:09 -07004874 bool hwcDisabled = mDebugDisableHWC || mDebugRegion;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004875 StringAppendF(&result, " h/w composer %s\n", hwcDisabled ? "disabled" : "enabled");
Dominik Laskowski075d3172018-05-24 15:50:06 -07004876 getHwComposer().dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004877
4878 /*
4879 * Dump gralloc state
4880 */
4881 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
4882 alloc.dump(result);
Karthik Ravi Shankar171155a2017-06-28 15:40:24 -07004883
4884 /*
4885 * Dump VrFlinger state if in use.
4886 */
4887 if (mVrFlingerRequestsDisplay && mVrFlinger) {
4888 result.append("VrFlinger state:\n");
Yiwei Zhang5434a782018-12-05 18:06:32 -08004889 result.append(mVrFlinger->Dump());
Karthik Ravi Shankar171155a2017-06-28 15:40:24 -07004890 result.append("\n");
4891 }
Ana Krulecb43429d2019-01-09 14:28:51 -08004892
4893 /**
4894 * Scheduler dump state.
4895 */
Ana Krulecc2870422019-01-29 19:00:58 -08004896 result.append("\nScheduler state:\n");
4897 result.append(mScheduler->doDump() + "\n");
Ana Krulecfefd6ae2019-02-13 17:53:08 -08004898 StringAppendF(&result, "+ Smart video mode: %s\n\n", mUseSmart90ForVideo ? "on" : "off");
Dominik Laskowski22488f62019-03-28 09:53:04 -07004899 result.append(mRefreshRateStats.doDump() + "\n");
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004900}
4901
Dominik Laskowski075d3172018-05-24 15:50:06 -07004902const Vector<sp<Layer>>& SurfaceFlinger::getLayerSortedByZForHwcDisplay(DisplayId displayId) {
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07004903 // Note: mStateLock is held here
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004904 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski7e045462018-05-30 13:02:02 -07004905 if (display->getId() == displayId) {
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004906 return getDisplayDeviceLocked(token)->getVisibleLayersSortedByZ();
Jesse Hall48bc05b2013-03-21 14:06:52 -07004907 }
4908 }
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004909
Dominik Laskowski34157762018-10-31 13:07:19 -07004910 ALOGE("%s: Invalid display %s", __FUNCTION__, to_string(displayId).c_str());
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004911 static const Vector<sp<Layer>> empty;
4912 return empty;
Mathias Agopiancb558572012-10-04 15:58:54 -07004913}
4914
Chia-I Wu28f320b2018-05-03 11:02:56 -07004915void SurfaceFlinger::updateColorMatrixLocked() {
4916 mat4 colorMatrix;
4917 if (mGlobalSaturationFactor != 1.0f) {
4918 // Rec.709 luma coefficients
4919 float3 luminance{0.213f, 0.715f, 0.072f};
4920 luminance *= 1.0f - mGlobalSaturationFactor;
4921 mat4 saturationMatrix = mat4(
4922 vec4{luminance.r + mGlobalSaturationFactor, luminance.r, luminance.r, 0.0f},
4923 vec4{luminance.g, luminance.g + mGlobalSaturationFactor, luminance.g, 0.0f},
4924 vec4{luminance.b, luminance.b, luminance.b + mGlobalSaturationFactor, 0.0f},
4925 vec4{0.0f, 0.0f, 0.0f, 1.0f}
4926 );
4927 colorMatrix = mClientColorMatrix * saturationMatrix * mDaltonizer();
4928 } else {
4929 colorMatrix = mClientColorMatrix * mDaltonizer();
4930 }
4931
4932 if (mCurrentState.colorMatrix != colorMatrix) {
4933 mCurrentState.colorMatrix = colorMatrix;
4934 mCurrentState.colorMatrixChanged = true;
4935 setTransactionFlags(eTransactionNeeded);
4936 }
4937}
4938
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07004939status_t SurfaceFlinger::CheckTransactCodeCredentials(uint32_t code) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004940#pragma clang diagnostic push
4941#pragma clang diagnostic error "-Wswitch-enum"
4942 switch (static_cast<ISurfaceComposerTag>(code)) {
4943 // These methods should at minimum make sure that the client requested
4944 // access to SF.
Dan Stozae3344402018-08-20 19:53:42 +00004945 case BOOT_FINISHED:
4946 case CLEAR_ANIMATION_FRAME_STATS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004947 case CREATE_DISPLAY:
4948 case DESTROY_DISPLAY:
Dan Stozae3344402018-08-20 19:53:42 +00004949 case ENABLE_VSYNC_INJECTIONS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004950 case GET_ANIMATION_FRAME_STATS:
4951 case GET_HDR_CAPABILITIES:
4952 case SET_ACTIVE_CONFIG:
Ady Abraham838de062019-02-04 10:24:03 -08004953 case SET_ALLOWED_DISPLAY_CONFIGS:
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08004954 case GET_ALLOWED_DISPLAY_CONFIGS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004955 case SET_ACTIVE_COLOR_MODE:
Chia-I Wu90f669f2017-10-05 14:24:41 -07004956 case INJECT_VSYNC:
Kevin DuBois9c0a1762018-10-16 13:32:31 -07004957 case SET_POWER_MODE:
Kevin DuBois74e53772018-11-19 10:52:38 -08004958 case GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES:
Kevin DuBois1d4249a2018-08-29 10:45:14 -07004959 case SET_DISPLAY_CONTENT_SAMPLING_ENABLED:
4960 case GET_DISPLAYED_CONTENT_SAMPLE: {
Robert Carrd4ae7f32018-06-07 16:10:57 -07004961 if (!callingThreadHasUnscopedSurfaceFlingerAccess()) {
4962 IPCThreadState* ipc = IPCThreadState::self();
4963 ALOGE("Permission Denial: can't access SurfaceFlinger pid=%d, uid=%d",
4964 ipc->getCallingPid(), ipc->getCallingUid());
Mathias Agopian375f5632009-06-15 18:24:59 -07004965 return PERMISSION_DENIED;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004966 }
Robert Carr1db73f62016-12-21 12:58:51 -08004967 return OK;
4968 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004969 case GET_LAYER_DEBUG_INFO: {
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07004970 IPCThreadState* ipc = IPCThreadState::self();
4971 const int pid = ipc->getCallingPid();
4972 const int uid = ipc->getCallingUid();
Ana Krulec13be8ad2018-08-21 02:43:56 +00004973 if ((uid != AID_SHELL) && !PermissionCache::checkPermission(sDump, pid, uid)) {
4974 ALOGE("Layer debug info permission denied for pid=%d, uid=%d", pid, uid);
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07004975 return PERMISSION_DENIED;
4976 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004977 return OK;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004978 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004979 // Used by apps to hook Choreographer to SurfaceFlinger.
4980 case CREATE_DISPLAY_EVENT_CONNECTION:
4981 // The following calls are currently used by clients that do not
4982 // request necessary permissions. However, they do not expose any secret
4983 // information, so it is OK to pass them.
4984 case AUTHENTICATE_SURFACE:
Peiyong Lind1fedb42019-03-11 17:48:41 -07004985 case GET_ACTIVE_COLOR_MODE:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004986 case GET_ACTIVE_CONFIG:
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08004987 case GET_PHYSICAL_DISPLAY_IDS:
4988 case GET_PHYSICAL_DISPLAY_TOKEN:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004989 case GET_DISPLAY_COLOR_MODES:
Daniel Solomon42d04562019-01-20 21:03:19 -08004990 case GET_DISPLAY_NATIVE_PRIMARIES:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004991 case GET_DISPLAY_CONFIGS:
4992 case GET_DISPLAY_STATS:
4993 case GET_SUPPORTED_FRAME_TIMESTAMPS:
4994 // Calling setTransactionState is safe, because you need to have been
4995 // granted a reference to Client* and Handle* to do anything with it.
4996 case SET_TRANSACTION_STATE:
Robert Carrb89ea9d2018-12-10 13:01:14 -08004997 case CREATE_CONNECTION:
Ady Abraham37965d42018-11-01 13:43:32 -07004998 case GET_COLOR_MANAGEMENT:
Peiyong Lin3c2791e2019-01-14 17:05:18 -08004999 case GET_COMPOSITION_PREFERENCE:
Marissa Wallebc2c052019-01-16 19:16:55 -08005000 case GET_PROTECTED_CONTENT_SUPPORT:
Dan Gittik57e63c52019-01-18 16:37:54 +00005001 case IS_WIDE_COLOR_DISPLAY:
5002 case GET_DISPLAY_BRIGHTNESS_SUPPORT:
5003 case SET_DISPLAY_BRIGHTNESS: {
Ana Krulec13be8ad2018-08-21 02:43:56 +00005004 return OK;
5005 }
5006 case CAPTURE_LAYERS:
Dan Stoza84ab9372018-12-17 15:27:57 -08005007 case CAPTURE_SCREEN:
5008 case ADD_REGION_SAMPLING_LISTENER:
5009 case REMOVE_REGION_SAMPLING_LISTENER: {
Ana Krulec13be8ad2018-08-21 02:43:56 +00005010 // codes that require permission check
chaviwa76b2712017-09-20 12:02:26 -07005011 IPCThreadState* ipc = IPCThreadState::self();
5012 const int pid = ipc->getCallingPid();
5013 const int uid = ipc->getCallingUid();
5014 if ((uid != AID_GRAPHICS) &&
5015 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
5016 ALOGE("Permission Denial: can't read framebuffer pid=%d, uid=%d", pid, uid);
5017 return PERMISSION_DENIED;
5018 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00005019 return OK;
5020 }
5021 // The following codes are deprecated and should never be allowed to access SF.
5022 case CONNECT_DISPLAY_UNUSED:
5023 case CREATE_GRAPHIC_BUFFER_ALLOC_UNUSED: {
5024 ALOGE("Attempting to access SurfaceFlinger with unused code: %u", code);
5025 return PERMISSION_DENIED;
chaviwa76b2712017-09-20 12:02:26 -07005026 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005027 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00005028
5029 // These codes are used for the IBinder protocol to either interrogate the recipient
5030 // side of the transaction for its canonical interface descriptor or to dump its state.
5031 // We let them pass by default.
5032 if (code == IBinder::INTERFACE_TRANSACTION || code == IBinder::DUMP_TRANSACTION ||
5033 code == IBinder::PING_TRANSACTION || code == IBinder::SHELL_COMMAND_TRANSACTION ||
5034 code == IBinder::SYSPROPS_TRANSACTION) {
5035 return OK;
5036 }
Ady Abraham03b02dd2019-03-21 15:40:11 -07005037 // Numbers from 1000 to 1034 are currently used for backdoors. The code
Ana Krulec13be8ad2018-08-21 02:43:56 +00005038 // in onTransact verifies that the user is root, and has access to use SF.
Ady Abraham34392f72019-04-10 11:29:27 -07005039 if (code >= 1000 && code <= 1035) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00005040 ALOGV("Accessing SurfaceFlinger through backdoor code: %u", code);
5041 return OK;
5042 }
5043 ALOGE("Permission Denial: SurfaceFlinger did not recognize request code: %u", code);
5044 return PERMISSION_DENIED;
5045#pragma clang diagnostic pop
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07005046}
5047
Ana Krulec13be8ad2018-08-21 02:43:56 +00005048status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
5049 uint32_t flags) {
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07005050 status_t credentialCheck = CheckTransactCodeCredentials(code);
5051 if (credentialCheck != OK) {
5052 return credentialCheck;
5053 }
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07005054
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005055 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
5056 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
Mathias Agopianb8a55602009-06-26 19:06:36 -07005057 CHECK_INTERFACE(ISurfaceComposer, data, reply);
Romain Guy8c6bbd62017-06-05 13:51:43 -07005058 IPCThreadState* ipc = IPCThreadState::self();
5059 const int uid = ipc->getCallingUid();
5060 if (CC_UNLIKELY(uid != AID_SYSTEM
5061 && !PermissionCache::checkCallingPermission(sHardwareTest))) {
Mathias Agopian375f5632009-06-15 18:24:59 -07005062 const int pid = ipc->getCallingPid();
Steve Blocke6f43dd2012-01-06 19:20:56 +00005063 ALOGE("Permission Denial: "
Mathias Agopian375f5632009-06-15 18:24:59 -07005064 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005065 return PERMISSION_DENIED;
5066 }
5067 int n;
5068 switch (code) {
Mathias Agopian01b76682009-04-16 20:04:08 -07005069 case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
Mathias Agopian35b48d12010-09-13 22:57:58 -07005070 case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005071 return NO_ERROR;
5072 case 1002: // SHOW_UPDATES
5073 n = data.readInt32();
5074 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
Mathias Agopian53331da2011-08-22 21:44:41 -07005075 invalidateHwcGeometry();
5076 repaintEverything();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005077 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005078 case 1004:{ // repaint everything
Mathias Agopian53331da2011-08-22 21:44:41 -07005079 repaintEverything();
Mathias Agopiancbb288b2009-09-07 16:32:45 -07005080 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005081 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -07005082 case 1005:{ // force transaction
Steven Thomas6d8110b2017-08-31 18:24:21 -07005083 Mutex::Autolock _l(mStateLock);
Mathias Agopiane57f2922012-08-09 16:29:12 -07005084 setTransactionFlags(
5085 eTransactionNeeded|
5086 eDisplayTransactionNeeded|
5087 eTraversalNeeded);
Mathias Agopiancbb288b2009-09-07 16:32:45 -07005088 return NO_ERROR;
5089 }
Mathias Agopian4d143ee2012-02-23 20:05:39 -08005090 case 1006:{ // send empty update
5091 signalRefresh();
5092 return NO_ERROR;
5093 }
Mathias Agopian53331da2011-08-22 21:44:41 -07005094 case 1008: // toggle use of hw composer
5095 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005096 mDebugDisableHWC = n != 0;
Mathias Agopian53331da2011-08-22 21:44:41 -07005097 invalidateHwcGeometry();
5098 repaintEverything();
5099 return NO_ERROR;
Mathias Agopiana4583642011-08-23 18:03:18 -07005100 case 1009: // toggle use of transform hint
5101 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005102 mDebugDisableTransformHint = n != 0;
Mathias Agopiana4583642011-08-23 18:03:18 -07005103 invalidateHwcGeometry();
5104 repaintEverything();
5105 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005106 case 1010: // interrogate.
Mathias Agopian01b76682009-04-16 20:04:08 -07005107 reply->writeInt32(0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005108 reply->writeInt32(0);
5109 reply->writeInt32(mDebugRegion);
Mathias Agopianb9494d52012-04-18 02:28:45 -07005110 reply->writeInt32(0);
Dianne Hackborn12839be2012-02-06 21:21:05 -08005111 reply->writeInt32(mDebugDisableHWC);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005112 return NO_ERROR;
5113 case 1013: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005114 const auto display = getDefaultDisplayDevice();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07005115 if (!display) {
5116 return NAME_NOT_FOUND;
5117 }
5118
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005119 reply->writeInt32(display->getPageFlipCount());
Mathias Agopianff2ed702013-09-01 21:36:12 -07005120 return NO_ERROR;
5121 }
5122 case 1014: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005123 Mutex::Autolock _l(mStateLock);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005124 // daltonize
5125 n = data.readInt32();
5126 switch (n % 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005127 case 1:
5128 mDaltonizer.setType(ColorBlindnessType::Protanomaly);
5129 break;
5130 case 2:
5131 mDaltonizer.setType(ColorBlindnessType::Deuteranomaly);
5132 break;
5133 case 3:
5134 mDaltonizer.setType(ColorBlindnessType::Tritanomaly);
5135 break;
5136 default:
5137 mDaltonizer.setType(ColorBlindnessType::None);
5138 break;
Mathias Agopianff2ed702013-09-01 21:36:12 -07005139 }
5140 if (n >= 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005141 mDaltonizer.setMode(ColorBlindnessMode::Correction);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005142 } else {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005143 mDaltonizer.setMode(ColorBlindnessMode::Simulation);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005144 }
Chia-I Wu28f320b2018-05-03 11:02:56 -07005145
5146 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005147 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005148 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005149 case 1015: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005150 Mutex::Autolock _l(mStateLock);
Alan Viverette9c5a3332013-09-12 20:04:35 -07005151 // apply a color matrix
5152 n = data.readInt32();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005153 if (n) {
Romain Guy0147a172017-06-01 13:53:56 -07005154 // color matrix is sent as a column-major mat4 matrix
Alan Viverette794c5ba2013-10-03 16:40:52 -07005155 for (size_t i = 0 ; i < 4; i++) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005156 for (size_t j = 0; j < 4; j++) {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005157 mClientColorMatrix[i][j] = data.readFloat();
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005158 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005159 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005160 } else {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005161 mClientColorMatrix = mat4();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005162 }
Romain Guy88d37dd2017-05-26 17:57:05 -07005163
5164 // Check that supplied matrix's last row is {0,0,0,1} so we can avoid
5165 // the division by w in the fragment shader
Chia-I Wu28f320b2018-05-03 11:02:56 -07005166 float4 lastRow(transpose(mClientColorMatrix)[3]);
Romain Guy88d37dd2017-05-26 17:57:05 -07005167 if (any(greaterThan(abs(lastRow - float4{0, 0, 0, 1}), float4{1e-4f}))) {
5168 ALOGE("The color transform's last row must be (0, 0, 0, 1)");
5169 }
5170
Chia-I Wu28f320b2018-05-03 11:02:56 -07005171 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005172 return NO_ERROR;
5173 }
Ruchi Kandoif52b3c82014-04-24 16:42:35 -07005174 // This is an experimental interface
5175 // Needs to be shifted to proper binder interface when we productize
5176 case 1016: {
Andy McFadden645b1f72014-06-10 14:43:32 -07005177 n = data.readInt32();
Ana Krulece588e312018-09-18 12:32:24 -07005178 // TODO(b/113612090): Evaluate if this can be removed.
Ana Krulecc2870422019-01-29 19:00:58 -08005179 mScheduler->setRefreshSkipCount(n);
Ruchi Kandoif52b3c82014-04-24 16:42:35 -07005180 return NO_ERROR;
5181 }
Dan Stozaee44edd2015-03-23 15:50:23 -07005182 case 1017: {
5183 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005184 mForceFullDamage = n != 0;
Dan Stozaee44edd2015-03-23 15:50:23 -07005185 return NO_ERROR;
5186 }
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005187 case 1018: { // Modify Choreographer's phase offset
5188 n = data.readInt32();
Ana Krulecc2870422019-01-29 19:00:58 -08005189 mScheduler->setPhaseOffset(mAppConnectionHandle, static_cast<nsecs_t>(n));
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005190 return NO_ERROR;
5191 }
5192 case 1019: { // Modify SurfaceFlinger's phase offset
5193 n = data.readInt32();
Ana Krulecc2870422019-01-29 19:00:58 -08005194 mScheduler->setPhaseOffset(mSfConnectionHandle, static_cast<nsecs_t>(n));
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005195 return NO_ERROR;
5196 }
Irvel468051e2016-06-13 16:44:44 -07005197 case 1020: { // Layer updates interceptor
5198 n = data.readInt32();
5199 if (n) {
5200 ALOGV("Interceptor enabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08005201 mInterceptor->enable(mDrawingState.layersSortedByZ, mDrawingState.displays);
Irvel468051e2016-06-13 16:44:44 -07005202 }
5203 else{
5204 ALOGV("Interceptor disabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08005205 mInterceptor->disable();
Irvel468051e2016-06-13 16:44:44 -07005206 }
5207 return NO_ERROR;
5208 }
Dan Stoza8cf150a2016-08-02 10:27:31 -07005209 case 1021: { // Disable HWC virtual displays
5210 n = data.readInt32();
5211 mUseHwcVirtualDisplays = !n;
5212 return NO_ERROR;
5213 }
Romain Guy0147a172017-06-01 13:53:56 -07005214 case 1022: { // Set saturation boost
Chia-I Wu28f320b2018-05-03 11:02:56 -07005215 Mutex::Autolock _l(mStateLock);
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005216 mGlobalSaturationFactor = std::max(0.0f, std::min(data.readFloat(), 2.0f));
Romain Guy0147a172017-06-01 13:53:56 -07005217
Chia-I Wu28f320b2018-05-03 11:02:56 -07005218 updateColorMatrixLocked();
Romain Guy0147a172017-06-01 13:53:56 -07005219 return NO_ERROR;
5220 }
Romain Guy54f154a2017-10-24 21:40:32 +01005221 case 1023: { // Set native mode
Chia-I Wu0d711262018-05-21 15:19:35 -07005222 mDisplayColorSetting = static_cast<DisplayColorSetting>(data.readInt32());
Romain Guy54f154a2017-10-24 21:40:32 +01005223 invalidateHwcGeometry();
5224 repaintEverything();
5225 return NO_ERROR;
5226 }
Peiyong Lin4bac91c2018-10-25 09:48:33 -07005227 // Deprecate, use 1030 to check whether the device is color managed.
5228 case 1024: {
5229 return NAME_NOT_FOUND;
Romain Guy54f154a2017-10-24 21:40:32 +01005230 }
Vishnu Nair87704c92018-01-08 15:32:57 -08005231 case 1025: { // Set layer tracing
Adrian Roos1e1a1282017-11-01 19:05:31 +01005232 n = data.readInt32();
5233 if (n) {
Yichi Chenadc69612018-09-15 14:51:18 +08005234 ALOGD("LayerTracing enabled");
Nataniel Borges2b796da2019-02-15 13:32:18 -08005235 Mutex::Autolock lock(mStateLock);
5236 mTracingEnabledChanged = true;
Adrian Roos1e1a1282017-11-01 19:05:31 +01005237 mTracing.enable();
Adrian Roos1e1a1282017-11-01 19:05:31 +01005238 reply->writeInt32(NO_ERROR);
5239 } else {
Yichi Chenadc69612018-09-15 14:51:18 +08005240 ALOGD("LayerTracing disabled");
Nataniel Borges2b796da2019-02-15 13:32:18 -08005241 bool writeFile = false;
5242 {
5243 Mutex::Autolock lock(mStateLock);
5244 mTracingEnabledChanged = true;
5245 writeFile = mTracing.disable();
5246 }
5247
5248 if (writeFile) {
5249 reply->writeInt32(mTracing.writeToFile());
5250 } else {
5251 reply->writeInt32(NO_ERROR);
5252 }
Adrian Roos1e1a1282017-11-01 19:05:31 +01005253 }
5254 return NO_ERROR;
5255 }
Vishnu Nair87704c92018-01-08 15:32:57 -08005256 case 1026: { // Get layer tracing status
5257 reply->writeBool(mTracing.isEnabled());
5258 return NO_ERROR;
5259 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005260 // Is a DisplayColorSetting supported?
5261 case 1027: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005262 const auto display = getDefaultDisplayDevice();
5263 if (!display) {
Chia-I Wu0d711262018-05-21 15:19:35 -07005264 return NAME_NOT_FOUND;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005265 }
Chia-I Wu0d711262018-05-21 15:19:35 -07005266
5267 DisplayColorSetting setting = static_cast<DisplayColorSetting>(data.readInt32());
5268 switch (setting) {
5269 case DisplayColorSetting::MANAGED:
Peiyong Lin13effd12018-07-24 17:01:47 -07005270 reply->writeBool(useColorManagement);
Chia-I Wu0d711262018-05-21 15:19:35 -07005271 break;
5272 case DisplayColorSetting::UNMANAGED:
5273 reply->writeBool(true);
5274 break;
5275 case DisplayColorSetting::ENHANCED:
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005276 reply->writeBool(display->hasRenderIntent(RenderIntent::ENHANCE));
Chia-I Wu0d711262018-05-21 15:19:35 -07005277 break;
5278 default: // vendor display color setting
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005279 reply->writeBool(
5280 display->hasRenderIntent(static_cast<RenderIntent>(setting)));
Chia-I Wu0d711262018-05-21 15:19:35 -07005281 break;
5282 }
5283 return NO_ERROR;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005284 }
Steven Thomas97f1f4c2018-06-01 12:04:16 -07005285 // Is VrFlinger active?
5286 case 1028: {
5287 Mutex::Autolock _l(mStateLock);
Lloyd Pique441d5042018-10-18 16:49:51 -07005288 reply->writeBool(getHwComposer().isUsingVrComposer());
Steven Thomas97f1f4c2018-06-01 12:04:16 -07005289 return NO_ERROR;
5290 }
Nataniel Borges2b796da2019-02-15 13:32:18 -08005291 // Set buffer size for SF tracing (value in KB)
5292 case 1029: {
5293 n = data.readInt32();
5294 if (n <= 0 || n > MAX_TRACING_MEMORY) {
5295 ALOGW("Invalid buffer size: %d KB", n);
5296 reply->writeInt32(BAD_VALUE);
5297 return BAD_VALUE;
5298 }
5299
5300 ALOGD("Updating trace buffer to %d KB", n);
5301 mTracing.setBufferSize(n * 1024);
5302 reply->writeInt32(NO_ERROR);
5303 return NO_ERROR;
5304 }
Peiyong Lin13effd12018-07-24 17:01:47 -07005305 // Is device color managed?
5306 case 1030: {
5307 reply->writeBool(useColorManagement);
5308 return NO_ERROR;
5309 }
Peiyong Lin9d846a52018-11-05 13:18:20 -08005310 // Override default composition data space
5311 // adb shell service call SurfaceFlinger 1031 i32 1 DATASPACE_NUMBER DATASPACE_NUMBER \
5312 // && adb shell stop zygote && adb shell start zygote
5313 // to restore: adb shell service call SurfaceFlinger 1031 i32 0 && \
5314 // adb shell stop zygote && adb shell start zygote
5315 case 1031: {
5316 Mutex::Autolock _l(mStateLock);
5317 n = data.readInt32();
5318 if (n) {
5319 n = data.readInt32();
5320 if (n) {
5321 Dataspace dataspace = static_cast<Dataspace>(n);
5322 if (!validateCompositionDataspace(dataspace)) {
5323 return BAD_VALUE;
5324 }
5325 mDefaultCompositionDataspace = dataspace;
5326 }
5327 n = data.readInt32();
5328 if (n) {
5329 Dataspace dataspace = static_cast<Dataspace>(n);
5330 if (!validateCompositionDataspace(dataspace)) {
5331 return BAD_VALUE;
5332 }
5333 mWideColorGamutCompositionDataspace = dataspace;
5334 }
5335 } else {
5336 // restore composition data space.
5337 mDefaultCompositionDataspace = defaultCompositionDataspace;
5338 mWideColorGamutCompositionDataspace = wideColorGamutCompositionDataspace;
5339 }
5340 return NO_ERROR;
5341 }
Vishnu Nair9245d3b2019-03-22 13:38:56 -07005342 // Set trace flags
5343 case 1033: {
5344 n = data.readUint32();
5345 ALOGD("Updating trace flags to 0x%x", n);
5346 mTracing.setTraceFlags(n);
5347 reply->writeInt32(NO_ERROR);
5348 return NO_ERROR;
5349 }
Ady Abraham03b02dd2019-03-21 15:40:11 -07005350 case 1034: {
5351 // TODO(b/129297325): expose this via developer menu option
5352 n = data.readInt32();
5353 if (n && !mRefreshRateOverlay) {
5354 std::lock_guard<std::mutex> lock(mActiveConfigLock);
5355 mRefreshRateOverlay = std::make_unique<RefreshRateOverlay>(*this);
5356 mRefreshRateOverlay->changeRefreshRate(mDesiredActiveConfig.type);
5357 } else if (!n) {
5358 mRefreshRateOverlay.reset();
5359 }
5360 return NO_ERROR;
5361 }
Ady Abraham34392f72019-04-10 11:29:27 -07005362 case 1035: {
5363 n = data.readInt32();
5364 mDebugDisplayConfigSetByBackdoor = false;
5365 if (n >= 0) {
5366 const auto displayToken = getInternalDisplayToken();
5367 status_t result = setAllowedDisplayConfigs(displayToken, {n});
5368 if (result != NO_ERROR) {
5369 return result;
5370 }
5371 mDebugDisplayConfigSetByBackdoor = true;
5372 }
5373 return NO_ERROR;
5374 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005375 }
5376 }
5377 return err;
5378}
5379
Steven Thomas6d8110b2017-08-31 18:24:21 -07005380void SurfaceFlinger::repaintEverything() {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07005381 mRepaintEverything = true;
Dan Stozac7a25ad2018-04-12 11:45:09 -07005382 signalTransaction();
Steven Thomas6d8110b2017-08-31 18:24:21 -07005383}
5384
Ana Krulec7d1d6832018-12-27 11:10:09 -08005385void SurfaceFlinger::repaintEverythingForHWC() {
5386 mRepaintEverything = true;
5387 mEventQueue->invalidateForHWC();
5388}
5389
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005390// A simple RAII class to disconnect from an ANativeWindow* when it goes out of scope
5391class WindowDisconnector {
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005392public:
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005393 WindowDisconnector(ANativeWindow* window, int api) : mWindow(window), mApi(api) {}
5394 ~WindowDisconnector() {
5395 native_window_api_disconnect(mWindow, mApi);
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005396 }
5397
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005398private:
5399 ANativeWindow* mWindow;
5400 const int mApi;
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005401};
5402
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005403status_t SurfaceFlinger::captureScreen(const sp<IBinder>& displayToken,
Robert Carr108b2c72019-04-02 16:32:58 -07005404 sp<GraphicBuffer>* outBuffer, bool& outCapturedSecureLayers,
5405 const Dataspace reqDataspace,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005406 const ui::PixelFormat reqPixelFormat, Rect sourceCrop,
chaviw0e3479f2018-09-10 16:49:30 -07005407 uint32_t reqWidth, uint32_t reqHeight,
5408 bool useIdentityTransform,
Robert Carrfa8855f2019-02-19 10:05:00 -08005409 ISurfaceComposer::Rotation rotation,
5410 bool captureSecureLayers) {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005411 ATRACE_CALL();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005412
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005413 if (!displayToken) return BAD_VALUE;
chaviwa76b2712017-09-20 12:02:26 -07005414
Chia-I Wuc80dcbb2018-08-24 15:34:02 -07005415 auto renderAreaRotation = fromSurfaceComposerRotation(rotation);
5416
Chia-I Wu20261cb2018-08-23 12:55:44 -07005417 sp<DisplayDevice> display;
5418 {
5419 Mutex::Autolock _l(mStateLock);
Garfield Tan3b1b8af2018-03-16 17:37:33 -07005420
Chia-I Wu20261cb2018-08-23 12:55:44 -07005421 display = getDisplayDeviceLocked(displayToken);
5422 if (!display) return BAD_VALUE;
5423
Chia-I Wucb023152018-08-28 12:57:23 -07005424 // set the requested width/height to the logical display viewport size
5425 // by default
5426 if (reqWidth == 0 || reqHeight == 0) {
5427 reqWidth = uint32_t(display->getViewport().width());
5428 reqHeight = uint32_t(display->getViewport().height());
Chia-I Wu20261cb2018-08-23 12:55:44 -07005429 }
Yiwei Zhang06a58e22018-08-20 16:42:23 -07005430 }
5431
Peiyong Lin0e003c92018-09-17 11:09:51 -07005432 DisplayRenderArea renderArea(display, sourceCrop, reqWidth, reqHeight, reqDataspace,
Robert Carrfa8855f2019-02-19 10:05:00 -08005433 renderAreaRotation, captureSecureLayers);
chaviwa76b2712017-09-20 12:02:26 -07005434
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08005435 auto traverseLayers = std::bind(&SurfaceFlinger::traverseLayersInDisplay, this, display,
5436 std::placeholders::_1);
Peiyong Lin0e003c92018-09-17 11:09:51 -07005437 return captureScreenCommon(renderArea, traverseLayers, outBuffer, reqPixelFormat,
Robert Carr108b2c72019-04-02 16:32:58 -07005438 useIdentityTransform, outCapturedSecureLayers);
chaviwa76b2712017-09-20 12:02:26 -07005439}
5440
Robert Carr866455f2019-04-02 16:28:26 -07005441status_t SurfaceFlinger::captureLayers(
5442 const sp<IBinder>& layerHandleBinder, sp<GraphicBuffer>* outBuffer,
5443 const Dataspace reqDataspace, const ui::PixelFormat reqPixelFormat, const Rect& sourceCrop,
5444 const std::unordered_set<sp<IBinder>, ISurfaceComposer::SpHash<IBinder>>& excludeHandles,
5445 float frameScale, bool childrenOnly) {
chaviwa76b2712017-09-20 12:02:26 -07005446 ATRACE_CALL();
5447
5448 class LayerRenderArea : public RenderArea {
5449 public:
Robert Carr578038f2018-03-09 12:25:24 -08005450 LayerRenderArea(SurfaceFlinger* flinger, const sp<Layer>& layer, const Rect crop,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005451 int32_t reqWidth, int32_t reqHeight, Dataspace reqDataSpace,
5452 bool childrenOnly)
5453 : RenderArea(reqWidth, reqHeight, CaptureFill::CLEAR, reqDataSpace),
Robert Carr578038f2018-03-09 12:25:24 -08005454 mLayer(layer),
5455 mCrop(crop),
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005456 mNeedsFiltering(false),
Robert Carr578038f2018-03-09 12:25:24 -08005457 mFlinger(flinger),
5458 mChildrenOnly(childrenOnly) {}
Peiyong Linefefaac2018-08-17 12:27:51 -07005459 const ui::Transform& getTransform() const override { return mTransform; }
Lloyd Pique0449b0f2018-12-20 16:23:45 -08005460 Rect getBounds() const override {
5461 const Layer::State& layerState(mLayer->getDrawingState());
5462 return mLayer->getBufferSize(layerState);
5463 }
Marissa Wall61c58622018-07-18 10:12:20 -07005464 int getHeight() const override {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08005465 return mLayer->getBufferSize(mLayer->getDrawingState()).getHeight();
Marissa Wall61c58622018-07-18 10:12:20 -07005466 }
Vishnu Nair88a11f22018-11-28 18:30:57 -08005467 int getWidth() const override {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08005468 return mLayer->getBufferSize(mLayer->getDrawingState()).getWidth();
Vishnu Nair88a11f22018-11-28 18:30:57 -08005469 }
chaviwa76b2712017-09-20 12:02:26 -07005470 bool isSecure() const override { return false; }
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005471 bool needsFiltering() const override { return mNeedsFiltering; }
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08005472 const sp<const DisplayDevice> getDisplayDevice() const override { return nullptr; }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005473 Rect getSourceCrop() const override {
5474 if (mCrop.isEmpty()) {
5475 return getBounds();
5476 } else {
5477 return mCrop;
5478 }
5479 }
Robert Carr578038f2018-03-09 12:25:24 -08005480 class ReparentForDrawing {
5481 public:
5482 const sp<Layer>& oldParent;
5483 const sp<Layer>& newParent;
5484
Vishnu Nair4351ad52019-02-11 14:13:02 -08005485 ReparentForDrawing(const sp<Layer>& oldParent, const sp<Layer>& newParent,
5486 const Rect& drawingBounds)
Robert Carr578038f2018-03-09 12:25:24 -08005487 : oldParent(oldParent), newParent(newParent) {
Vishnu Nair4351ad52019-02-11 14:13:02 -08005488 // Compute and cache the bounds for the new parent layer.
5489 newParent->computeBounds(drawingBounds.toFloatRect(), ui::Transform());
Robert Carr15eae092018-03-23 13:43:53 -07005490 oldParent->setChildrenDrawingParent(newParent);
Robert Carr578038f2018-03-09 12:25:24 -08005491 }
Vishnu Nairbce6ffd2019-02-14 10:58:59 -08005492 ~ReparentForDrawing() { oldParent->setChildrenDrawingParent(oldParent); }
Robert Carr578038f2018-03-09 12:25:24 -08005493 };
5494
5495 void render(std::function<void()> drawLayers) override {
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005496 const Rect sourceCrop = getSourceCrop();
5497 // no need to check rotation because there is none
5498 mNeedsFiltering = sourceCrop.width() != getReqWidth() ||
5499 sourceCrop.height() != getReqHeight();
5500
Robert Carr578038f2018-03-09 12:25:24 -08005501 if (!mChildrenOnly) {
5502 mTransform = mLayer->getTransform().inverse();
5503 drawLayers();
5504 } else {
5505 Rect bounds = getBounds();
Lloyd Pique90c115d2018-09-18 21:39:42 -07005506 screenshotParentLayer = mFlinger->getFactory().createContainerLayer(
Lloyd Pique42ab75e2018-09-12 20:46:03 -07005507 LayerCreationArgs(mFlinger, nullptr, String8("Screenshot Parent"),
Evan Roskya1f1e152019-01-24 16:17:46 -08005508 bounds.getWidth(), bounds.getHeight(), 0,
5509 LayerMetadata()));
Robert Carr578038f2018-03-09 12:25:24 -08005510
Vishnu Nair4351ad52019-02-11 14:13:02 -08005511 ReparentForDrawing reparent(mLayer, screenshotParentLayer, sourceCrop);
Robert Carr578038f2018-03-09 12:25:24 -08005512 drawLayers();
5513 }
5514 }
chaviwa76b2712017-09-20 12:02:26 -07005515
chaviwa76b2712017-09-20 12:02:26 -07005516 private:
chaviw7206d492017-11-10 16:16:12 -08005517 const sp<Layer> mLayer;
5518 const Rect mCrop;
Robert Carr578038f2018-03-09 12:25:24 -08005519
5520 // In the "childrenOnly" case we reparent the children to a screenshot
5521 // layer which has no properties set and which does not draw.
5522 sp<ContainerLayer> screenshotParentLayer;
Peiyong Linefefaac2018-08-17 12:27:51 -07005523 ui::Transform mTransform;
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005524 bool mNeedsFiltering;
Robert Carr578038f2018-03-09 12:25:24 -08005525
5526 SurfaceFlinger* mFlinger;
5527 const bool mChildrenOnly;
chaviwa76b2712017-09-20 12:02:26 -07005528 };
5529
Robert Carrc0df3122019-04-11 13:18:21 -07005530 int reqWidth = 0;
5531 int reqHeight = 0;
5532 sp<Layer> parent;
chaviw7206d492017-11-10 16:16:12 -08005533 Rect crop(sourceCrop);
Robert Carrc0df3122019-04-11 13:18:21 -07005534 std::unordered_set<sp<Layer>, ISurfaceComposer::SpHash<Layer>> excludeLayers;
chaviw7206d492017-11-10 16:16:12 -08005535
Robert Carrc0df3122019-04-11 13:18:21 -07005536 {
5537 Mutex::Autolock _l(mStateLock);
chaviw7206d492017-11-10 16:16:12 -08005538
Robert Carrc0df3122019-04-11 13:18:21 -07005539 parent = fromHandle(layerHandleBinder);
5540 if (parent == nullptr || parent->isRemovedFromCurrentState()) {
5541 ALOGE("captureLayers called with an invalid or removed parent");
5542 return NAME_NOT_FOUND;
5543 }
5544
5545 const int uid = IPCThreadState::self()->getCallingUid();
5546 const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
5547 if (!forSystem && parent->getCurrentState().flags & layer_state_t::eLayerSecure) {
5548 ALOGW("Attempting to capture secure layer: PERMISSION_DENIED");
5549 return PERMISSION_DENIED;
5550 }
5551
5552 if (sourceCrop.width() <= 0) {
5553 crop.left = 0;
5554 crop.right = parent->getBufferSize(parent->getCurrentState()).getWidth();
5555 }
5556
5557 if (sourceCrop.height() <= 0) {
5558 crop.top = 0;
5559 crop.bottom = parent->getBufferSize(parent->getCurrentState()).getHeight();
5560 }
5561 reqWidth = crop.width() * frameScale;
5562 reqHeight = crop.height() * frameScale;
5563
5564 for (const auto& handle : excludeHandles) {
5565 sp<Layer> excludeLayer = fromHandle(handle);
5566 if (excludeLayer != nullptr) {
5567 excludeLayers.emplace(excludeLayer);
5568 } else {
5569 ALOGW("Invalid layer handle passed as excludeLayer to captureLayers");
5570 return NAME_NOT_FOUND;
5571 }
5572 }
5573 } // mStateLock
chaviw7206d492017-11-10 16:16:12 -08005574
Chia-I Wu20261cb2018-08-23 12:55:44 -07005575 // really small crop or frameScale
5576 if (reqWidth <= 0) {
5577 reqWidth = 1;
5578 }
5579 if (reqHeight <= 0) {
5580 reqHeight = 1;
5581 }
5582
Robert Carr866455f2019-04-02 16:28:26 -07005583 LayerRenderArea renderArea(this, parent, crop, reqWidth, reqHeight, reqDataspace, childrenOnly);
5584 auto traverseLayers = [parent, childrenOnly,
5585 &excludeLayers](const LayerVector::Visitor& visitor) {
chaviwa76b2712017-09-20 12:02:26 -07005586 parent->traverseChildrenInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
5587 if (!layer->isVisible()) {
5588 return;
Robert Carr578038f2018-03-09 12:25:24 -08005589 } else if (childrenOnly && layer == parent.get()) {
5590 return;
chaviwa76b2712017-09-20 12:02:26 -07005591 }
Robert Carr866455f2019-04-02 16:28:26 -07005592
5593 sp<Layer> p = layer;
5594 while (p != nullptr) {
5595 if (excludeLayers.count(p) != 0) {
5596 return;
5597 }
5598 p = p->getParent();
5599 }
5600
chaviwa76b2712017-09-20 12:02:26 -07005601 visitor(layer);
5602 });
5603 };
Robert Carr108b2c72019-04-02 16:32:58 -07005604
5605 bool outCapturedSecureLayers = false;
5606 return captureScreenCommon(renderArea, traverseLayers, outBuffer, reqPixelFormat, false,
5607 outCapturedSecureLayers);
chaviwa76b2712017-09-20 12:02:26 -07005608}
5609
5610status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea,
5611 TraverseLayersFunction traverseLayers,
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005612 sp<GraphicBuffer>* outBuffer,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005613 const ui::PixelFormat reqPixelFormat,
Robert Carr108b2c72019-04-02 16:32:58 -07005614 bool useIdentityTransform,
5615 bool& outCapturedSecureLayers) {
chaviwa76b2712017-09-20 12:02:26 -07005616 ATRACE_CALL();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005617
Peiyong Lin0e003c92018-09-17 11:09:51 -07005618 // TODO(b/116112787) Make buffer usage a parameter.
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005619 const uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
5620 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
Lloyd Pique90c115d2018-09-18 21:39:42 -07005621 *outBuffer =
5622 getFactory().createGraphicBuffer(renderArea.getReqWidth(), renderArea.getReqHeight(),
5623 static_cast<android_pixel_format>(reqPixelFormat), 1,
5624 usage, "screenshot");
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005625
Robert Carr108b2c72019-04-02 16:32:58 -07005626 return captureScreenCommon(renderArea, traverseLayers, *outBuffer, useIdentityTransform,
5627 outCapturedSecureLayers);
Dan Stozaec460082018-12-17 15:35:09 -08005628}
5629
Kevin DuBois7cbcc372019-02-25 14:53:28 -08005630status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea,
5631 TraverseLayersFunction traverseLayers,
5632 const sp<GraphicBuffer>& buffer,
Robert Carr108b2c72019-04-02 16:32:58 -07005633 bool useIdentityTransform,
5634 bool& outCapturedSecureLayers) {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005635 // This mutex protects syncFd and captureResult for communication of the return values from the
5636 // main thread back to this Binder thread
5637 std::mutex captureMutex;
5638 std::condition_variable captureCondition;
5639 std::unique_lock<std::mutex> captureLock(captureMutex);
5640 int syncFd = -1;
5641 std::optional<status_t> captureResult;
5642
Robert Carr03480e22018-01-04 16:02:06 -08005643 const int uid = IPCThreadState::self()->getCallingUid();
5644 const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
5645
Dominik Laskowski8c001672018-05-30 16:52:06 -07005646 sp<LambdaMessage> message = new LambdaMessage([&] {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005647 // If there is a refresh pending, bug out early and tell the binder thread to try again
5648 // after the refresh.
5649 if (mRefreshPending) {
5650 ATRACE_NAME("Skipping screenshot for now");
5651 std::unique_lock<std::mutex> captureLock(captureMutex);
5652 captureResult = std::make_optional<status_t>(EAGAIN);
5653 captureCondition.notify_one();
5654 return;
5655 }
5656
5657 status_t result = NO_ERROR;
5658 int fd = -1;
5659 {
5660 Mutex::Autolock _l(mStateLock);
Dominik Laskowski8c001672018-05-30 16:52:06 -07005661 renderArea.render([&] {
Dan Stozaec460082018-12-17 15:35:09 -08005662 result = captureScreenImplLocked(renderArea, traverseLayers, buffer.get(),
Robert Carr108b2c72019-04-02 16:32:58 -07005663 useIdentityTransform, forSystem, &fd,
5664 outCapturedSecureLayers);
Robert Carr578038f2018-03-09 12:25:24 -08005665 });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005666 }
5667
5668 {
5669 std::unique_lock<std::mutex> captureLock(captureMutex);
5670 syncFd = fd;
5671 captureResult = std::make_optional<status_t>(result);
5672 captureCondition.notify_one();
5673 }
5674 });
5675
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005676 status_t result = postMessageAsync(message);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005677 if (result == NO_ERROR) {
Dominik Laskowski8c001672018-05-30 16:52:06 -07005678 captureCondition.wait(captureLock, [&] { return captureResult; });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005679 while (*captureResult == EAGAIN) {
5680 captureResult.reset();
5681 result = postMessageAsync(message);
5682 if (result != NO_ERROR) {
5683 return result;
5684 }
Dominik Laskowski8c001672018-05-30 16:52:06 -07005685 captureCondition.wait(captureLock, [&] { return captureResult; });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005686 }
5687 result = *captureResult;
5688 }
5689
5690 if (result == NO_ERROR) {
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005691 sync_wait(syncFd, -1);
5692 close(syncFd);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005693 }
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005694
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005695 return result;
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005696}
5697
chaviwa76b2712017-09-20 12:02:26 -07005698void SurfaceFlinger::renderScreenImplLocked(const RenderArea& renderArea,
Chia-I Wu1be50b52018-08-29 10:44:48 -07005699 TraverseLayersFunction traverseLayers,
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005700 ANativeWindowBuffer* buffer, bool useIdentityTransform,
5701 int* outSyncFd) {
Mathias Agopian180f10d2013-04-10 22:55:41 -07005702 ATRACE_CALL();
chaviwa76b2712017-09-20 12:02:26 -07005703
chaviwa76b2712017-09-20 12:02:26 -07005704 const auto reqWidth = renderArea.getReqWidth();
5705 const auto reqHeight = renderArea.getReqHeight();
Chia-I Wuf2aa3112018-08-27 14:54:37 -07005706 const auto rotation = renderArea.getRotationFlags();
Alec Mouriadb75f42019-03-28 21:42:24 -07005707 const auto transform = renderArea.getTransform();
5708 const auto sourceCrop = renderArea.getSourceCrop();
Dan Stozac1879002014-05-22 15:59:05 -07005709
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005710 renderengine::DisplaySettings clientCompositionDisplay;
5711 std::vector<renderengine::LayerSettings> clientCompositionLayers;
Romain Guy88d37dd2017-05-26 17:57:05 -07005712
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005713 // assume that bounds are never offset, and that they are the same as the
5714 // buffer bounds.
5715 clientCompositionDisplay.physicalDisplay = Rect(reqWidth, reqHeight);
Alec Mouriadb75f42019-03-28 21:42:24 -07005716 clientCompositionDisplay.clip = sourceCrop;
Lloyd Pique7e06e7f2019-03-15 18:36:44 -07005717 clientCompositionDisplay.globalTransform = transform.asMatrix4();
Alec Mouriadb75f42019-03-28 21:42:24 -07005718
5719 // Now take into account the rotation flag. We append a transform that
5720 // rotates the layer stack about the origin, then translate by buffer
5721 // boundaries to be in the right quadrant.
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005722 mat4 rotMatrix;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005723 int displacementX = 0;
5724 int displacementY = 0;
5725 float rot90InRadians = 2.0f * static_cast<float>(M_PI) / 4.0f;
5726 switch (rotation) {
5727 case ui::Transform::ROT_90:
5728 rotMatrix = mat4::rotate(rot90InRadians, vec3(0, 0, 1));
Alec Mouriadb75f42019-03-28 21:42:24 -07005729 displacementX = renderArea.getBounds().getHeight();
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005730 break;
5731 case ui::Transform::ROT_180:
5732 rotMatrix = mat4::rotate(rot90InRadians * 2.0f, vec3(0, 0, 1));
Alec Mouriadb75f42019-03-28 21:42:24 -07005733 displacementY = renderArea.getBounds().getWidth();
5734 displacementX = renderArea.getBounds().getHeight();
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005735 break;
5736 case ui::Transform::ROT_270:
5737 rotMatrix = mat4::rotate(rot90InRadians * 3.0f, vec3(0, 0, 1));
Alec Mouriadb75f42019-03-28 21:42:24 -07005738 displacementY = renderArea.getBounds().getWidth();
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005739 break;
5740 default:
5741 break;
5742 }
Alec Mouriadb75f42019-03-28 21:42:24 -07005743
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005744 // We need to transform the clipping window into the right spot.
5745 // First, rotate the clipping rectangle by the rotation hint to get the
5746 // right orientation
5747 const vec4 clipTL = vec4(sourceCrop.left, sourceCrop.top, 0, 1);
5748 const vec4 clipBR = vec4(sourceCrop.right, sourceCrop.bottom, 0, 1);
5749 const vec4 rotClipTL = rotMatrix * clipTL;
5750 const vec4 rotClipBR = rotMatrix * clipBR;
5751 const int newClipLeft = std::min(rotClipTL[0], rotClipBR[0]);
5752 const int newClipTop = std::min(rotClipTL[1], rotClipBR[1]);
5753 const int newClipRight = std::max(rotClipTL[0], rotClipBR[0]);
5754 const int newClipBottom = std::max(rotClipTL[1], rotClipBR[1]);
5755
5756 // Now reposition the clipping rectangle with the displacement vector
5757 // computed above.
5758 const mat4 displacementMat = mat4::translate(vec4(displacementX, displacementY, 0, 1));
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005759 clientCompositionDisplay.clip =
5760 Rect(newClipLeft + displacementX, newClipTop + displacementY,
5761 newClipRight + displacementX, newClipBottom + displacementY);
5762
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005763 mat4 clipTransform = displacementMat * rotMatrix;
Alec Mouriadb75f42019-03-28 21:42:24 -07005764 clientCompositionDisplay.globalTransform =
5765 clipTransform * clientCompositionDisplay.globalTransform;
5766
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005767 clientCompositionDisplay.outputDataspace = renderArea.getReqDataSpace();
5768 clientCompositionDisplay.maxLuminance = DisplayDevice::sDefaultMaxLumiance;
Mathias Agopian180f10d2013-04-10 22:55:41 -07005769
chaviw50da5042018-04-09 13:49:37 -07005770 const float alpha = RenderArea::getCaptureFillValue(renderArea.getCaptureFill());
Mathias Agopian180f10d2013-04-10 22:55:41 -07005771
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005772 renderengine::LayerSettings fillLayer;
5773 fillLayer.source.buffer.buffer = nullptr;
5774 fillLayer.source.solidColor = half3(0.0, 0.0, 0.0);
5775 fillLayer.geometry.boundaries = FloatRect(0.0, 0.0, 1.0, 1.0);
5776 fillLayer.alpha = half(alpha);
5777 clientCompositionLayers.push_back(fillLayer);
5778
5779 Region clearRegion = Region::INVALID_REGION;
chaviwa76b2712017-09-20 12:02:26 -07005780 traverseLayers([&](Layer* layer) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005781 renderengine::LayerSettings layerSettings;
5782 bool prepared = layer->prepareClientLayer(renderArea, useIdentityTransform, clearRegion,
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08005783 false, layerSettings);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005784 if (prepared) {
5785 clientCompositionLayers.push_back(layerSettings);
5786 }
chaviwa76b2712017-09-20 12:02:26 -07005787 });
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005788
5789 clientCompositionDisplay.clearRegion = clearRegion;
Alec Mouri6338c9d2019-02-07 16:57:51 -08005790 // Use an empty fence for the buffer fence, since we just created the buffer so
5791 // there is no need for synchronization with the GPU.
5792 base::unique_fd bufferFence;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005793 base::unique_fd drawFence;
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08005794 getRenderEngine().useProtectedContext(false);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005795 getRenderEngine().drawLayers(clientCompositionDisplay, clientCompositionLayers, buffer,
Alec Mourife0d72b2019-03-21 14:05:56 -07005796 /*useFramebufferCache=*/false, std::move(bufferFence), &drawFence);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005797
5798 *outSyncFd = drawFence.release();
Mathias Agopian180f10d2013-04-10 22:55:41 -07005799}
5800
chaviwa76b2712017-09-20 12:02:26 -07005801status_t SurfaceFlinger::captureScreenImplLocked(const RenderArea& renderArea,
5802 TraverseLayersFunction traverseLayers,
5803 ANativeWindowBuffer* buffer,
Robert Carr108b2c72019-04-02 16:32:58 -07005804 bool useIdentityTransform, bool forSystem,
5805 int* outSyncFd, bool& outCapturedSecureLayers) {
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005806 ATRACE_CALL();
5807
chaviwa76b2712017-09-20 12:02:26 -07005808 traverseLayers([&](Layer* layer) {
Robert Carr108b2c72019-04-02 16:32:58 -07005809 outCapturedSecureLayers =
5810 outCapturedSecureLayers || (layer->isVisible() && layer->isSecure());
chaviwa76b2712017-09-20 12:02:26 -07005811 });
Pablo Ceballosb5b35632016-02-23 11:18:51 -08005812
Robert Carr03480e22018-01-04 16:02:06 -08005813 // We allow the system server to take screenshots of secure layers for
5814 // use in situations like the Screen-rotation animation and place
5815 // the impetus on WindowManager to not persist them.
Robert Carr108b2c72019-04-02 16:32:58 -07005816 if (outCapturedSecureLayers && !forSystem) {
Pablo Ceballosb5b35632016-02-23 11:18:51 -08005817 ALOGW("FB is protected: PERMISSION_DENIED");
5818 return PERMISSION_DENIED;
5819 }
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005820 renderScreenImplLocked(renderArea, traverseLayers, buffer, useIdentityTransform, outSyncFd);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005821 return NO_ERROR;
Mathias Agopian74c40c02010-09-29 13:02:36 -07005822}
5823
chaviw95ef3c42019-02-14 10:55:09 -08005824void SurfaceFlinger::setInputWindowsFinished() {
5825 Mutex::Autolock _l(mStateLock);
5826
5827 mPendingSyncInputWindows = false;
5828 mTransactionCV.broadcast();
5829}
chaviw5f21a5e2019-02-14 10:00:34 -08005830
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07005831// ---------------------------------------------------------------------------
5832
Dan Stoza412903f2017-04-27 13:42:17 -07005833void SurfaceFlinger::State::traverseInZOrder(const LayerVector::Visitor& visitor) const {
5834 layersSortedByZ.traverseInZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07005835}
5836
Dan Stoza412903f2017-04-27 13:42:17 -07005837void SurfaceFlinger::State::traverseInReverseZOrder(const LayerVector::Visitor& visitor) const {
5838 layersSortedByZ.traverseInReverseZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07005839}
5840
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005841void SurfaceFlinger::traverseLayersInDisplay(const sp<const DisplayDevice>& display,
chaviwa76b2712017-09-20 12:02:26 -07005842 const LayerVector::Visitor& visitor) {
5843 // We loop through the first level of layers without traversing,
chaviw0e3479f2018-09-10 16:49:30 -07005844 // as we need to determine which layers belong to the requested display.
chaviwa76b2712017-09-20 12:02:26 -07005845 for (const auto& layer : mDrawingState.layersSortedByZ) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005846 if (!layer->belongsToDisplay(display->getLayerStack(), false)) {
chaviwa76b2712017-09-20 12:02:26 -07005847 continue;
5848 }
Chia-I Wuec2d9852017-11-21 09:21:01 -08005849 // relative layers are traversed in Layer::traverseInZOrder
chaviwa76b2712017-09-20 12:02:26 -07005850 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005851 if (!layer->belongsToDisplay(display->getLayerStack(), false)) {
Adrian Roos8acf5a02018-01-17 21:28:19 +01005852 return;
5853 }
chaviwa76b2712017-09-20 12:02:26 -07005854 if (!layer->isVisible()) {
5855 return;
5856 }
5857 visitor(layer);
5858 });
5859 }
5860}
5861
Dominik Laskowski22488f62019-03-28 09:53:04 -07005862void SurfaceFlinger::setAllowedDisplayConfigsInternal(const sp<DisplayDevice>& display,
5863 const std::vector<int32_t>& allowedConfigs) {
5864 if (!display->isPrimary()) {
Ady Abraham838de062019-02-04 10:24:03 -08005865 return;
5866 }
5867
5868 ALOGV("Updating allowed configs");
Dominik Laskowski22488f62019-03-28 09:53:04 -07005869 mAllowedDisplayConfigs = DisplayConfigs(allowedConfigs.begin(), allowedConfigs.end());
Ady Abraham838de062019-02-04 10:24:03 -08005870
Ady Abrahamde3b67b2019-03-25 16:38:10 -07005871 // Set the highest allowed config by iterating backwards on available refresh rates
Dominik Laskowski22488f62019-03-28 09:53:04 -07005872 const auto& refreshRates = mRefreshRateConfigs.getRefreshRates();
Ady Abrahamde3b67b2019-03-25 16:38:10 -07005873 for (auto iter = refreshRates.crbegin(); iter != refreshRates.crend(); ++iter) {
Dominik Laskowski22488f62019-03-28 09:53:04 -07005874 if (iter->second && isDisplayConfigAllowed(iter->second->configId)) {
Ady Abrahamde3b67b2019-03-25 16:38:10 -07005875 ALOGV("switching to config %d", iter->second->configId);
Dominik Laskowski22488f62019-03-28 09:53:04 -07005876 setDesiredActiveConfig(
5877 {iter->first, iter->second->configId, Scheduler::ConfigEvent::Changed});
Ady Abrahamde3b67b2019-03-25 16:38:10 -07005878 break;
Ady Abraham97d04232019-03-05 19:48:12 -08005879 }
5880 }
Ady Abraham838de062019-02-04 10:24:03 -08005881}
5882
Dominik Laskowski22488f62019-03-28 09:53:04 -07005883status_t SurfaceFlinger::setAllowedDisplayConfigs(const sp<IBinder>& displayToken,
Ady Abraham838de062019-02-04 10:24:03 -08005884 const std::vector<int32_t>& allowedConfigs) {
5885 ATRACE_CALL();
5886
Dominik Laskowski22488f62019-03-28 09:53:04 -07005887 if (!displayToken || allowedConfigs.empty()) {
Ady Abraham838de062019-02-04 10:24:03 -08005888 return BAD_VALUE;
5889 }
5890
Ady Abraham34392f72019-04-10 11:29:27 -07005891 if (mDebugDisplayConfigSetByBackdoor) {
5892 // ignore this request as config is overridden by backdoor
5893 return NO_ERROR;
5894 }
5895
Ady Abraham838de062019-02-04 10:24:03 -08005896 postMessageSync(new LambdaMessage([&]() NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowski22488f62019-03-28 09:53:04 -07005897 const auto display = getDisplayDeviceLocked(displayToken);
5898 if (!display) {
5899 ALOGE("Attempt to set allowed display configs for invalid display token %p",
5900 displayToken.get());
5901 } else if (display->isVirtual()) {
5902 ALOGW("Attempt to set allowed display configs for virtual display");
5903 } else {
5904 setAllowedDisplayConfigsInternal(display, allowedConfigs);
5905 }
Ady Abraham838de062019-02-04 10:24:03 -08005906 }));
Dominik Laskowski22488f62019-03-28 09:53:04 -07005907
Ady Abraham838de062019-02-04 10:24:03 -08005908 return NO_ERROR;
5909}
5910
Dominik Laskowski22488f62019-03-28 09:53:04 -07005911status_t SurfaceFlinger::getAllowedDisplayConfigs(const sp<IBinder>& displayToken,
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08005912 std::vector<int32_t>* outAllowedConfigs) {
5913 ATRACE_CALL();
5914
Dominik Laskowski22488f62019-03-28 09:53:04 -07005915 if (!displayToken || !outAllowedConfigs) {
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08005916 return BAD_VALUE;
5917 }
5918
Dominik Laskowski22488f62019-03-28 09:53:04 -07005919 Mutex::Autolock lock(mStateLock);
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08005920
Dominik Laskowski4f1dd8c2019-04-17 15:54:30 -07005921 const auto display = getDisplayDeviceLocked(displayToken);
5922 if (!display) {
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08005923 return NAME_NOT_FOUND;
5924 }
5925
Dominik Laskowski4f1dd8c2019-04-17 15:54:30 -07005926 if (display->isPrimary()) {
5927 outAllowedConfigs->assign(mAllowedDisplayConfigs.begin(), mAllowedDisplayConfigs.end());
5928 }
5929
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08005930 return NO_ERROR;
5931}
5932
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005933void SurfaceFlinger::SetInputWindowsListener::onSetInputWindowsFinished() {
chaviw291d88a2019-02-14 10:33:58 -08005934 mFlinger->setInputWindowsFinished();
5935}
5936
Robert Carrc0df3122019-04-11 13:18:21 -07005937sp<Layer> SurfaceFlinger::fromHandle(const sp<IBinder>& handle) {
5938 BBinder *b = handle->localBinder();
5939 if (b == nullptr) {
5940 return nullptr;
5941 }
5942 auto it = mLayersByLocalBinderToken.find(b);
5943 if (it != mLayersByLocalBinderToken.end()) {
5944 return it->second.promote();
5945 }
5946 return nullptr;
5947}
5948
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005949} // namespace android
Lloyd Pique074e8122018-07-26 12:57:23 -07005950
Mathias Agopian3f844832013-08-07 21:24:32 -07005951#if defined(__gl_h_)
5952#error "don't include gl/gl.h in this file"
5953#endif
5954
5955#if defined(__gl2_h_)
5956#error "don't include gl2/gl2.h in this file"
Chia-I Wu767fcf72017-11-30 22:07:38 -08005957#endif