blob: 95787b6b0f5db8a4b07495e547b370fd2bd5b97f [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>
Ady Abrahama3b08ef2019-07-15 18:43:10 -070051#include <gui/DebugEGLImageTracker.h>
52
Andy McFadden4803b742012-09-24 19:07:20 -070053#include <gui/GuiConfig.h>
Jamie Gennis1a4d8832012-08-02 20:11:05 -070054#include <gui/IDisplayEventConnection.h>
Alec Mouri0a9c7b82018-11-16 13:05:25 -080055#include <gui/IProducerListener.h>
Kalle Raitaa099a242017-01-11 11:17:29 -080056#include <gui/LayerDebugInfo.h>
Mathias Agopiane3c697f2013-02-14 17:11:02 -080057#include <gui/Surface.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070058#include <input/IInputFlinger.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070059#include <renderengine/RenderEngine.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070060#include <ui/ColorSpace.h>
61#include <ui/DebugUtils.h>
62#include <ui/DisplayInfo.h>
63#include <ui/DisplayStatInfo.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070064#include <ui/GraphicBufferAllocator.h>
65#include <ui/PixelFormat.h>
Andy McFadden4803b742012-09-24 19:07:20 -070066#include <ui/UiConfig.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080067#include <utils/StopWatch.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070068#include <utils/String16.h>
69#include <utils/String8.h>
Yusuke Sato0a688f52015-07-30 23:05:39 -070070#include <utils/Timers.h>
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080071#include <utils/Trace.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070072#include <utils/misc.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080073
Mathias Agopian921e6ac2012-07-23 23:11:29 -070074#include <private/android_filesystem_config.h>
Mathias Agopianca088332013-03-28 17:44:13 -070075#include <private/gui/SyncFeatures.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080076
Robert Carr578038f2018-03-09 12:25:24 -080077#include "BufferLayer.h"
Marissa Wallfd668622018-05-10 10:21:13 -070078#include "BufferQueueLayer.h"
Marissa Wall61c58622018-07-18 10:12:20 -070079#include "BufferStateLayer.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +020080#include "Client.h"
Robert Carr578038f2018-03-09 12:25:24 -080081#include "ColorLayer.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +020082#include "Colorizer.h"
Robert Carr578038f2018-03-09 12:25:24 -080083#include "ContainerLayer.h"
Robert Carr578038f2018-03-09 12:25:24 -080084#include "DisplayDevice.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080085#include "Layer.h"
Robert Carr1f0a16a2016-10-24 16:27:39 -070086#include "LayerVector.h"
Robert Carr1db73f62016-12-21 12:58:51 -080087#include "MonitoredProducer.h"
Lloyd Pique22098362018-09-13 11:46:49 -070088#include "NativeWindowSurface.h"
Ady Abraham03b02dd2019-03-21 15:40:11 -070089#include "RefreshRateOverlay.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070090#include "StartPropertySetThread.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080091#include "SurfaceFlinger.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070092#include "SurfaceInterceptor.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080093
Steven Thomasb02664d2017-07-26 18:48:28 -070094#include "DisplayHardware/ComposerHal.h"
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -070095#include "DisplayHardware/DisplayIdentification.h"
Mathias Agopiana4912602012-07-12 14:25:33 -070096#include "DisplayHardware/FramebufferSurface.h"
Mathias Agopiana350ff92010-08-10 17:14:02 -070097#include "DisplayHardware/HWComposer.h"
Jesse Hall99c7dbb2013-03-14 14:29:29 -070098#include "DisplayHardware/VirtualDisplaySurface.h"
Mathias Agopianff2ed702013-09-01 21:36:12 -070099#include "Effects/Daltonizer.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700100#include "RegionSamplingThread.h"
Ana Krulecfefcb582018-08-07 14:22:37 -0700101#include "Scheduler/DispSync.h"
Ana Krulec241cf832018-08-10 15:03:23 -0700102#include "Scheduler/DispSyncSource.h"
Ana Krulecfefcb582018-08-07 14:22:37 -0700103#include "Scheduler/EventControlThread.h"
104#include "Scheduler/EventThread.h"
Ana Krulec47454452018-08-14 11:04:14 -0700105#include "Scheduler/InjectVSyncSource.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -0700106#include "Scheduler/MessageQueue.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700107#include "Scheduler/PhaseOffsets.h"
Ana Krulec98b5b242018-08-10 15:03:23 -0700108#include "Scheduler/Scheduler.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800109#include "TimeStats/TimeStats.h"
Ana Krulecfefcb582018-08-07 14:22:37 -0700110
Mathias Agopianff2ed702013-09-01 21:36:12 -0700111#include <cutils/compiler.h>
Mathias Agopian875d8e12013-06-07 15:35:48 -0700112
David Sodman7e4ae112018-02-09 15:02:28 -0800113#include "android-base/stringprintf.h"
114
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900115#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
Iris Chang7501ed62018-04-30 14:45:42 +0800116#include <android/hardware/configstore/1.1/ISurfaceFlingerConfigs.h>
117#include <android/hardware/configstore/1.1/types.h>
Ady Abraham8532d012019-05-08 14:50:56 -0700118#include <android/hardware/power/1.0/IPower.h>
Jaesoo Lee43518572017-01-23 19:03:16 +0900119#include <configstore/Utils.h>
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900120
chaviw1d044282017-09-27 12:19:28 -0700121#include <layerproto/LayerProtoParser.h>
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900122#include "SurfaceFlingerProperties.h"
chaviw1d044282017-09-27 12:19:28 -0700123
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800124namespace android {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700125
Jaesoo Lee43518572017-01-23 19:03:16 +0900126using namespace android::hardware::configstore;
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900127using namespace android::hardware::configstore::V1_0;
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900128using namespace android::sysprop;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -0800129
Ady Abraham8532d012019-05-08 14:50:56 -0700130using android::hardware::power::V1_0::PowerHint;
Yiwei Zhang5434a782018-12-05 18:06:32 -0800131using base::StringAppendF;
Peiyong Lin9f034472018-03-28 15:29:00 -0700132using ui::ColorMode;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700133using ui::Dataspace;
Daniel Solomon42d04562019-01-20 21:03:19 -0800134using ui::DisplayPrimaries;
Peiyong Lin62665892018-04-16 11:07:44 -0700135using ui::Hdr;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700136using ui::RenderIntent;
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900137
Steven Thomasb02664d2017-07-26 18:48:28 -0700138namespace {
Peiyong Linfca547f2018-07-09 13:03:33 -0700139
140#pragma clang diagnostic push
141#pragma clang diagnostic error "-Wswitch-enum"
142
143bool isWideColorMode(const ColorMode colorMode) {
144 switch (colorMode) {
145 case ColorMode::DISPLAY_P3:
146 case ColorMode::ADOBE_RGB:
147 case ColorMode::DCI_P3:
148 case ColorMode::BT2020:
Valerie Hau9758ae02018-10-09 16:05:09 -0700149 case ColorMode::DISPLAY_BT2020:
Peiyong Linfca547f2018-07-09 13:03:33 -0700150 case ColorMode::BT2100_PQ:
151 case ColorMode::BT2100_HLG:
152 return true;
153 case ColorMode::NATIVE:
154 case ColorMode::STANDARD_BT601_625:
155 case ColorMode::STANDARD_BT601_625_UNADJUSTED:
156 case ColorMode::STANDARD_BT601_525:
157 case ColorMode::STANDARD_BT601_525_UNADJUSTED:
158 case ColorMode::STANDARD_BT709:
159 case ColorMode::SRGB:
160 return false;
161 }
162 return false;
163}
164
Chia-I Wuc80dcbb2018-08-24 15:34:02 -0700165ui::Transform::orientation_flags fromSurfaceComposerRotation(ISurfaceComposer::Rotation rotation) {
166 switch (rotation) {
167 case ISurfaceComposer::eRotateNone:
168 return ui::Transform::ROT_0;
169 case ISurfaceComposer::eRotate90:
170 return ui::Transform::ROT_90;
171 case ISurfaceComposer::eRotate180:
172 return ui::Transform::ROT_180;
173 case ISurfaceComposer::eRotate270:
174 return ui::Transform::ROT_270;
175 }
176 ALOGE("Invalid rotation passed to captureScreen(): %d\n", rotation);
177 return ui::Transform::ROT_0;
178}
179
Peiyong Linfca547f2018-07-09 13:03:33 -0700180#pragma clang diagnostic pop
181
Steven Thomasb02664d2017-07-26 18:48:28 -0700182class ConditionalLock {
183public:
184 ConditionalLock(Mutex& mutex, bool lock) : mMutex(mutex), mLocked(lock) {
185 if (lock) {
186 mMutex.lock();
187 }
188 }
189 ~ConditionalLock() { if (mLocked) mMutex.unlock(); }
190private:
191 Mutex& mMutex;
192 bool mLocked;
193};
Peiyong Linfca547f2018-07-09 13:03:33 -0700194
Peiyong Lin9d846a52018-11-05 13:18:20 -0800195// Currently we only support V0_SRGB and DISPLAY_P3 as composition preference.
196bool validateCompositionDataspace(Dataspace dataspace) {
197 return dataspace == Dataspace::V0_SRGB || dataspace == Dataspace::DISPLAY_P3;
198}
199
Steven Thomasb02664d2017-07-26 18:48:28 -0700200} // namespace anonymous
201
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800202// ---------------------------------------------------------------------------
203
Mathias Agopian99b49842011-06-27 16:05:52 -0700204const String16 sHardwareTest("android.permission.HARDWARE_TEST");
205const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER");
206const String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER");
207const String16 sDump("android.permission.DUMP");
208
209// ---------------------------------------------------------------------------
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700210int64_t SurfaceFlinger::dispSyncPresentTimeOffset;
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700211bool SurfaceFlinger::useHwcForRgbToYuv;
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800212uint64_t SurfaceFlinger::maxVirtualDisplaySize;
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800213bool SurfaceFlinger::hasSyncFramework;
Steven Thomas050b2c82017-03-06 11:45:16 -0800214bool SurfaceFlinger::useVrFlinger;
Fabien Sanglard1971b632017-03-10 14:50:03 -0800215int64_t SurfaceFlinger::maxFrameBufferAcquiredBuffers;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600216bool SurfaceFlinger::hasWideColorDisplay;
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700217int SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientationDefault;
Peiyong Lin13effd12018-07-24 17:01:47 -0700218bool SurfaceFlinger::useColorManagement;
Peiyong Linb3839ad2018-09-05 15:37:19 -0700219bool SurfaceFlinger::useContextPriority;
Peiyong Linc6780972018-10-28 15:24:08 -0700220Dataspace SurfaceFlinger::defaultCompositionDataspace = Dataspace::V0_SRGB;
221ui::PixelFormat SurfaceFlinger::defaultCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
222Dataspace SurfaceFlinger::wideColorGamutCompositionDataspace = Dataspace::V0_SRGB;
223ui::PixelFormat SurfaceFlinger::wideColorGamutCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
Mathias Agopian99b49842011-06-27 16:05:52 -0700224
Kalle Raitaa099a242017-01-11 11:17:29 -0800225std::string getHwcServiceName() {
226 char value[PROPERTY_VALUE_MAX] = {};
227 property_get("debug.sf.hwc_service_name", value, "default");
228 ALOGI("Using HWComposer service: '%s'", value);
229 return std::string(value);
230}
231
232bool useTrebleTestingOverride() {
233 char value[PROPERTY_VALUE_MAX] = {};
234 property_get("debug.sf.treble_testing_override", value, "false");
235 ALOGI("Treble testing override: '%s'", value);
236 return std::string(value) == "true";
237}
238
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800239std::string decodeDisplayColorSetting(DisplayColorSetting displayColorSetting) {
240 switch(displayColorSetting) {
241 case DisplayColorSetting::MANAGED:
Chia-I Wu0d711262018-05-21 15:19:35 -0700242 return std::string("Managed");
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800243 case DisplayColorSetting::UNMANAGED:
Chia-I Wu0d711262018-05-21 15:19:35 -0700244 return std::string("Unmanaged");
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800245 case DisplayColorSetting::ENHANCED:
Chia-I Wu0d711262018-05-21 15:19:35 -0700246 return std::string("Enhanced");
247 default:
248 return std::string("Unknown ") +
249 std::to_string(static_cast<int>(displayColorSetting));
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800250 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800251}
252
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700253SurfaceFlingerBE::SurfaceFlingerBE() : mHwcServiceName(getHwcServiceName()) {}
David Sodmanbc815282017-11-05 18:57:52 -0800254
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700255SurfaceFlinger::SurfaceFlinger(Factory& factory, SkipInitializationTag)
256 : mFactory(factory),
257 mPhaseOffsets(mFactory.createPhaseOffsets()),
258 mInterceptor(mFactory.createSurfaceInterceptor(this)),
259 mTimeStats(mFactory.createTimeStats()),
260 mEventQueue(mFactory.createMessageQueue()),
261 mCompositionEngine(mFactory.createCompositionEngine()) {}
Lloyd Piqueac648ee2018-01-17 13:42:24 -0800262
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700263SurfaceFlinger::SurfaceFlinger(Factory& factory) : SurfaceFlinger(factory, SkipInitialization) {
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800264 ALOGI("SurfaceFlinger is starting");
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800265
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900266 hasSyncFramework = running_without_sync_framework(true);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800267
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900268 dispSyncPresentTimeOffset = present_time_offset_from_vsync_ns(0);
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700269
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900270 useHwcForRgbToYuv = force_hwc_copy_for_virtual_displays(false);
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700271
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900272 maxVirtualDisplaySize = max_virtual_display_dimension(0);
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800273
Steven Thomas050b2c82017-03-06 11:45:16 -0800274 // Vr flinger is only enabled on Daydream ready devices.
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900275 useVrFlinger = use_vr_flinger(false);
Steven Thomas050b2c82017-03-06 11:45:16 -0800276
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900277 maxFrameBufferAcquiredBuffers = max_frame_buffer_acquired_buffers(2);
Fabien Sanglard1971b632017-03-10 14:50:03 -0800278
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900279 hasWideColorDisplay = has_wide_color_display(false);
Peiyong Lin0256f722018-08-31 15:45:10 -0700280
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900281 useColorManagement = use_color_management(false);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600282
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900283 mDefaultCompositionDataspace =
284 static_cast<ui::Dataspace>(default_composition_dataspace(Dataspace::V0_SRGB));
Peiyong Lin8cabfc32019-06-14 14:25:43 -0700285 mWideColorGamutCompositionDataspace = static_cast<ui::Dataspace>(wcg_composition_dataspace(
286 hasWideColorDisplay ? Dataspace::DISPLAY_P3 : Dataspace::V0_SRGB));
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900287 defaultCompositionDataspace = mDefaultCompositionDataspace;
288 wideColorGamutCompositionDataspace = mWideColorGamutCompositionDataspace;
289 defaultCompositionPixelFormat = static_cast<ui::PixelFormat>(
290 default_composition_pixel_format(ui::PixelFormat::RGBA_8888));
291 wideColorGamutCompositionPixelFormat =
292 static_cast<ui::PixelFormat>(wcg_composition_pixel_format(ui::PixelFormat::RGBA_8888));
Peiyong Linb3839ad2018-09-05 15:37:19 -0700293
Yichi Chenda901bf2019-06-28 14:58:27 +0800294 mColorSpaceAgnosticDataspace =
295 static_cast<ui::Dataspace>(color_space_agnostic_dataspace(Dataspace::UNKNOWN));
296
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900297 useContextPriority = use_context_priority(true);
Iris Chang7501ed62018-04-30 14:45:42 +0800298
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900299 auto tmpPrimaryDisplayOrientation = primary_display_orientation(
300 SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_0);
301 switch (tmpPrimaryDisplayOrientation) {
302 case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_90:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700303 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientation90;
Iris Chang7501ed62018-04-30 14:45:42 +0800304 break;
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900305 case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_180:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700306 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientation180;
Iris Chang7501ed62018-04-30 14:45:42 +0800307 break;
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900308 case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_270:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700309 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientation270;
Iris Chang7501ed62018-04-30 14:45:42 +0800310 break;
311 default:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700312 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientationDefault;
Iris Chang7501ed62018-04-30 14:45:42 +0800313 break;
314 }
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700315 ALOGV("Primary Display Orientation is set to %2d.", SurfaceFlinger::primaryDisplayOrientation);
Iris Chang7501ed62018-04-30 14:45:42 +0800316
Sundong Ahn85131bd2019-02-18 15:51:53 +0900317 mInternalDisplayPrimaries = sysprop::getDisplayNativePrimaries();
Daniel Solomon42d04562019-01-20 21:03:19 -0800318
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800319 // debugging stuff...
320 char value[PROPERTY_VALUE_MAX];
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700321
Mathias Agopianb4b17302013-03-20 18:36:41 -0700322 property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");
Mathias Agopian50210b92013-03-21 21:13:21 -0700323 mGpuToCpuSupported = !atoi(value);
Mathias Agopianb4b17302013-03-20 18:36:41 -0700324
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800325 property_get("debug.sf.showupdates", value, "0");
326 mDebugRegion = atoi(value);
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700327
Mathias Agopianc1d359d2012-08-04 20:09:03 -0700328 ALOGI_IF(mDebugRegion, "showupdates enabled");
Orion Hodson34397da2019-02-04 09:36:10 +0000329
330 // DDMS debugging deprecated (b/120782499)
331 property_get("debug.sf.ddms", value, "0");
332 int debugDdms = atoi(value);
333 ALOGI_IF(debugDdms, "DDMS debugging not supported");
Dan Stozac5da2712016-07-20 15:38:12 -0700334
335 property_get("debug.sf.disable_backpressure", value, "0");
336 mPropagateBackpressure = !atoi(value);
337 ALOGI_IF(!mPropagateBackpressure, "Disabling backpressure propagation");
Dan Stoza8cf150a2016-08-02 10:27:31 -0700338
Ady Abraham4658e112019-07-22 13:07:26 -0700339 property_get("debug.sf.enable_gl_backpressure", value, "0");
340 mPropagateBackpressureClientComposition = atoi(value);
341 ALOGI_IF(mPropagateBackpressureClientComposition,
342 "Enabling backpressure propagation for Client Composition");
343
Fabien Sanglard642b23d2017-02-09 12:29:39 -0800344 property_get("debug.sf.enable_hwc_vds", value, "0");
345 mUseHwcVirtualDisplays = atoi(value);
Chia-I Wu11d10612018-06-21 15:41:13 +0800346 ALOGI_IF(mUseHwcVirtualDisplays, "Enabling HWC virtual displays");
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800347
Yiwei Zhangb770ed32018-12-17 17:44:28 -0800348 property_get("ro.sf.disable_triple_buffer", value, "0");
Fabien Sanglardc65dafa2017-02-07 14:06:39 -0800349 mLayerTripleBufferingDisabled = atoi(value);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800350 ALOGI_IF(mLayerTripleBufferingDisabled, "Disabling Triple Buffering");
Romain Guy3054f002017-06-05 18:38:53 -0700351
Yiwei Zhang243b3782018-05-15 17:40:04 -0700352 const size_t defaultListSize = MAX_LAYERS;
Dan Stoza0a0158c2018-03-16 13:38:54 -0700353 auto listSize = property_get_int32("debug.sf.max_igbp_list_size", int32_t(defaultListSize));
354 mMaxGraphicBufferProducerListSize = (listSize > 0) ? size_t(listSize) : defaultListSize;
355
Ana Krulece5a06e02019-03-06 17:09:03 -0800356 mUseSmart90ForVideo = use_smart_90_for_video(false);
Ana Krulecba13ab32019-02-20 14:14:12 -0800357 property_get("debug.sf.use_smart_90_for_video", value, "0");
Ana Krulece5a06e02019-03-06 17:09:03 -0800358
359 int int_value = atoi(value);
360 if (int_value) {
361 mUseSmart90ForVideo = true;
362 }
Ana Krulecba13ab32019-02-20 14:14:12 -0800363
Dan Stozaec460082018-12-17 15:35:09 -0800364 property_get("debug.sf.luma_sampling", value, "1");
365 mLumaSampling = atoi(value);
366
Ana Krulec757f63a2019-01-25 10:46:18 -0800367 const auto [early, gl, late] = mPhaseOffsets->getCurrentOffsets();
Ady Abraham45e4e362019-06-07 18:20:51 -0700368 mVsyncModulator.setPhaseOffsets(early, gl, late,
369 mPhaseOffsets->getOffsetThresholdForNextVsync());
Dan Stoza84d619e2018-03-28 17:07:36 -0700370
Romain Guy11d63f42017-07-20 12:47:14 -0700371 // We should be reading 'persist.sys.sf.color_saturation' here
372 // but since /data may be encrypted, we need to wait until after vold
373 // comes online to attempt to read the property. The property is
374 // instead read after the boot animation
Kalle Raitaa099a242017-01-11 11:17:29 -0800375
376 if (useTrebleTestingOverride()) {
377 // Without the override SurfaceFlinger cannot connect to HIDL
378 // services that are not listed in the manifests. Considered
379 // deriving the setting from the set service name, but it
380 // would be brittle if the name that's not 'default' is used
381 // for production purposes later on.
382 setenv("TREBLE_TESTING_OVERRIDE", "true", true);
383 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800384}
385
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800386void SurfaceFlinger::onFirstRef()
387{
Lloyd Pique3fcdef12018-01-22 17:14:00 -0800388 mEventQueue->init(this);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800389}
390
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700391SurfaceFlinger::~SurfaceFlinger() = default;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800392
Dan Stozac7014012014-02-14 15:03:43 -0800393void SurfaceFlinger::binderDied(const wp<IBinder>& /* who */)
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800394{
395 // the window manager died on us. prepare its eulogy.
396
Andy McFadden13a082e2012-08-24 10:16:42 -0700397 // restore initial conditions (default device unblank, etc)
398 initializeDisplays();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800399
400 // restart the boot-animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700401 startBootAnim();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800402}
403
Robert Carr1db73f62016-12-21 12:58:51 -0800404static sp<ISurfaceComposerClient> initClient(const sp<Client>& client) {
Mathias Agopian96f08192010-06-02 23:28:45 -0700405 status_t err = client->initCheck();
406 if (err == NO_ERROR) {
Robert Carr1db73f62016-12-21 12:58:51 -0800407 return client;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800408 }
Robert Carr1db73f62016-12-21 12:58:51 -0800409 return nullptr;
410}
411
412sp<ISurfaceComposerClient> SurfaceFlinger::createConnection() {
413 return initClient(new Client(this));
414}
415
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700416sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName,
417 bool secure)
Mathias Agopiane57f2922012-08-09 16:29:12 -0700418{
419 class DisplayToken : public BBinder {
420 sp<SurfaceFlinger> flinger;
421 virtual ~DisplayToken() {
422 // no more references, this display must be terminated
423 Mutex::Autolock _l(flinger->mStateLock);
424 flinger->mCurrentState.displays.removeItem(this);
425 flinger->setTransactionFlags(eDisplayTransactionNeeded);
426 }
427 public:
Chih-Hung Hsiehc4067912016-05-03 14:03:27 -0700428 explicit DisplayToken(const sp<SurfaceFlinger>& flinger)
Mathias Agopiane57f2922012-08-09 16:29:12 -0700429 : flinger(flinger) {
430 }
431 };
432
433 sp<BBinder> token = new DisplayToken(this);
434
435 Mutex::Autolock _l(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700436 // Display ID is assigned when virtual display is allocated by HWC.
437 DisplayDeviceState state;
438 state.isSecure = secure;
439 state.displayName = displayName;
440 mCurrentState.displays.add(token, state);
441 mInterceptor->saveDisplayCreation(state);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700442 return token;
443}
444
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700445void SurfaceFlinger::destroyDisplay(const sp<IBinder>& displayToken) {
Jesse Hall6c913be2013-08-08 12:15:49 -0700446 Mutex::Autolock _l(mStateLock);
447
Dominik Laskowski075d3172018-05-24 15:50:06 -0700448 ssize_t index = mCurrentState.displays.indexOfKey(displayToken);
449 if (index < 0) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700450 ALOGE("destroyDisplay: Invalid display token %p", displayToken.get());
Jesse Hall6c913be2013-08-08 12:15:49 -0700451 return;
452 }
453
Dominik Laskowski075d3172018-05-24 15:50:06 -0700454 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
455 if (!state.isVirtual()) {
Jesse Hall6c913be2013-08-08 12:15:49 -0700456 ALOGE("destroyDisplay called for non-virtual display");
457 return;
458 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700459 mInterceptor->saveDisplayDeletion(state.sequenceId);
460 mCurrentState.displays.removeItemsAt(index);
Jesse Hall6c913be2013-08-08 12:15:49 -0700461 setTransactionFlags(eDisplayTransactionNeeded);
462}
463
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800464std::vector<PhysicalDisplayId> SurfaceFlinger::getPhysicalDisplayIds() const {
465 Mutex::Autolock lock(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700466
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800467 const auto internalDisplayId = getInternalDisplayIdLocked();
468 if (!internalDisplayId) {
469 return {};
Dominik Laskowski075d3172018-05-24 15:50:06 -0700470 }
471
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800472 std::vector<PhysicalDisplayId> displayIds;
473 displayIds.reserve(mPhysicalDisplayTokens.size());
474 displayIds.push_back(internalDisplayId->value);
475
476 for (const auto& [id, token] : mPhysicalDisplayTokens) {
477 if (id != *internalDisplayId) {
478 displayIds.push_back(id.value);
479 }
Mathias Agopiane57f2922012-08-09 16:29:12 -0700480 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700481
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800482 return displayIds;
483}
484
485sp<IBinder> SurfaceFlinger::getPhysicalDisplayToken(PhysicalDisplayId displayId) const {
486 Mutex::Autolock lock(mStateLock);
487 return getPhysicalDisplayTokenLocked(DisplayId{displayId});
Mathias Agopiane57f2922012-08-09 16:29:12 -0700488}
489
Ady Abraham37965d42018-11-01 13:43:32 -0700490status_t SurfaceFlinger::getColorManagement(bool* outGetColorManagement) const {
491 if (!outGetColorManagement) {
492 return BAD_VALUE;
493 }
494 *outGetColorManagement = useColorManagement;
495 return NO_ERROR;
Ady Abraham2a6ab2a2018-10-26 14:25:30 -0700496}
497
Lloyd Pique441d5042018-10-18 16:49:51 -0700498HWComposer& SurfaceFlinger::getHwComposer() const {
499 return mCompositionEngine->getHwComposer();
500}
501
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700502renderengine::RenderEngine& SurfaceFlinger::getRenderEngine() const {
503 return mCompositionEngine->getRenderEngine();
504}
505
Lloyd Pique70d91362018-10-18 16:02:55 -0700506compositionengine::CompositionEngine& SurfaceFlinger::getCompositionEngine() const {
507 return *mCompositionEngine.get();
508}
509
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800510void SurfaceFlinger::bootFinished()
511{
Wei Wangf9b05ee2017-07-19 20:59:39 -0700512 if (mStartPropertySetThread->join() != NO_ERROR) {
513 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800514 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800515 const nsecs_t now = systemTime();
516 const nsecs_t duration = now - mBootTime;
Steve Blocka19954a2012-01-04 20:05:49 +0000517 ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700518
519 // wait patiently for the window manager death
520 const String16 name("window");
Steven Morelanda904bb92019-07-02 17:37:23 -0700521 mWindowManager = defaultServiceManager()->getService(name);
522 if (mWindowManager != 0) {
523 mWindowManager->linkToDeath(static_cast<IBinder::DeathRecipient*>(this));
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700524 }
Robert Carr720e5062018-07-30 17:45:14 -0700525 sp<IBinder> input(defaultServiceManager()->getService(
526 String16("inputflinger")));
527 if (input == nullptr) {
528 ALOGE("Failed to link to input service");
529 } else {
530 mInputFlinger = interface_cast<IInputFlinger>(input);
531 }
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700532
Steven Thomas050b2c82017-03-06 11:45:16 -0800533 if (mVrFlinger) {
534 mVrFlinger->OnBootFinished();
535 }
536
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700537 // stop boot animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700538 // formerly we would just kill the process, but we now ask it to exit so it
539 // can choose where to stop the animation.
540 property_set("service.bootanim.exit", "1");
Yusuke Sato0a688f52015-07-30 23:05:39 -0700541
542 const int LOGTAG_SF_STOP_BOOTANIM = 60110;
543 LOG_EVENT_LONG(LOGTAG_SF_STOP_BOOTANIM,
544 ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
Romain Guy11d63f42017-07-20 12:47:14 -0700545
Ana Krulecbd6654b2019-02-15 15:18:15 -0800546 postMessageAsync(new LambdaMessage([this]() NO_THREAD_SAFETY_ANALYSIS {
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800547 readPersistentProperties();
548 mBootStage = BootStage::FINISHED;
Ana Krulecbd6654b2019-02-15 15:18:15 -0800549
Ady Abraham97d04232019-03-05 19:48:12 -0800550 // set the refresh rate according to the policy
Alec Mouri0a1cc962019-03-14 12:33:02 -0700551 const auto& performanceRefreshRate =
Dominik Laskowski22488f62019-03-28 09:53:04 -0700552 mRefreshRateConfigs.getRefreshRate(RefreshRateType::PERFORMANCE);
Ady Abraham97d04232019-03-05 19:48:12 -0800553
Dominik Laskowski22488f62019-03-28 09:53:04 -0700554 if (performanceRefreshRate && isDisplayConfigAllowed(performanceRefreshRate->configId)) {
Ana Krulec8d3e4f32019-03-05 10:40:33 -0800555 setRefreshRateTo(RefreshRateType::PERFORMANCE, Scheduler::ConfigEvent::None);
Ana Krulecbd6654b2019-02-15 15:18:15 -0800556 } else {
Ana Krulec8d3e4f32019-03-05 10:40:33 -0800557 setRefreshRateTo(RefreshRateType::DEFAULT, Scheduler::ConfigEvent::None);
Ana Krulecbd6654b2019-02-15 15:18:15 -0800558 }
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800559 }));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800560}
561
Dan Stoza436ccf32018-06-21 12:10:12 -0700562uint32_t SurfaceFlinger::getNewTexture() {
563 {
564 std::lock_guard lock(mTexturePoolMutex);
565 if (!mTexturePool.empty()) {
566 uint32_t name = mTexturePool.back();
567 mTexturePool.pop_back();
568 ATRACE_INT("TexturePoolSize", mTexturePool.size());
569 return name;
570 }
571
572 // The pool was too small, so increase it for the future
573 ++mTexturePoolSize;
574 }
575
576 // The pool was empty, so we need to get a new texture name directly using a
577 // blocking call to the main thread
578 uint32_t name = 0;
579 postMessageSync(new LambdaMessage([&]() { getRenderEngine().genTextures(1, &name); }));
580 return name;
581}
582
Mathias Agopian3f844832013-08-07 21:24:32 -0700583void SurfaceFlinger::deleteTextureAsync(uint32_t texture) {
Dan Stoza67765d82019-05-07 14:58:27 -0700584 std::lock_guard lock(mTexturePoolMutex);
585 // We don't change the pool size, so the fix-up logic in postComposition will decide whether
586 // to actually delete this or not based on mTexturePoolSize
587 mTexturePool.push_back(texture);
588 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700589}
590
Wei Wangf9b05ee2017-07-19 20:59:39 -0700591// Do not call property_set on main thread which will be blocked by init
592// Use StartPropertySetThread instead.
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700593void SurfaceFlinger::init() {
Mathias Agopiana4912602012-07-12 14:25:33 -0700594 ALOGI( "SurfaceFlinger's main thread ready to run. "
595 "Initializing graphics H/W...");
596
Ana Krulec757f63a2019-01-25 10:46:18 -0800597 ALOGI("Phase offset NS: %" PRId64 "", mPhaseOffsets->getCurrentAppOffset());
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900598
Steven Thomasb02664d2017-07-26 18:48:28 -0700599 Mutex::Autolock _l(mStateLock);
Steven Thomasb02664d2017-07-26 18:48:28 -0700600 // start the EventThread
Ana Krulecc2870422019-01-29 19:00:58 -0800601 mScheduler =
Ady Abraham09bd3922019-04-08 10:44:56 -0700602 getFactory().createScheduler([this](bool enabled) { setPrimaryVsyncEnabled(enabled); },
603 mRefreshRateConfigs);
Ana Krulecc2870422019-01-29 19:00:58 -0800604 auto resyncCallback =
605 mScheduler->makeResyncCallback(std::bind(&SurfaceFlinger::getVsyncPeriod, this));
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800606
Ana Krulecc2870422019-01-29 19:00:58 -0800607 mAppConnectionHandle =
Ady Abraham45e4e362019-06-07 18:20:51 -0700608 mScheduler->createConnection("app", mVsyncModulator.getOffsets().app,
609 mPhaseOffsets->getOffsetThresholdForNextVsync(),
Ana Krulecc2870422019-01-29 19:00:58 -0800610 resyncCallback,
611 impl::EventThread::InterceptVSyncsCallback());
Ady Abraham45e4e362019-06-07 18:20:51 -0700612 mSfConnectionHandle =
613 mScheduler->createConnection("sf", mVsyncModulator.getOffsets().sf,
614 mPhaseOffsets->getOffsetThresholdForNextVsync(),
615 resyncCallback, [this](nsecs_t timestamp) {
616 mInterceptor->saveVSyncEvent(timestamp);
617 });
Ana Krulecc2870422019-01-29 19:00:58 -0800618
619 mEventQueue->setEventConnection(mScheduler->getEventConnection(mSfConnectionHandle));
620 mVsyncModulator.setSchedulerAndHandles(mScheduler.get(), mAppConnectionHandle.get(),
621 mSfConnectionHandle.get());
622
Kevin DuBois413287f2019-02-25 08:46:47 -0800623 mRegionSamplingThread =
624 new RegionSamplingThread(*this, *mScheduler,
625 RegionSamplingThread::EnvironmentTimingTunables());
626
Steven Thomasb02664d2017-07-26 18:48:28 -0700627 // Get a RenderEngine for the given display / config (can't fail)
Peiyong Lin13effd12018-07-24 17:01:47 -0700628 int32_t renderEngineFeature = 0;
Peiyong Lin833074a2018-08-28 11:53:54 -0700629 renderEngineFeature |= (useColorManagement ?
630 renderengine::RenderEngine::USE_COLOR_MANAGEMENT : 0);
Peiyong Linb3839ad2018-09-05 15:37:19 -0700631 renderEngineFeature |= (useContextPriority ?
632 renderengine::RenderEngine::USE_HIGH_PRIORITY_CONTEXT : 0);
Peiyong Lin6a043d52019-04-01 17:18:21 -0700633 renderEngineFeature |=
634 (enable_protected_contents(false) ? renderengine::RenderEngine::ENABLE_PROTECTED_CONTEXT
635 : 0);
Peiyong Lin0256f722018-08-31 15:45:10 -0700636
637 // TODO(b/77156734): We need to stop casting and use HAL types when possible.
Alec Mourida4cf3b2019-02-12 15:33:01 -0800638 // Sending maxFrameBufferAcquiredBuffers as the cache size is tightly tuned to single-display.
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700639 mCompositionEngine->setRenderEngine(
Peiyong Linc6780972018-10-28 15:24:08 -0700640 renderengine::RenderEngine::create(static_cast<int32_t>(defaultCompositionPixelFormat),
Alec Mourida4cf3b2019-02-12 15:33:01 -0800641 renderEngineFeature, maxFrameBufferAcquiredBuffers));
Steven Thomasb02664d2017-07-26 18:48:28 -0700642
643 LOG_ALWAYS_FATAL_IF(mVrFlingerRequestsDisplay,
644 "Starting with vr flinger active is not currently supported.");
Lloyd Pique441d5042018-10-18 16:49:51 -0700645 mCompositionEngine->setHwComposer(getFactory().createHWComposer(getBE().mHwcServiceName));
646 mCompositionEngine->getHwComposer().registerCallback(this, getBE().mComposerSequenceId);
Lloyd Piqueba04e622017-12-14 17:11:26 -0800647 // Process any initial hotplug and resulting display changes.
648 processDisplayHotplugEventsLocked();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700649 const auto display = getDefaultDisplayDeviceLocked();
650 LOG_ALWAYS_FATAL_IF(!display, "Missing internal display after registering composer callback.");
Dominik Laskowski075d3172018-05-24 15:50:06 -0700651 LOG_ALWAYS_FATAL_IF(!getHwComposer().isConnected(*display->getId()),
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700652 "Internal display is disconnected.");
Jesse Hall692c7232012-11-08 15:41:56 -0800653
Steven Thomas050b2c82017-03-06 11:45:16 -0800654 if (useVrFlinger) {
Dominik Laskowski8c001672018-05-30 16:52:06 -0700655 auto vrFlingerRequestDisplayCallback = [this](bool requestDisplay) {
Steven Thomasbe6cbae2017-09-28 15:30:23 -0700656 // This callback is called from the vr flinger dispatch thread. We
657 // need to call signalTransaction(), which requires holding
658 // mStateLock when we're not on the main thread. Acquiring
659 // mStateLock from the vr flinger dispatch thread might trigger a
660 // deadlock in surface flinger (see b/66916578), so post a message
661 // to be handled on the main thread instead.
Dominik Laskowski8c001672018-05-30 16:52:06 -0700662 postMessageAsync(new LambdaMessage([=] {
Steven Thomasbe6cbae2017-09-28 15:30:23 -0700663 ALOGI("VR request display mode: requestDisplay=%d", requestDisplay);
664 mVrFlingerRequestsDisplay = requestDisplay;
665 signalTransaction();
Dominik Laskowski8c001672018-05-30 16:52:06 -0700666 }));
Steven Thomas050b2c82017-03-06 11:45:16 -0800667 };
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700668 mVrFlinger = dvr::VrFlinger::Create(getHwComposer().getComposer(),
669 getHwComposer()
Dominik Laskowski075d3172018-05-24 15:50:06 -0700670 .fromPhysicalDisplayId(*display->getId())
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700671 .value_or(0),
672 vrFlingerRequestDisplayCallback);
Steven Thomas050b2c82017-03-06 11:45:16 -0800673 if (!mVrFlinger) {
674 ALOGE("Failed to start vrflinger");
675 }
676 }
677
Mathias Agopian92a979a2012-08-02 18:32:23 -0700678 // initialize our drawing state
679 mDrawingState = mCurrentState;
Mathias Agopian86303202012-07-24 22:46:10 -0700680
Andy McFadden13a082e2012-08-24 10:16:42 -0700681 // set initial conditions (e.g. unblank default device)
682 initializeDisplays();
683
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700684 getRenderEngine().primeCache();
Dan Stoza4e637772016-07-28 13:31:51 -0700685
Wei Wangf9b05ee2017-07-19 20:59:39 -0700686 // Inform native graphics APIs whether the present timestamp is supported:
Lloyd Pique90c115d2018-09-18 21:39:42 -0700687
688 const bool presentFenceReliable =
689 !getHwComposer().hasCapability(HWC2::Capability::PresentFenceIsNotReliable);
690 mStartPropertySetThread = getFactory().createStartPropertySetThread(presentFenceReliable);
Wei Wangf9b05ee2017-07-19 20:59:39 -0700691
692 if (mStartPropertySetThread->Start() != NO_ERROR) {
693 ALOGE("Run StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800694 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800695
Alec Mouri93bc83d2019-04-17 14:47:43 -0700696 mScheduler->setChangeRefreshRateCallback(
697 [this](RefreshRateType type, Scheduler::ConfigEvent event) {
698 Mutex::Autolock lock(mStateLock);
699 setRefreshRateTo(type, event);
700 });
Alec Mouri7f015182019-07-11 13:56:22 -0700701 mScheduler->setGetCurrentRefreshRateTypeCallback([this] {
702 Mutex::Autolock lock(mStateLock);
703 const auto display = getDefaultDisplayDeviceLocked();
704 if (!display) {
705 // If we don't have a default display the fallback to the default
706 // refresh rate type
707 return RefreshRateType::DEFAULT;
708 }
709
710 const int configId = display->getActiveConfig();
711 for (const auto& [type, refresh] : mRefreshRateConfigs.getRefreshRates()) {
712 if (refresh && refresh->configId == configId) {
713 return type;
714 }
715 }
716 // This should never happen, but just gracefully fallback to default.
717 return RefreshRateType::DEFAULT;
718 });
Alec Mouridc28b372019-04-18 21:17:13 -0700719 mScheduler->setGetVsyncPeriodCallback([this] {
720 Mutex::Autolock lock(mStateLock);
721 return getVsyncPeriod();
722 });
Ady Abraham09bd3922019-04-08 10:44:56 -0700723
Dominik Laskowski22488f62019-03-28 09:53:04 -0700724 mRefreshRateConfigs.populate(getHwComposer().getConfigs(*display->getId()));
725 mRefreshRateStats.setConfigMode(getHwComposer().getActiveConfigIndex(*display->getId()));
Ana Krulec7d1d6832018-12-27 11:10:09 -0800726
Dan Stoza9e56aa02015-11-02 13:00:03 -0800727 ALOGV("Done initializing");
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700728}
729
Romain Guy11d63f42017-07-20 12:47:14 -0700730void SurfaceFlinger::readPersistentProperties() {
Chia-I Wu28f320b2018-05-03 11:02:56 -0700731 Mutex::Autolock _l(mStateLock);
732
Romain Guy11d63f42017-07-20 12:47:14 -0700733 char value[PROPERTY_VALUE_MAX];
734
735 property_get("persist.sys.sf.color_saturation", value, "1.0");
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800736 mGlobalSaturationFactor = atof(value);
Chia-I Wu28f320b2018-05-03 11:02:56 -0700737 updateColorMatrixLocked();
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800738 ALOGV("Saturation is set to %.2f", mGlobalSaturationFactor);
Romain Guy54f154a2017-10-24 21:40:32 +0100739
740 property_get("persist.sys.sf.native_mode", value, "0");
Chia-I Wu0d711262018-05-21 15:19:35 -0700741 mDisplayColorSetting = static_cast<DisplayColorSetting>(atoi(value));
Peiyong Lina3ea5592019-02-10 14:45:00 -0800742
743 property_get("persist.sys.sf.color_mode", value, "0");
744 mForceColorMode = static_cast<ColorMode>(atoi(value));
Romain Guy11d63f42017-07-20 12:47:14 -0700745}
746
Mathias Agopiana67e4182012-06-19 17:26:12 -0700747void SurfaceFlinger::startBootAnim() {
Wei Wangb254fa32017-01-31 17:43:23 -0800748 // Start boot animation service by setting a property mailbox
749 // if property setting thread is already running, Start() will be just a NOP
Wei Wangf9b05ee2017-07-19 20:59:39 -0700750 mStartPropertySetThread->Start();
Wei Wangb254fa32017-01-31 17:43:23 -0800751 // Wait until property was set
Wei Wangf9b05ee2017-07-19 20:59:39 -0700752 if (mStartPropertySetThread->join() != NO_ERROR) {
753 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800754 }
Mathias Agopiana67e4182012-06-19 17:26:12 -0700755}
756
Mathias Agopian875d8e12013-06-07 15:35:48 -0700757size_t SurfaceFlinger::getMaxTextureSize() const {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700758 return getRenderEngine().getMaxTextureSize();
Mathias Agopiana4912602012-07-12 14:25:33 -0700759}
760
Mathias Agopian875d8e12013-06-07 15:35:48 -0700761size_t SurfaceFlinger::getMaxViewportDims() const {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700762 return getRenderEngine().getMaxViewportDims();
Mathias Agopiana4912602012-07-12 14:25:33 -0700763}
764
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800765// ----------------------------------------------------------------------------
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800766
Jamie Gennis582270d2011-08-17 18:19:00 -0700767bool SurfaceFlinger::authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800768 const sp<IGraphicBufferProducer>& bufferProducer) const {
Jamie Gennis134f0422011-03-08 12:18:54 -0800769 Mutex::Autolock _l(mStateLock);
Robert Carr0d480722017-01-10 16:42:54 -0800770 return authenticateSurfaceTextureLocked(bufferProducer);
771}
772
773bool SurfaceFlinger::authenticateSurfaceTextureLocked(
774 const sp<IGraphicBufferProducer>& bufferProducer) const {
Marco Nelissen097ca272014-11-14 08:01:01 -0800775 sp<IBinder> surfaceTextureBinder(IInterface::asBinder(bufferProducer));
Dan Stoza101d8dc2018-02-27 15:42:25 -0800776 return mGraphicBufferProducerList.count(surfaceTextureBinder.get()) > 0;
Jamie Gennis134f0422011-03-08 12:18:54 -0800777}
778
Brian Anderson6b376712017-04-04 10:51:39 -0700779status_t SurfaceFlinger::getSupportedFrameTimestamps(
780 std::vector<FrameEvent>* outSupported) const {
781 *outSupported = {
782 FrameEvent::REQUESTED_PRESENT,
783 FrameEvent::ACQUIRE,
784 FrameEvent::LATCH,
785 FrameEvent::FIRST_REFRESH_START,
786 FrameEvent::LAST_REFRESH_START,
787 FrameEvent::GPU_COMPOSITION_DONE,
788 FrameEvent::DEQUEUE_READY,
789 FrameEvent::RELEASE,
790 };
Steven Thomas6d8110b2017-08-31 18:24:21 -0700791 ConditionalLock _l(mStateLock,
792 std::this_thread::get_id() != mMainThreadId);
Brian Anderson6b376712017-04-04 10:51:39 -0700793 if (!getHwComposer().hasCapability(
794 HWC2::Capability::PresentFenceIsNotReliable)) {
795 outSupported->push_back(FrameEvent::DISPLAY_PRESENT);
796 }
797 return NO_ERROR;
798}
799
Dominik Laskowski22488f62019-03-28 09:53:04 -0700800status_t SurfaceFlinger::getDisplayConfigs(const sp<IBinder>& displayToken,
801 Vector<DisplayInfo>* configs) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700802 if (!displayToken || !configs) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700803 return BAD_VALUE;
804 }
805
Dominik Laskowski22488f62019-03-28 09:53:04 -0700806 Mutex::Autolock lock(mStateLock);
807
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800808 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700809 if (!displayId) {
810 return NAME_NOT_FOUND;
Mathias Agopianc666cae2012-07-25 18:56:13 -0700811 }
Mathias Agopian8b736f12012-08-13 17:54:26 -0700812
Mathias Agopian8b736f12012-08-13 17:54:26 -0700813 // TODO: Not sure if display density should handled by SF any longer
814 class Density {
Hernan Liatis57568932018-08-16 17:07:08 -0700815 static float getDensityFromProperty(char const* propName) {
Mathias Agopian8b736f12012-08-13 17:54:26 -0700816 char property[PROPERTY_VALUE_MAX];
Hernan Liatis57568932018-08-16 17:07:08 -0700817 float density = 0.0f;
Peiyong Lin566a3b42018-01-09 18:22:43 -0800818 if (property_get(propName, property, nullptr) > 0) {
Hernan Liatis57568932018-08-16 17:07:08 -0700819 density = strtof(property, nullptr);
Mathias Agopian8b736f12012-08-13 17:54:26 -0700820 }
821 return density;
822 }
823 public:
Hernan Liatis57568932018-08-16 17:07:08 -0700824 static float getEmuDensity() {
Mathias Agopian8b736f12012-08-13 17:54:26 -0700825 return getDensityFromProperty("qemu.sf.lcd_density"); }
Hernan Liatis57568932018-08-16 17:07:08 -0700826 static float getBuildDensity() {
Mathias Agopian8b736f12012-08-13 17:54:26 -0700827 return getDensityFromProperty("ro.sf.lcd_density"); }
828 };
Mathias Agopian1604f772012-09-18 21:54:42 -0700829
Dan Stoza7f7da322014-05-02 15:26:25 -0700830 configs->clear();
Mathias Agopian1604f772012-09-18 21:54:42 -0700831
Dominik Laskowski075d3172018-05-24 15:50:06 -0700832 for (const auto& hwConfig : getHwComposer().getConfigs(*displayId)) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700833 DisplayInfo info = DisplayInfo();
834
Dan Stoza9e56aa02015-11-02 13:00:03 -0800835 float xdpi = hwConfig->getDpiX();
836 float ydpi = hwConfig->getDpiY();
Dan Stoza7f7da322014-05-02 15:26:25 -0700837
Yiwei Zhang27de5df2018-08-23 17:04:51 -0700838 info.w = hwConfig->getWidth();
839 info.h = hwConfig->getHeight();
840 // Default display viewport to display width and height
841 info.viewportW = info.w;
842 info.viewportH = info.h;
843
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800844 if (displayId == getInternalDisplayIdLocked()) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700845 // The density of the device is provided by a build property
846 float density = Density::getBuildDensity() / 160.0f;
847 if (density == 0) {
848 // the build doesn't provide a density -- this is wrong!
849 // use xdpi instead
850 ALOGE("ro.sf.lcd_density must be defined as a build property");
851 density = xdpi / 160.0f;
852 }
853 if (Density::getEmuDensity()) {
854 // if "qemu.sf.lcd_density" is specified, it overrides everything
855 xdpi = ydpi = density = Density::getEmuDensity();
856 density /= 160.0f;
857 }
858 info.density = density;
859
860 // TODO: this needs to go away (currently needed only by webkit)
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700861 const auto display = getDefaultDisplayDeviceLocked();
862 info.orientation = display ? display->getOrientation() : 0;
Yiwei Zhang27de5df2018-08-23 17:04:51 -0700863
864 // This is for screenrecord
865 const Rect viewport = display->getViewport();
866 if (viewport.isValid()) {
867 info.viewportW = uint32_t(viewport.getWidth());
868 info.viewportH = uint32_t(viewport.getHeight());
869 }
Dan Stoza7f7da322014-05-02 15:26:25 -0700870 } else {
871 // TODO: where should this value come from?
872 static const int TV_DENSITY = 213;
873 info.density = TV_DENSITY / 160.0f;
874 info.orientation = 0;
875 }
876
Dan Stoza7f7da322014-05-02 15:26:25 -0700877 info.xdpi = xdpi;
878 info.ydpi = ydpi;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800879 info.fps = 1e9 / hwConfig->getVsyncPeriod();
Ady Abraham796beb02019-04-11 15:23:07 -0700880 const auto refreshRateType = mRefreshRateConfigs.getRefreshRateType(hwConfig->getId());
881 const auto offset = mPhaseOffsets->getOffsetsForRefreshRate(refreshRateType);
882 info.appVsyncOffset = offset.late.app;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800883
Andy McFadden91b2ca82014-06-13 14:04:23 -0700884 // This is how far in advance a buffer must be queued for
885 // presentation at a given time. If you want a buffer to appear
886 // on the screen at time N, you must submit the buffer before
887 // (N - presentationDeadline).
888 //
889 // Normally it's one full refresh period (to give SF a chance to
890 // latch the buffer), but this can be reduced by configuring a
891 // DispSync offset. Any additional delays introduced by the hardware
892 // composer or panel must be accounted for here.
893 //
894 // We add an additional 1ms to allow for processing time and
895 // differences between the ideal and actual refresh rate.
Ady Abraham796beb02019-04-11 15:23:07 -0700896 info.presentationDeadline = hwConfig->getVsyncPeriod() - offset.late.sf + 1000000;
Dan Stoza7f7da322014-05-02 15:26:25 -0700897
898 // All non-virtual displays are currently considered secure.
899 info.secure = true;
900
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800901 if (displayId == getInternalDisplayIdLocked() &&
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700902 primaryDisplayOrientation & DisplayState::eOrientationSwapMask) {
Iris Chang7501ed62018-04-30 14:45:42 +0800903 std::swap(info.w, info.h);
904 }
905
Michael Wright28f24d02016-07-12 13:30:53 -0700906 configs->push_back(info);
Mathias Agopian8b736f12012-08-13 17:54:26 -0700907 }
908
Dan Stoza7f7da322014-05-02 15:26:25 -0700909 return NO_ERROR;
910}
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700911
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700912status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>&, DisplayStatInfo* stats) {
913 if (!stats) {
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700914 return BAD_VALUE;
915 }
916
Ana Krulecc2870422019-01-29 19:00:58 -0800917 mScheduler->getDisplayStatInfo(stats);
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700918 return NO_ERROR;
919}
920
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700921int SurfaceFlinger::getActiveConfig(const sp<IBinder>& displayToken) {
922 const auto display = getDisplayDevice(displayToken);
923 if (!display) {
924 ALOGE("getActiveConfig: Invalid display token %p", displayToken.get());
Jinguang Dong9f8b9ae2016-11-29 13:55:57 +0800925 return BAD_VALUE;
926 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700927
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700928 return display->getActiveConfig();
Dan Stoza7f7da322014-05-02 15:26:25 -0700929}
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700930
Ady Abraham03b02dd2019-03-21 15:40:11 -0700931void SurfaceFlinger::setDesiredActiveConfig(const ActiveConfigInfo& info) {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800932 ATRACE_CALL();
Ana Krulec7d1d6832018-12-27 11:10:09 -0800933
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800934 // Don't check against the current mode yet. Worst case we set the desired
Ady Abraham9360a222019-02-27 17:05:30 -0800935 // config twice. However event generation config might have changed so we need to update it
936 // accordingly
Ady Abrahamb838aed2019-02-12 15:30:16 -0800937 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Ady Abraham03b02dd2019-03-21 15:40:11 -0700938 const Scheduler::ConfigEvent prevConfig = mDesiredActiveConfig.event;
939 mDesiredActiveConfig = info;
940 mDesiredActiveConfig.event = mDesiredActiveConfig.event | prevConfig;
Ady Abrahamb838aed2019-02-12 15:30:16 -0800941
942 if (!mDesiredActiveConfigChanged) {
Ady Abrahamb838aed2019-02-12 15:30:16 -0800943 // This will trigger HWC refresh without resetting the idle timer.
944 repaintEverythingForHWC();
Alec Mouri754c98a2019-03-18 18:53:42 -0700945 // Start receiving vsync samples now, so that we can detect a period
946 // switch.
947 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
Ady Abraham53852a52019-05-28 18:07:44 -0700948 // As we called to set period, we will call to onRefreshRateChangeCompleted once
949 // DispSync model is locked.
950 mVsyncModulator.onRefreshRateChangeInitiated();
Alec Mouri754c98a2019-03-18 18:53:42 -0700951 mPhaseOffsets->setRefreshRateType(info.type);
952 const auto [early, gl, late] = mPhaseOffsets->getCurrentOffsets();
Ady Abraham45e4e362019-06-07 18:20:51 -0700953 mVsyncModulator.setPhaseOffsets(early, gl, late,
954 mPhaseOffsets->getOffsetThresholdForNextVsync());
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800955 }
Ady Abrahamb838aed2019-02-12 15:30:16 -0800956 mDesiredActiveConfigChanged = true;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700957
958 if (mRefreshRateOverlay) {
959 mRefreshRateOverlay->changeRefreshRate(mDesiredActiveConfig.type);
960 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800961}
962
963status_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& displayToken, int mode) {
964 ATRACE_CALL();
Ady Abraham838de062019-02-04 10:24:03 -0800965
966 std::vector<int32_t> allowedConfig;
967 allowedConfig.push_back(mode);
968
969 return setAllowedDisplayConfigs(displayToken, allowedConfig);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800970}
971
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800972void SurfaceFlinger::setActiveConfigInternal() {
973 ATRACE_CALL();
974
Dominik Laskowski22488f62019-03-28 09:53:04 -0700975 const auto display = getDefaultDisplayDeviceLocked();
976 if (!display) {
977 return;
978 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800979
Dominik Laskowski22488f62019-03-28 09:53:04 -0700980 std::lock_guard<std::mutex> lock(mActiveConfigLock);
981 mRefreshRateStats.setConfigMode(mUpcomingActiveConfig.configId);
982
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800983 display->setActiveConfig(mUpcomingActiveConfig.configId);
984
Alec Mouri754c98a2019-03-18 18:53:42 -0700985 mPhaseOffsets->setRefreshRateType(mUpcomingActiveConfig.type);
Alec Mouri1c9e82b2019-03-07 12:24:05 -0800986 const auto [early, gl, late] = mPhaseOffsets->getCurrentOffsets();
Ady Abraham45e4e362019-06-07 18:20:51 -0700987 mVsyncModulator.setPhaseOffsets(early, gl, late,
988 mPhaseOffsets->getOffsetThresholdForNextVsync());
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800989 ATRACE_INT("ActiveConfigMode", mUpcomingActiveConfig.configId);
Dominik Laskowski22488f62019-03-28 09:53:04 -0700990
Ana Krulec8d3e4f32019-03-05 10:40:33 -0800991 if (mUpcomingActiveConfig.event != Scheduler::ConfigEvent::None) {
Ady Abraham447052e2019-02-13 16:07:27 -0800992 mScheduler->onConfigChanged(mAppConnectionHandle, display->getId()->value,
993 mUpcomingActiveConfig.configId);
994 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800995}
996
Ady Abraham53852a52019-05-28 18:07:44 -0700997void SurfaceFlinger::desiredActiveConfigChangeDone() {
998 std::lock_guard<std::mutex> lock(mActiveConfigLock);
999 mDesiredActiveConfig.event = Scheduler::ConfigEvent::None;
1000 mDesiredActiveConfigChanged = false;
Ady Abraham53852a52019-05-28 18:07:44 -07001001
1002 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
1003 mPhaseOffsets->setRefreshRateType(mUpcomingActiveConfig.type);
1004 const auto [early, gl, late] = mPhaseOffsets->getCurrentOffsets();
Ady Abraham45e4e362019-06-07 18:20:51 -07001005 mVsyncModulator.setPhaseOffsets(early, gl, late,
1006 mPhaseOffsets->getOffsetThresholdForNextVsync());
Ady Abraham53852a52019-05-28 18:07:44 -07001007}
1008
Dominik Laskowski22488f62019-03-28 09:53:04 -07001009bool SurfaceFlinger::performSetActiveConfig() {
Alec Mourife3dc942019-02-12 14:19:18 -08001010 ATRACE_CALL();
Ady Abrahamb838aed2019-02-12 15:30:16 -08001011 if (mCheckPendingFence) {
Ady Abrahambe0f9482019-04-24 15:41:53 -07001012 if (previousFrameMissed()) {
Ady Abrahamb838aed2019-02-12 15:30:16 -08001013 // fence has not signaled yet. wait for the next invalidate
Ady Abraham8532d012019-05-08 14:50:56 -07001014 mEventQueue->invalidate();
Ady Abrahamb838aed2019-02-12 15:30:16 -08001015 return true;
1016 }
1017
1018 // We received the present fence from the HWC, so we assume it successfully updated
1019 // the config, hence we update SF.
1020 mCheckPendingFence = false;
1021 setActiveConfigInternal();
1022 }
1023
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001024 // Store the local variable to release the lock.
1025 ActiveConfigInfo desiredActiveConfig;
1026 {
1027 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Ady Abrahamb838aed2019-02-12 15:30:16 -08001028 if (!mDesiredActiveConfigChanged) {
1029 return false;
1030 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001031 desiredActiveConfig = mDesiredActiveConfig;
1032 }
1033
Dominik Laskowski22488f62019-03-28 09:53:04 -07001034 const auto display = getDefaultDisplayDeviceLocked();
Ady Abrahamb838aed2019-02-12 15:30:16 -08001035 if (!display || display->getActiveConfig() == desiredActiveConfig.configId) {
1036 // display is not valid or we are already in the requested mode
1037 // on both cases there is nothing left to do
Ady Abraham53852a52019-05-28 18:07:44 -07001038 desiredActiveConfigChangeDone();
Ady Abrahamb838aed2019-02-12 15:30:16 -08001039 return false;
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001040 }
Ady Abrahamb838aed2019-02-12 15:30:16 -08001041
Ady Abraham838de062019-02-04 10:24:03 -08001042 // Desired active config was set, it is different than the config currently in use, however
1043 // allowed configs might have change by the time we process the refresh.
1044 // Make sure the desired config is still allowed
Dominik Laskowski22488f62019-03-28 09:53:04 -07001045 if (!isDisplayConfigAllowed(desiredActiveConfig.configId)) {
Ady Abraham53852a52019-05-28 18:07:44 -07001046 desiredActiveConfigChangeDone();
Ady Abraham838de062019-02-04 10:24:03 -08001047 return false;
1048 }
Alec Mouri7f015182019-07-11 13:56:22 -07001049
Ady Abrahamb838aed2019-02-12 15:30:16 -08001050 mUpcomingActiveConfig = desiredActiveConfig;
1051 const auto displayId = display->getId();
1052 LOG_ALWAYS_FATAL_IF(!displayId);
1053
1054 ATRACE_INT("ActiveConfigModeHWC", mUpcomingActiveConfig.configId);
1055 getHwComposer().setActiveConfig(*displayId, mUpcomingActiveConfig.configId);
1056
1057 // we need to submit an empty frame to HWC to start the process
Ady Abrahamb838aed2019-02-12 15:30:16 -08001058 mCheckPendingFence = true;
Ady Abraham8532d012019-05-08 14:50:56 -07001059 mEventQueue->invalidate();
Ady Abrahamb838aed2019-02-12 15:30:16 -08001060 return false;
Mathias Agopianc666cae2012-07-25 18:56:13 -07001061}
Dominik Laskowski075d3172018-05-24 15:50:06 -07001062
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001063status_t SurfaceFlinger::getDisplayColorModes(const sp<IBinder>& displayToken,
1064 Vector<ColorMode>* outColorModes) {
1065 if (!displayToken || !outColorModes) {
Michael Wright28f24d02016-07-12 13:30:53 -07001066 return BAD_VALUE;
1067 }
1068
Peiyong Lina52f0292018-03-14 17:26:31 -07001069 std::vector<ColorMode> modes;
Peiyong Linff84a152019-05-17 18:36:19 -07001070 bool isInternalDisplay = false;
Steven Thomas6d8110b2017-08-31 18:24:21 -07001071 {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001072 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
1073
1074 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1075 if (!displayId) {
1076 return NAME_NOT_FOUND;
1077 }
1078
Dominik Laskowski075d3172018-05-24 15:50:06 -07001079 modes = getHwComposer().getColorModes(*displayId);
Peiyong Linff84a152019-05-17 18:36:19 -07001080 isInternalDisplay = displayId == getInternalDisplayIdLocked();
Steven Thomas6d8110b2017-08-31 18:24:21 -07001081 }
Michael Wright28f24d02016-07-12 13:30:53 -07001082 outColorModes->clear();
Peiyong Linff84a152019-05-17 18:36:19 -07001083
1084 // If it's built-in display and the configuration claims it's not wide color capable,
1085 // filter out all wide color modes. The typical reason why this happens is that the
1086 // hardware is not good enough to support GPU composition of wide color, and thus the
1087 // OEMs choose to disable this capability.
1088 if (isInternalDisplay && !hasWideColorDisplay) {
1089 std::remove_copy_if(modes.cbegin(), modes.cend(), std::back_inserter(*outColorModes),
1090 isWideColorMode);
1091 } else {
1092 std::copy(modes.cbegin(), modes.cend(), std::back_inserter(*outColorModes));
1093 }
Michael Wright28f24d02016-07-12 13:30:53 -07001094
1095 return NO_ERROR;
1096}
1097
Daniel Solomon42d04562019-01-20 21:03:19 -08001098status_t SurfaceFlinger::getDisplayNativePrimaries(const sp<IBinder>& displayToken,
1099 ui::DisplayPrimaries &primaries) {
1100 if (!displayToken) {
1101 return BAD_VALUE;
1102 }
1103
1104 // Currently we only support this API for a single internal display.
1105 if (getInternalDisplayToken() != displayToken) {
1106 return BAD_VALUE;
1107 }
1108
1109 memcpy(&primaries, &mInternalDisplayPrimaries, sizeof(ui::DisplayPrimaries));
1110 return NO_ERROR;
1111}
1112
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001113ColorMode SurfaceFlinger::getActiveColorMode(const sp<IBinder>& displayToken) {
1114 if (const auto display = getDisplayDevice(displayToken)) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07001115 return display->getCompositionDisplay()->getState().colorMode;
Michael Wright28f24d02016-07-12 13:30:53 -07001116 }
Peiyong Lina52f0292018-03-14 17:26:31 -07001117 return static_cast<ColorMode>(BAD_VALUE);
Michael Wright28f24d02016-07-12 13:30:53 -07001118}
1119
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001120status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& displayToken, ColorMode mode) {
Dominik Laskowski8c001672018-05-30 16:52:06 -07001121 postMessageSync(new LambdaMessage([&] {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001122 Vector<ColorMode> modes;
1123 getDisplayColorModes(displayToken, &modes);
1124 bool exists = std::find(std::begin(modes), std::end(modes), mode) != std::end(modes);
1125 if (mode < ColorMode::NATIVE || !exists) {
1126 ALOGE("Attempt to set invalid active color mode %s (%d) for display token %p",
1127 decodeColorMode(mode).c_str(), mode, displayToken.get());
1128 return;
Michael Wright28f24d02016-07-12 13:30:53 -07001129 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001130 const auto display = getDisplayDevice(displayToken);
1131 if (!display) {
1132 ALOGE("Attempt to set active color mode %s (%d) for invalid display token %p",
1133 decodeColorMode(mode).c_str(), mode, displayToken.get());
1134 } else if (display->isVirtual()) {
1135 ALOGW("Attempt to set active color mode %s (%d) for virtual display",
1136 decodeColorMode(mode).c_str(), mode);
1137 } else {
Lloyd Pique32cbe282018-10-19 13:09:22 -07001138 display->getCompositionDisplay()->setColorMode(mode, Dataspace::UNKNOWN,
Lloyd Piquef5275482019-01-29 18:42:42 -08001139 RenderIntent::COLORIMETRIC,
1140 Dataspace::UNKNOWN);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001141 }
1142 }));
1143
Michael Wright28f24d02016-07-12 13:30:53 -07001144 return NO_ERROR;
1145}
Mathias Agopianc666cae2012-07-25 18:56:13 -07001146
Svetoslavd85084b2014-03-20 10:28:31 -07001147status_t SurfaceFlinger::clearAnimationFrameStats() {
1148 Mutex::Autolock _l(mStateLock);
1149 mAnimFrameTracker.clearStats();
1150 return NO_ERROR;
1151}
1152
1153status_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const {
1154 Mutex::Autolock _l(mStateLock);
1155 mAnimFrameTracker.getStats(outStats);
1156 return NO_ERROR;
1157}
1158
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001159status_t SurfaceFlinger::getHdrCapabilities(const sp<IBinder>& displayToken,
1160 HdrCapabilities* outCapabilities) const {
Dan Stozac4f471e2016-03-24 09:31:08 -07001161 Mutex::Autolock _l(mStateLock);
1162
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001163 const auto display = getDisplayDeviceLocked(displayToken);
1164 if (!display) {
1165 ALOGE("getHdrCapabilities: Invalid display token %p", displayToken.get());
Dan Stozac4f471e2016-03-24 09:31:08 -07001166 return BAD_VALUE;
1167 }
1168
Peiyong Linfb069302018-04-25 14:34:31 -07001169 // At this point the DisplayDeivce should already be set up,
1170 // meaning the luminance information is already queried from
1171 // hardware composer and stored properly.
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001172 const HdrCapabilities& capabilities = display->getHdrCapabilities();
Peiyong Linfb069302018-04-25 14:34:31 -07001173 *outCapabilities = HdrCapabilities(capabilities.getSupportedHdrTypes(),
1174 capabilities.getDesiredMaxLuminance(),
1175 capabilities.getDesiredMaxAverageLuminance(),
1176 capabilities.getDesiredMinLuminance());
Dan Stozac4f471e2016-03-24 09:31:08 -07001177
1178 return NO_ERROR;
1179}
1180
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001181status_t SurfaceFlinger::getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
1182 ui::PixelFormat* outFormat,
1183 ui::Dataspace* outDataspace,
1184 uint8_t* outComponentMask) const {
1185 if (!outFormat || !outDataspace || !outComponentMask) {
1186 return BAD_VALUE;
1187 }
Kevin DuBois74e53772018-11-19 10:52:38 -08001188 const auto display = getDisplayDevice(displayToken);
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001189 if (!display || !display->getId()) {
1190 ALOGE("getDisplayedContentSamplingAttributes: Bad display token: %p", display.get());
1191 return BAD_VALUE;
1192 }
1193 return getHwComposer().getDisplayedContentSamplingAttributes(*display->getId(), outFormat,
1194 outDataspace, outComponentMask);
1195}
1196
Kevin DuBois74e53772018-11-19 10:52:38 -08001197status_t SurfaceFlinger::setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken,
1198 bool enable, uint8_t componentMask,
1199 uint64_t maxFrames) const {
1200 const auto display = getDisplayDevice(displayToken);
1201 if (!display || !display->getId()) {
1202 ALOGE("setDisplayContentSamplingEnabled: Bad display token: %p", display.get());
1203 return BAD_VALUE;
1204 }
1205
1206 return getHwComposer().setDisplayContentSamplingEnabled(*display->getId(), enable,
1207 componentMask, maxFrames);
1208}
1209
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001210status_t SurfaceFlinger::getDisplayedContentSample(const sp<IBinder>& displayToken,
1211 uint64_t maxFrames, uint64_t timestamp,
1212 DisplayedFrameStats* outStats) const {
1213 const auto display = getDisplayDevice(displayToken);
1214 if (!display || !display->getId()) {
1215 ALOGE("getDisplayContentSample: Bad display token: %p", displayToken.get());
1216 return BAD_VALUE;
1217 }
1218
1219 return getHwComposer().getDisplayedContentSample(*display->getId(), maxFrames, timestamp,
1220 outStats);
1221}
1222
Peiyong Lin3c2791e2019-01-14 17:05:18 -08001223status_t SurfaceFlinger::getProtectedContentSupport(bool* outSupported) const {
1224 if (!outSupported) {
1225 return BAD_VALUE;
1226 }
1227 *outSupported = getRenderEngine().supportsProtectedContent();
1228 return NO_ERROR;
1229}
1230
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001231status_t SurfaceFlinger::isWideColorDisplay(const sp<IBinder>& displayToken,
1232 bool* outIsWideColorDisplay) const {
1233 if (!displayToken || !outIsWideColorDisplay) {
1234 return BAD_VALUE;
1235 }
1236 Mutex::Autolock _l(mStateLock);
1237 const auto display = getDisplayDeviceLocked(displayToken);
1238 if (!display) {
1239 return BAD_VALUE;
1240 }
Peiyong Linff84a152019-05-17 18:36:19 -07001241
1242 // Use hasWideColorDisplay to override built-in display.
1243 const auto displayId = display->getId();
1244 if (displayId && displayId == getInternalDisplayIdLocked()) {
1245 *outIsWideColorDisplay = hasWideColorDisplay;
1246 return NO_ERROR;
1247 }
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001248 *outIsWideColorDisplay = display->hasWideColorGamut();
1249 return NO_ERROR;
1250}
1251
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001252status_t SurfaceFlinger::enableVSyncInjections(bool enable) {
Dominik Laskowski8c001672018-05-30 16:52:06 -07001253 postMessageSync(new LambdaMessage([&] {
Chia-I Wu90f669f2017-10-05 14:24:41 -07001254 Mutex::Autolock _l(mStateLock);
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001255
Chia-I Wu90f669f2017-10-05 14:24:41 -07001256 if (mInjectVSyncs == enable) {
1257 return;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001258 }
Chia-I Wu90f669f2017-10-05 14:24:41 -07001259
Ana Krulecc2870422019-01-29 19:00:58 -08001260 auto resyncCallback =
1261 mScheduler->makeResyncCallback(std::bind(&SurfaceFlinger::getVsyncPeriod, this));
Dominik Laskowskif654d572018-12-20 11:03:06 -08001262
Ady Abraham46e2f3e2019-03-18 16:40:15 -07001263 // TODO(b/128863962): Part of the Injector should be refactored, so that it
Ana Krulec98b5b242018-08-10 15:03:23 -07001264 // can be passed to Scheduler.
Chia-I Wu90f669f2017-10-05 14:24:41 -07001265 if (enable) {
1266 ALOGV("VSync Injections enabled");
1267 if (mVSyncInjector.get() == nullptr) {
Lloyd Piquee83f9312018-02-01 12:53:17 -08001268 mVSyncInjector = std::make_unique<InjectVSyncSource>();
Lloyd Pique24b0a482018-03-09 18:52:26 -08001269 mInjectorEventThread = std::make_unique<
Dominik Laskowskif654d572018-12-20 11:03:06 -08001270 impl::EventThread>(mVSyncInjector.get(),
Lloyd Pique24b0a482018-03-09 18:52:26 -08001271 impl::EventThread::InterceptVSyncsCallback(),
1272 "injEventThread");
Chia-I Wu90f669f2017-10-05 14:24:41 -07001273 }
Dominik Laskowskif654d572018-12-20 11:03:06 -08001274 mEventQueue->setEventThread(mInjectorEventThread.get(), std::move(resyncCallback));
Chia-I Wu90f669f2017-10-05 14:24:41 -07001275 } else {
1276 ALOGV("VSync Injections disabled");
Ana Krulecc2870422019-01-29 19:00:58 -08001277 mEventQueue->setEventThread(mScheduler->getEventThread(mSfConnectionHandle),
1278 std::move(resyncCallback));
Chia-I Wu90f669f2017-10-05 14:24:41 -07001279 }
1280
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001281 mInjectVSyncs = enable;
Dominik Laskowski8c001672018-05-30 16:52:06 -07001282 }));
1283
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001284 return NO_ERROR;
1285}
1286
1287status_t SurfaceFlinger::injectVSync(nsecs_t when) {
Chia-I Wu90f669f2017-10-05 14:24:41 -07001288 Mutex::Autolock _l(mStateLock);
1289
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001290 if (!mInjectVSyncs) {
1291 ALOGE("VSync Injections not enabled");
1292 return BAD_VALUE;
1293 }
1294 if (mInjectVSyncs && mInjectorEventThread.get() != nullptr) {
1295 ALOGV("Injecting VSync inside SurfaceFlinger");
1296 mVSyncInjector->onInjectSyncEvent(when);
1297 }
1298 return NO_ERROR;
1299}
1300
Lloyd Pique755e3192018-01-31 16:46:15 -08001301status_t SurfaceFlinger::getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const
1302 NO_THREAD_SAFETY_ANALYSIS {
Kalle Raitaa099a242017-01-11 11:17:29 -08001303 // Try to acquire a lock for 1s, fail gracefully
1304 const status_t err = mStateLock.timedLock(s2ns(1));
1305 const bool locked = (err == NO_ERROR);
1306 if (!locked) {
1307 ALOGE("LayerDebugInfo: SurfaceFlinger unresponsive (%s [%d]) - exit", strerror(-err), err);
1308 return TIMED_OUT;
1309 }
1310
1311 outLayers->clear();
1312 mCurrentState.traverseInZOrder([&](Layer* layer) {
1313 outLayers->push_back(layer->getLayerDebugInfo());
1314 });
1315
1316 mStateLock.unlock();
1317 return NO_ERROR;
1318}
1319
Peiyong Linc6780972018-10-28 15:24:08 -07001320status_t SurfaceFlinger::getCompositionPreference(
1321 Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
1322 Dataspace* outWideColorGamutDataspace,
1323 ui::PixelFormat* outWideColorGamutPixelFormat) const {
Peiyong Lin9d846a52018-11-05 13:18:20 -08001324 *outDataspace = mDefaultCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001325 *outPixelFormat = defaultCompositionPixelFormat;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001326 *outWideColorGamutDataspace = mWideColorGamutCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001327 *outWideColorGamutPixelFormat = wideColorGamutCompositionPixelFormat;
Peiyong Lin0256f722018-08-31 15:45:10 -07001328 return NO_ERROR;
1329}
1330
Dan Stozaec460082018-12-17 15:35:09 -08001331status_t SurfaceFlinger::addRegionSamplingListener(const Rect& samplingArea,
1332 const sp<IBinder>& stopLayerHandle,
1333 const sp<IRegionSamplingListener>& listener) {
tangrobinaf45f012019-02-26 18:10:10 +08001334 if (!listener || samplingArea == Rect::INVALID_RECT) {
Dan Stozaec460082018-12-17 15:35:09 -08001335 return BAD_VALUE;
1336 }
1337 mRegionSamplingThread->addListener(samplingArea, stopLayerHandle, listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001338 return NO_ERROR;
1339}
1340
Dan Stozaec460082018-12-17 15:35:09 -08001341status_t SurfaceFlinger::removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) {
tangrobinaf45f012019-02-26 18:10:10 +08001342 if (!listener) {
1343 return BAD_VALUE;
1344 }
Dan Stozaec460082018-12-17 15:35:09 -08001345 mRegionSamplingThread->removeListener(listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001346 return NO_ERROR;
1347}
Dan Gittik57e63c52019-01-18 16:37:54 +00001348
1349status_t SurfaceFlinger::getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
1350 bool* outSupport) const {
1351 if (!displayToken || !outSupport) {
1352 return BAD_VALUE;
1353 }
1354 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1355 if (!displayId) {
1356 return NAME_NOT_FOUND;
1357 }
1358 *outSupport =
1359 getHwComposer().hasDisplayCapability(displayId, HWC2::DisplayCapability::Brightness);
1360 return NO_ERROR;
1361}
1362
1363status_t SurfaceFlinger::setDisplayBrightness(const sp<IBinder>& displayToken,
1364 float brightness) const {
1365 if (!displayToken) {
1366 return BAD_VALUE;
1367 }
1368 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1369 if (!displayId) {
1370 return NAME_NOT_FOUND;
1371 }
1372 return getHwComposer().setDisplayBrightness(*displayId, brightness);
1373}
1374
Ady Abraham8532d012019-05-08 14:50:56 -07001375status_t SurfaceFlinger::notifyPowerHint(int32_t hintId) {
1376 PowerHint powerHint = static_cast<PowerHint>(hintId);
1377
1378 if (powerHint == PowerHint::INTERACTION) {
1379 mScheduler->notifyTouchEvent();
1380 }
1381
1382 return NO_ERROR;
1383}
1384
Mathias Agopiand0566bc2011-11-17 17:49:17 -08001385// ----------------------------------------------------------------------------
1386
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -07001387sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection(
Ady Abraham0f4a1b12019-06-04 16:04:04 -07001388 ISurfaceComposer::VsyncSource vsyncSource, ISurfaceComposer::ConfigChanged configChanged) {
Ana Krulecc2870422019-01-29 19:00:58 -08001389 auto resyncCallback = mScheduler->makeResyncCallback([this] {
Dominik Laskowski83b88212018-12-11 13:34:06 -08001390 Mutex::Autolock lock(mStateLock);
1391 return getVsyncPeriod();
1392 });
Dominik Laskowskif654d572018-12-20 11:03:06 -08001393
Ana Krulecc2870422019-01-29 19:00:58 -08001394 const auto& handle =
1395 vsyncSource == eVsyncSourceSurfaceFlinger ? mSfConnectionHandle : mAppConnectionHandle;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001396
Ady Abraham0f4a1b12019-06-04 16:04:04 -07001397 return mScheduler->createDisplayEventConnection(handle, std::move(resyncCallback),
1398 configChanged);
Mathias Agopianbb641242010-05-18 17:06:55 -07001399}
1400
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001401// ----------------------------------------------------------------------------
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001402
1403void SurfaceFlinger::waitForEvent() {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001404 mEventQueue->waitMessage();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001405}
1406
1407void SurfaceFlinger::signalTransaction() {
Ady Abraham8532d012019-05-08 14:50:56 -07001408 mScheduler->resetIdleTimer();
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001409 mEventQueue->invalidate();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001410}
1411
1412void SurfaceFlinger::signalLayerUpdate() {
Ady Abraham8532d012019-05-08 14:50:56 -07001413 mScheduler->resetIdleTimer();
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001414 mEventQueue->invalidate();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001415}
1416
1417void SurfaceFlinger::signalRefresh() {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07001418 mRefreshPending = true;
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001419 mEventQueue->refresh();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001420}
1421
1422status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,
Dan Stozac7014012014-02-14 15:03:43 -08001423 nsecs_t reltime, uint32_t /* flags */) {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001424 return mEventQueue->postMessage(msg, reltime);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001425}
1426
1427status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
Dan Stozac7014012014-02-14 15:03:43 -08001428 nsecs_t reltime, uint32_t /* flags */) {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001429 status_t res = mEventQueue->postMessage(msg, reltime);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001430 if (res == NO_ERROR) {
1431 msg->wait();
1432 }
1433 return res;
1434}
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001435
Mathias Agopian4f4f0942013-08-19 17:26:18 -07001436void SurfaceFlinger::run() {
Mathias Agopian4f4f0942013-08-19 17:26:18 -07001437 do {
1438 waitForEvent();
1439 } while (true);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001440}
1441
Dominik Laskowski83b88212018-12-11 13:34:06 -08001442nsecs_t SurfaceFlinger::getVsyncPeriod() const {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001443 const auto displayId = getInternalDisplayIdLocked();
Dominik Laskowski83b88212018-12-11 13:34:06 -08001444 if (!displayId || !getHwComposer().isConnected(*displayId)) {
1445 return 0;
1446 }
1447
1448 const auto config = getHwComposer().getActiveConfig(*displayId);
1449 return config ? config->getVsyncPeriod() : 0;
1450}
1451
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001452void SurfaceFlinger::onVsyncReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId,
1453 int64_t timestamp) {
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001454 ATRACE_NAME("SF onVsync");
1455
Steven Thomas3cfac282017-02-06 12:29:30 -08001456 Mutex::Autolock lock(mStateLock);
Steven Thomasb02664d2017-07-26 18:48:28 -07001457 // Ignore any vsyncs from a previous hardware composer.
David Sodman105b7dc2017-11-04 20:28:14 -07001458 if (sequenceId != getBE().mComposerSequenceId) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001459 return;
1460 }
1461
Dominik Laskowski075d3172018-05-24 15:50:06 -07001462 if (!getHwComposer().onVsync(hwcDisplayId, timestamp)) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001463 return;
1464 }
1465
Dominik Laskowski075d3172018-05-24 15:50:06 -07001466 if (hwcDisplayId != getHwComposer().getInternalHwcDisplayId()) {
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001467 // For now, we don't do anything with external display vsyncs.
1468 return;
1469 }
1470
Alec Mourif8e689c2019-05-20 18:32:22 -07001471 bool periodFlushed = false;
1472 mScheduler->addResyncSample(timestamp, &periodFlushed);
1473 if (periodFlushed) {
1474 mVsyncModulator.onRefreshRateChangeCompleted();
Alec Mouri754c98a2019-03-18 18:53:42 -07001475 }
Mathias Agopian148994e2012-09-19 17:31:36 -07001476}
1477
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001478void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
David Sodman99974d22017-11-28 12:04:33 -08001479 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
1480 *compositorTiming = getBE().mCompositorTiming;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001481}
1482
Ady Abraham261614e2019-07-10 17:53:12 -07001483bool SurfaceFlinger::isDisplayConfigAllowed(int32_t configId) const {
Dominik Laskowski22488f62019-03-28 09:53:04 -07001484 return mAllowedDisplayConfigs.empty() || mAllowedDisplayConfigs.count(configId);
Ady Abraham838de062019-02-04 10:24:03 -08001485}
1486
Ana Krulec8d3e4f32019-03-05 10:40:33 -08001487void SurfaceFlinger::setRefreshRateTo(RefreshRateType refreshRate, Scheduler::ConfigEvent event) {
Dominik Laskowski22488f62019-03-28 09:53:04 -07001488 const auto display = getDefaultDisplayDeviceLocked();
1489 if (!display || mBootStage != BootStage::FINISHED) {
Ana Krulec7d1d6832018-12-27 11:10:09 -08001490 return;
1491 }
Alec Mouri1c9e82b2019-03-07 12:24:05 -08001492 ATRACE_CALL();
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001493
Ana Krulec7d1d6832018-12-27 11:10:09 -08001494 // Don't do any updating if the current fps is the same as the new one.
Dominik Laskowski22488f62019-03-28 09:53:04 -07001495 const auto& refreshRateConfig = mRefreshRateConfigs.getRefreshRate(refreshRate);
Alec Mouri0a1cc962019-03-14 12:33:02 -07001496 if (!refreshRateConfig) {
1497 ALOGV("Skipping refresh rate change request for unsupported rate.");
Ady Abraham1902d072019-03-01 17:18:59 -08001498 return;
Ana Krulec7d1d6832018-12-27 11:10:09 -08001499 }
Ady Abraham1902d072019-03-01 17:18:59 -08001500
Alec Mouri0a1cc962019-03-14 12:33:02 -07001501 const int desiredConfigId = refreshRateConfig->configId;
1502
Dominik Laskowski22488f62019-03-28 09:53:04 -07001503 if (!isDisplayConfigAllowed(desiredConfigId)) {
Ady Abraham1902d072019-03-01 17:18:59 -08001504 ALOGV("Skipping config %d as it is not part of allowed configs", desiredConfigId);
1505 return;
1506 }
1507
Dominik Laskowski22488f62019-03-28 09:53:04 -07001508 setDesiredActiveConfig({refreshRate, desiredConfigId, event});
Ana Krulec7d1d6832018-12-27 11:10:09 -08001509}
1510
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001511void SurfaceFlinger::onHotplugReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId,
Lloyd Pique715a2c12017-12-14 17:18:08 -08001512 HWC2::Connection connection) {
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001513 ALOGV("%s(%d, %" PRIu64 ", %s)", __FUNCTION__, sequenceId, hwcDisplayId,
Lloyd Pique715a2c12017-12-14 17:18:08 -08001514 connection == HWC2::Connection::Connected ? "connected" : "disconnected");
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001515
Lloyd Piqueba04e622017-12-14 17:11:26 -08001516 // Ignore events that do not have the right sequenceId.
1517 if (sequenceId != getBE().mComposerSequenceId) {
1518 return;
1519 }
1520
Steven Thomasb02664d2017-07-26 18:48:28 -07001521 // Only lock if we're not on the main thread. This function is normally
1522 // called on a hwbinder thread, but for the primary display it's called on
1523 // the main thread with the state lock already held, so don't attempt to
1524 // acquire it here.
Lloyd Piqueba04e622017-12-14 17:11:26 -08001525 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
Steven Thomasb02664d2017-07-26 18:48:28 -07001526
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001527 mPendingHotplugEvents.emplace_back(HotplugEvent{hwcDisplayId, connection});
Mathias Agopian9e2463e2012-09-21 18:26:16 -07001528
Jiwen 'Steve' Caiccfd6822018-02-21 16:15:58 -08001529 if (std::this_thread::get_id() == mMainThreadId) {
1530 // Process all pending hot plug events immediately if we are on the main thread.
1531 processDisplayHotplugEventsLocked();
1532 }
1533
Lloyd Piqueba04e622017-12-14 17:11:26 -08001534 setTransactionFlags(eDisplayTransactionNeeded);
Mathias Agopian86303202012-07-24 22:46:10 -07001535}
1536
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001537void SurfaceFlinger::onRefreshReceived(int sequenceId, hwc2_display_t /*hwcDisplayId*/) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001538 Mutex::Autolock lock(mStateLock);
David Sodman105b7dc2017-11-04 20:28:14 -07001539 if (sequenceId != getBE().mComposerSequenceId) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001540 return;
Steven Thomas3cfac282017-02-06 12:29:30 -08001541 }
Ana Krulec7d1d6832018-12-27 11:10:09 -08001542 repaintEverythingForHWC();
Steven Thomas3cfac282017-02-06 12:29:30 -08001543}
1544
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001545void SurfaceFlinger::setPrimaryVsyncEnabled(bool enabled) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001546 ATRACE_CALL();
Ady Abraham9ba25122019-06-03 17:10:55 -07001547
1548 // Enable / Disable HWVsync from the main thread to avoid race conditions with
1549 // display power state.
1550 postMessageAsync(new LambdaMessage(
1551 [=]() NO_THREAD_SAFETY_ANALYSIS { setPrimaryVsyncEnabledInternal(enabled); }));
1552}
1553
1554void SurfaceFlinger::setPrimaryVsyncEnabledInternal(bool enabled) {
1555 ATRACE_CALL();
1556
Ady Abraham27c70212019-06-11 10:52:26 -07001557 mHWCVsyncPendingState = enabled ? HWC2::Vsync::Enable : HWC2::Vsync::Disable;
1558
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001559 if (const auto displayId = getInternalDisplayIdLocked()) {
Ady Abraham9ba25122019-06-03 17:10:55 -07001560 sp<DisplayDevice> display = getDefaultDisplayDeviceLocked();
1561 if (display && display->isPoweredOn()) {
Ady Abraham27c70212019-06-11 10:52:26 -07001562 setVsyncEnabledInHWC(*displayId, mHWCVsyncPendingState);
Ady Abraham9ba25122019-06-03 17:10:55 -07001563 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07001564 }
Mathias Agopian86303202012-07-24 22:46:10 -07001565}
1566
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001567// Note: it is assumed the caller holds |mStateLock| when this is called
Steven Thomasb02664d2017-07-26 18:48:28 -07001568void SurfaceFlinger::resetDisplayState() {
Ana Krulecc2870422019-01-29 19:00:58 -08001569 mScheduler->disableHardwareVsync(true);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001570 // Clear the drawing state so that the logic inside of
1571 // handleTransactionLocked will fire. It will determine the delta between
1572 // mCurrentState and mDrawingState and re-apply all changes when we make the
1573 // transition.
1574 mDrawingState.displays.clear();
1575 mDisplays.clear();
1576}
1577
Steven Thomas050b2c82017-03-06 11:45:16 -08001578void SurfaceFlinger::updateVrFlinger() {
Alec Mourife3dc942019-02-12 14:19:18 -08001579 ATRACE_CALL();
Steven Thomas050b2c82017-03-06 11:45:16 -08001580 if (!mVrFlinger)
1581 return;
1582 bool vrFlingerRequestsDisplay = mVrFlingerRequestsDisplay;
Lloyd Pique441d5042018-10-18 16:49:51 -07001583 if (vrFlingerRequestsDisplay == getHwComposer().isUsingVrComposer()) {
Mark Urbanus209beca2017-02-23 11:16:04 -08001584 return;
1585 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001586
Lloyd Pique441d5042018-10-18 16:49:51 -07001587 if (vrFlingerRequestsDisplay && !getHwComposer().getComposer()->isRemote()) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001588 ALOGE("Vr flinger is only supported for remote hardware composer"
1589 " service connections. Ignoring request to transition to vr"
1590 " flinger.");
1591 mVrFlingerRequestsDisplay = false;
1592 return;
Mark Urbanus209beca2017-02-23 11:16:04 -08001593 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001594
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001595 Mutex::Autolock _l(mStateLock);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001596
Steven Thomas0123ac62018-07-12 11:32:34 -07001597 sp<DisplayDevice> display = getDefaultDisplayDeviceLocked();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07001598 LOG_ALWAYS_FATAL_IF(!display);
Lloyd Pique07e33212018-12-18 16:33:37 -08001599
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07001600 const int currentDisplayPowerMode = display->getPowerMode();
Lloyd Pique07e33212018-12-18 16:33:37 -08001601
1602 // Clear out all the output layers from the composition engine for all
1603 // displays before destroying the hardware composer interface. This ensures
1604 // any HWC layers are destroyed through that interface before it becomes
1605 // invalid.
1606 for (const auto& [token, displayDevice] : mDisplays) {
1607 displayDevice->getCompositionDisplay()->setOutputLayersOrderedByZ(
1608 compositionengine::Output::OutputLayers());
1609 }
1610
Steven Thomas0123ac62018-07-12 11:32:34 -07001611 // This DisplayDevice will no longer be relevant once resetDisplayState() is
1612 // called below. Clear the reference now so we don't accidentally use it
1613 // later.
1614 display.clear();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001615
Steven Thomasb02664d2017-07-26 18:48:28 -07001616 if (!vrFlingerRequestsDisplay) {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001617 mVrFlinger->SeizeDisplayOwnership();
Steven Thomasb02664d2017-07-26 18:48:28 -07001618 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001619
Steven Thomasb02664d2017-07-26 18:48:28 -07001620 resetDisplayState();
Lloyd Pique441d5042018-10-18 16:49:51 -07001621 // Delete the current instance before creating the new one
1622 mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
1623 mCompositionEngine->setHwComposer(getFactory().createHWComposer(
1624 vrFlingerRequestsDisplay ? "vr" : getBE().mHwcServiceName));
1625 getHwComposer().registerCallback(this, ++getBE().mComposerSequenceId);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001626
Lloyd Pique441d5042018-10-18 16:49:51 -07001627 LOG_ALWAYS_FATAL_IF(!getHwComposer().getComposer()->isRemote(),
David Sodman105b7dc2017-11-04 20:28:14 -07001628 "Switched to non-remote hardware composer");
Steven Thomasb02664d2017-07-26 18:48:28 -07001629
1630 if (vrFlingerRequestsDisplay) {
1631 mVrFlinger->GrantDisplayOwnership();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001632 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001633
1634 mVisibleRegionsDirty = true;
1635 invalidateHwcGeometry();
1636
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001637 // Re-enable default display.
Steven Thomas0123ac62018-07-12 11:32:34 -07001638 display = getDefaultDisplayDeviceLocked();
1639 LOG_ALWAYS_FATAL_IF(!display);
Dominik Laskowskie9774092018-12-11 10:04:24 -08001640 setPowerModeInternal(display, currentDisplayPowerMode);
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001641
Steven Thomasb02664d2017-07-26 18:48:28 -07001642 // Reset the timing values to account for the period of the swapped in HWC
Dominik Laskowski83b88212018-12-11 13:34:06 -08001643 const nsecs_t vsyncPeriod = getVsyncPeriod();
1644 mAnimFrameTracker.setDisplayRefreshPeriod(vsyncPeriod);
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001645
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001646 // The present fences returned from vr_hwc are not an accurate
1647 // representation of vsync times.
Ana Krulecc2870422019-01-29 19:00:58 -08001648 mScheduler->setIgnorePresentFences(getHwComposer().isUsingVrComposer() || !hasSyncFramework);
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001649
Steven Thomasb02664d2017-07-26 18:48:28 -07001650 // Use phase of 0 since phase is not known.
1651 // Use latency of 0, which will snap to the ideal latency.
Dominik Laskowski83b88212018-12-11 13:34:06 -08001652 DisplayStatInfo stats{0 /* vsyncTime */, vsyncPeriod};
Ana Krulece588e312018-09-18 12:32:24 -07001653 setCompositorTimingSnapped(stats, 0);
Stephen Kiazyk82386cd2017-04-14 13:43:29 -07001654
Ana Krulecc2870422019-01-29 19:00:58 -08001655 mScheduler->resyncToHardwareVsync(false, vsyncPeriod);
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001656
Lloyd Piquef1c675b2018-09-12 20:45:39 -07001657 mRepaintEverything = true;
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001658 setTransactionFlags(eDisplayTransactionNeeded);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001659}
1660
Ady Abrahambe0f9482019-04-24 15:41:53 -07001661bool SurfaceFlinger::previousFrameMissed() NO_THREAD_SAFETY_ANALYSIS {
1662 // We are storing the last 2 present fences. If sf's phase offset is to be
1663 // woken up before the actual vsync but targeting the next vsync, we need to check
1664 // fence N-2
1665 const sp<Fence>& fence =
1666 mVsyncModulator.getOffsets().sf < mPhaseOffsets->getOffsetThresholdForNextVsync()
1667 ? mPreviousPresentFences[0]
1668 : mPreviousPresentFences[1];
1669
1670 return fence != Fence::NO_FENCE && (fence->getStatus() == Fence::Status::Unsignaled);
1671}
1672
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07001673void SurfaceFlinger::populateExpectedPresentTime() {
Alec Mouriaa614192019-06-06 13:28:34 -07001674 DisplayStatInfo stats;
1675 mScheduler->getDisplayStatInfo(&stats);
Ady Abraham8fe11022019-06-12 17:11:12 -07001676 const nsecs_t presentTime = mScheduler->getDispSyncExpectedPresentTime();
Alec Mouriaa614192019-06-06 13:28:34 -07001677 // Inflate the expected present time if we're targetting the next vsync.
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07001678 mExpectedPresentTime.store(mVsyncModulator.getOffsets().sf <
1679 mPhaseOffsets->getOffsetThresholdForNextVsync()
1680 ? presentTime
1681 : presentTime + stats.vsyncPeriod);
Alec Mouriaa614192019-06-06 13:28:34 -07001682}
1683
Dominik Laskowski22488f62019-03-28 09:53:04 -07001684void SurfaceFlinger::onMessageReceived(int32_t what) NO_THREAD_SAFETY_ANALYSIS {
Jamie Gennis1c8e95c2012-02-23 19:27:23 -08001685 ATRACE_CALL();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001686 switch (what) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08001687 case MessageQueue::INVALIDATE: {
Ady Abraham7c03ce62019-07-19 10:59:45 -07001688 // calculate the expected present time once and use the cached
1689 // value throughout this frame to make sure all layers are
1690 // seeing this same value.
1691 populateExpectedPresentTime();
1692
Ady Abraham50204dd2019-07-19 15:47:11 -07001693 const TracedOrdinal<bool> frameMissed = {"FrameMissed", previousFrameMissed()};
1694 const TracedOrdinal<bool> hwcFrameMissed = {"HwcFrameMissed",
1695 mHadDeviceComposition && frameMissed};
1696 const TracedOrdinal<bool> gpuFrameMissed = {"GpuFrameMissed",
1697 mHadClientComposition && frameMissed};
1698
Alec Mouricc0fc602019-02-26 21:45:19 -08001699 if (frameMissed) {
1700 mFrameMissedCount++;
1701 mTimeStats->incrementMissedFrames();
1702 }
1703
Alec Mouri40189b02019-03-05 15:07:54 -08001704 if (hwcFrameMissed) {
1705 mHwcFrameMissedCount++;
1706 }
1707
1708 if (gpuFrameMissed) {
1709 mGpuFrameMissedCount++;
1710 }
1711
Ana Krulecfefd6ae2019-02-13 17:53:08 -08001712 if (mUseSmart90ForVideo) {
1713 // This call is made each time SF wakes up and creates a new frame. It is part
1714 // of video detection feature.
Ady Abraham09bd3922019-04-08 10:44:56 -07001715 mScheduler->updateFpsBasedOnContent();
Ana Krulecfefd6ae2019-02-13 17:53:08 -08001716 }
1717
Ady Abrahamb838aed2019-02-12 15:30:16 -08001718 if (performSetActiveConfig()) {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001719 break;
1720 }
1721
Ady Abraham4658e112019-07-22 13:07:26 -07001722 if (frameMissed && mPropagateBackpressure) {
1723 if ((hwcFrameMissed && !gpuFrameMissed) ||
1724 mPropagateBackpressureClientComposition) {
Yiwei Zhang621f9d42018-05-07 10:40:55 -07001725 signalLayerUpdate();
1726 break;
1727 }
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07001728 }
Dan Stoza50182882016-07-08 12:02:20 -07001729
Steven Thomas050b2c82017-03-06 11:45:16 -08001730 // Now that we're going to make it to the handleMessageTransaction()
1731 // call below it's safe to call updateVrFlinger(), which will
1732 // potentially trigger a display handoff.
1733 updateVrFlinger();
1734
Dan Stoza6b9454d2014-11-07 16:00:59 -08001735 bool refreshNeeded = handleMessageTransaction();
1736 refreshNeeded |= handleMessageInvalidate();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001737
1738 updateCursorAsync();
1739 updateInputFlinger();
1740
Dan Stoza58784442014-12-02 16:58:17 -08001741 refreshNeeded |= mRepaintEverything;
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08001742 if (refreshNeeded && CC_LIKELY(mBootStage != BootStage::BOOTLOADER)) {
Dan Stoza58784442014-12-02 16:58:17 -08001743 // Signal a refresh if a transaction modified the window state,
1744 // a new buffer was latched, or if HWC has requested a full
1745 // repaint
Dan Stoza6b9454d2014-11-07 16:00:59 -08001746 signalRefresh();
1747 }
1748 break;
1749 }
1750 case MessageQueue::REFRESH: {
1751 handleMessageRefresh();
1752 break;
1753 }
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001754 }
1755}
1756
Dan Stoza6b9454d2014-11-07 16:00:59 -08001757bool SurfaceFlinger::handleMessageTransaction() {
Alec Mourife3dc942019-02-12 14:19:18 -08001758 ATRACE_CALL();
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08001759 uint32_t transactionFlags = peekTransactionFlags();
Marissa Wall713b63f2018-10-17 15:42:43 -07001760
Marissa Walle6e3c0d2019-03-29 10:28:30 -07001761 bool flushedATransaction = flushTransactionQueues();
1762
1763 bool runHandleTransaction = transactionFlags &&
1764 ((transactionFlags != eTransactionFlushNeeded) || flushedATransaction);
1765
1766 if (runHandleTransaction) {
1767 handleTransaction(eTransactionMask);
1768 } else {
1769 getTransactionFlags(eTransactionFlushNeeded);
Marissa Wall713b63f2018-10-17 15:42:43 -07001770 }
1771
Marissa Walle6e3c0d2019-03-29 10:28:30 -07001772 if (transactionFlushNeeded()) {
1773 setTransactionFlags(eTransactionFlushNeeded);
Mathias Agopian4fec8732012-06-29 14:12:52 -07001774 }
Marissa Wall713b63f2018-10-17 15:42:43 -07001775
Marissa Walle6e3c0d2019-03-29 10:28:30 -07001776 return runHandleTransaction;
Mathias Agopian4fec8732012-06-29 14:12:52 -07001777}
1778
Mathias Agopian4fec8732012-06-29 14:12:52 -07001779void SurfaceFlinger::handleMessageRefresh() {
Mathias Agopiancd60f992012-08-16 16:28:27 -07001780 ATRACE_CALL();
Dan Stoza14cd37c2015-07-09 12:43:33 -07001781
Dan Stoza2b6d38e2017-06-01 16:40:30 -07001782 mRefreshPending = false;
1783
Lloyd Piquef1c675b2018-09-12 20:45:39 -07001784 const bool repaintEverything = mRepaintEverything.exchange(false);
David Sodman2b406362017-12-15 13:33:47 -08001785 preComposition();
Lloyd Pique074e8122018-07-26 12:57:23 -07001786 rebuildLayerStacks();
David Sodman79bba0e2018-08-05 18:07:49 -07001787 calculateWorkingSet();
David Sodmanfa9b2af2017-12-24 13:28:59 -08001788 for (const auto& [token, display] : mDisplays) {
1789 beginFrame(display);
1790 prepareFrame(display);
1791 doDebugFlashRegions(display, repaintEverything);
1792 doComposition(display, repaintEverything);
1793 }
1794
Yiwei Zhang7124ad32018-02-21 13:02:45 -08001795 logLayerStats();
David Sodmanfa9b2af2017-12-24 13:28:59 -08001796
1797 postFrame();
David Sodman2b406362017-12-15 13:33:47 -08001798 postComposition();
Dan Stoza05dacfb2016-07-01 13:33:38 -07001799
Dan Stozabfbffeb2016-07-21 14:49:33 -07001800 mHadClientComposition = false;
Alec Mouricc0fc602019-02-26 21:45:19 -08001801 mHadDeviceComposition = false;
Lloyd Pique32cbe282018-10-19 13:09:22 -07001802 for (const auto& [token, displayDevice] : mDisplays) {
1803 auto display = displayDevice->getCompositionDisplay();
1804 const auto displayId = display->getId();
Lloyd Pique441d5042018-10-18 16:49:51 -07001805 mHadClientComposition =
Lloyd Pique32cbe282018-10-19 13:09:22 -07001806 mHadClientComposition || getHwComposer().hasClientComposition(displayId);
Alec Mouricc0fc602019-02-26 21:45:19 -08001807 mHadDeviceComposition =
1808 mHadDeviceComposition || getHwComposer().hasDeviceComposition(displayId);
Dan Stozabfbffeb2016-07-21 14:49:33 -07001809 }
David Sodmanfa9b2af2017-12-24 13:28:59 -08001810
Jorim Jaggi90535212018-05-23 23:44:06 +02001811 mVsyncModulator.onRefreshed(mHadClientComposition);
Dan Stoza14cd37c2015-07-09 12:43:33 -07001812
David Sodman7e4ae112018-02-09 15:02:28 -08001813 mLayersWithQueuedFrames.clear();
Vishnu Nairdf529052019-06-07 14:53:14 -07001814 if (mVisibleRegionsDirty) {
1815 mVisibleRegionsDirty = false;
1816 if (mTracingEnabled) {
1817 mTracing.notify("visibleRegionsDirty");
1818 }
1819 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07001820}
Mathias Agopian4fec8732012-06-29 14:12:52 -07001821
David Sodmanfa9b2af2017-12-24 13:28:59 -08001822
1823bool SurfaceFlinger::handleMessageInvalidate() {
1824 ATRACE_CALL();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001825 bool refreshNeeded = handlePageFlip();
1826
Vishnu Nair4351ad52019-02-11 14:13:02 -08001827 if (mVisibleRegionsDirty) {
1828 computeLayerBounds();
1829 }
1830
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001831 for (auto& layer : mLayersPendingRefresh) {
1832 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08001833 visibleReg.set(layer->getScreenBounds());
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001834 invalidateLayerStack(layer, visibleReg);
1835 }
1836 mLayersPendingRefresh.clear();
1837 return refreshNeeded;
Mathias Agopian4fec8732012-06-29 14:12:52 -07001838}
1839
David Sodman79bba0e2018-08-05 18:07:49 -07001840void SurfaceFlinger::calculateWorkingSet() {
1841 ATRACE_CALL();
1842 ALOGV(__FUNCTION__);
1843
Lloyd Piquef5275482019-01-29 18:42:42 -08001844 const bool updatingGeometryThisFrame = mGeometryInvalid;
1845 mGeometryInvalid = false;
1846
1847 {
1848 // Use a map so that we latch the state of each front-end layer once.
1849 std::unordered_map<compositionengine::LayerFE*, compositionengine::LayerFECompositionState*>
1850 uniqueVisibleLayers;
1851
1852 // Figure out which frontend layers are being composed, and build the unique
1853 // set of them (and the corresponding composition layer)
Lloyd Pique32cbe282018-10-19 13:09:22 -07001854 for (const auto& [token, displayDevice] : mDisplays) {
1855 auto display = displayDevice->getCompositionDisplay();
Lloyd Piquef5275482019-01-29 18:42:42 -08001856 for (auto& layer : display->getOutputLayersOrderedByZ()) {
1857 uniqueVisibleLayers.insert(std::make_pair(&layer->getLayerFE(),
1858 &layer->getLayer().editState().frontEnd));
1859 }
1860 }
David Sodman79bba0e2018-08-05 18:07:49 -07001861
Lloyd Piquef5275482019-01-29 18:42:42 -08001862 // Update the composition state from each front-end layer.
1863 for (auto& [layerFE, state] : uniqueVisibleLayers) {
1864 layerFE->latchCompositionState(*state, updatingGeometryThisFrame);
1865 }
1866 }
1867
1868 if (CC_UNLIKELY(updatingGeometryThisFrame)) {
1869 for (const auto& [token, displayDevice] : mDisplays) {
1870 auto display = displayDevice->getCompositionDisplay();
Lloyd Piquea83776c2019-01-29 18:42:32 -08001871 uint32_t zOrder = 0;
David Sodman79bba0e2018-08-05 18:07:49 -07001872
Lloyd Piquea83776c2019-01-29 18:42:32 -08001873 for (auto& layer : display->getOutputLayersOrderedByZ()) {
Lloyd Piquef5275482019-01-29 18:42:42 -08001874 // Assign a simple Z order sequence to each visible layer.
1875 layer->editState().z = zOrder++;
David Sodman79bba0e2018-08-05 18:07:49 -07001876 }
1877 }
1878 }
1879
Lloyd Piquef5275482019-01-29 18:42:42 -08001880 // Determine the color configuration of each output
Lloyd Pique32cbe282018-10-19 13:09:22 -07001881 for (const auto& [token, displayDevice] : mDisplays) {
1882 auto display = displayDevice->getCompositionDisplay();
David Sodman79bba0e2018-08-05 18:07:49 -07001883
Lloyd Piquef5275482019-01-29 18:42:42 -08001884 ColorMode colorMode = ColorMode::NATIVE;
1885 Dataspace dataspace = Dataspace::UNKNOWN;
1886 RenderIntent renderIntent = RenderIntent::COLORIMETRIC;
1887 if (useColorManagement) {
1888 pickColorMode(displayDevice, &colorMode, &dataspace, &renderIntent);
1889 }
1890 display->setColorMode(colorMode, dataspace, renderIntent, mColorSpaceAgnosticDataspace);
1891 }
1892
1893 for (const auto& [token, displayDevice] : mDisplays) {
1894 auto display = displayDevice->getCompositionDisplay();
1895
1896 for (auto& layer : display->getOutputLayersOrderedByZ()) {
1897 // Update the composition state of the output layer, as needed
1898 // recomputing it from the state given by the front-end layer.
1899 layer->updateCompositionState(updatingGeometryThisFrame);
1900 }
1901 }
1902
1903 for (const auto& [token, displayDevice] : mDisplays) {
1904 auto display = displayDevice->getCompositionDisplay();
1905
1906 for (auto& layer : display->getOutputLayersOrderedByZ()) {
1907 // Send the updated state to the HWC, if appropriate.
1908 layer->writeStateToHWC(updatingGeometryThisFrame);
1909 }
1910 }
1911
1912 if (CC_UNLIKELY(mDrawingState.colorMatrixChanged)) {
1913 for (const auto& [token, displayDevice] : mDisplays) {
1914 auto display = displayDevice->getCompositionDisplay();
David Sodman79bba0e2018-08-05 18:07:49 -07001915 display->setColorTransform(mDrawingState.colorMatrix);
David Sodman79bba0e2018-08-05 18:07:49 -07001916 }
Lloyd Piquef5275482019-01-29 18:42:42 -08001917 mDrawingState.colorMatrixChanged = false;
David Sodmanba340492018-08-05 21:51:33 -07001918 }
David Sodman79bba0e2018-08-05 18:07:49 -07001919}
1920
Lloyd Pique32cbe282018-10-19 13:09:22 -07001921void SurfaceFlinger::doDebugFlashRegions(const sp<DisplayDevice>& displayDevice,
1922 bool repaintEverything) {
1923 auto display = displayDevice->getCompositionDisplay();
1924 const auto& displayState = display->getState();
1925
Mathias Agopiancd60f992012-08-16 16:28:27 -07001926 // is debugging enabled
1927 if (CC_LIKELY(!mDebugRegion))
1928 return;
1929
Lloyd Pique32cbe282018-10-19 13:09:22 -07001930 if (displayState.isEnabled) {
David Sodmanfa9b2af2017-12-24 13:28:59 -08001931 // transform the dirty region into this screen's coordinate space
Alec Mourie7d1d4a2019-02-05 01:13:46 +00001932 const Region dirtyRegion = display->getDirtyRegion(repaintEverything);
David Sodmanfa9b2af2017-12-24 13:28:59 -08001933 if (!dirtyRegion.isEmpty()) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +00001934 base::unique_fd readyFence;
David Sodmanfa9b2af2017-12-24 13:28:59 -08001935 // redraw the whole screen
Alec Mourie7d1d4a2019-02-05 01:13:46 +00001936 doComposeSurfaces(displayDevice, dirtyRegion, &readyFence);
Mathias Agopiancd60f992012-08-16 16:28:27 -07001937
Alec Mourie7d1d4a2019-02-05 01:13:46 +00001938 display->getRenderSurface()->queueBuffer(std::move(readyFence));
Mathias Agopiancd60f992012-08-16 16:28:27 -07001939 }
1940 }
1941
Lloyd Pique32cbe282018-10-19 13:09:22 -07001942 postFramebuffer(displayDevice);
Mathias Agopiancd60f992012-08-16 16:28:27 -07001943
1944 if (mDebugRegion > 1) {
1945 usleep(mDebugRegion * 1000);
1946 }
Mathias Agopianbb53b0e2012-09-24 21:27:29 -07001947
Lloyd Pique32cbe282018-10-19 13:09:22 -07001948 prepareFrame(displayDevice);
Mathias Agopiancd60f992012-08-16 16:28:27 -07001949}
1950
Yiwei Zhang7124ad32018-02-21 13:02:45 -08001951void SurfaceFlinger::logLayerStats() {
1952 ATRACE_CALL();
1953 if (CC_UNLIKELY(mLayerStats.isEnabled())) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07001954 for (const auto& [token, display] : mDisplays) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001955 if (display->isPrimary()) {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001956 mLayerStats.logLayerStats(dumpVisibleLayersProtoInfo(display));
Dominik Laskowski63165dc2018-05-25 18:36:52 -07001957 return;
Yiwei Zhang7124ad32018-02-21 13:02:45 -08001958 }
1959 }
Dominik Laskowski63165dc2018-05-25 18:36:52 -07001960
1961 ALOGE("logLayerStats: no primary display");
Yiwei Zhang7124ad32018-02-21 13:02:45 -08001962 }
1963}
1964
David Sodman2b406362017-12-15 13:33:47 -08001965void SurfaceFlinger::preComposition()
Mathias Agopiancd60f992012-08-16 16:28:27 -07001966{
Dan Stoza9e56aa02015-11-02 13:00:03 -08001967 ATRACE_CALL();
1968 ALOGV("preComposition");
1969
David Sodman2b406362017-12-15 13:33:47 -08001970 mRefreshStartTime = systemTime(SYSTEM_TIME_MONOTONIC);
1971
Mathias Agopiancd60f992012-08-16 16:28:27 -07001972 bool needExtraInvalidate = false;
Robert Carr2047fae2016-11-28 14:09:09 -08001973 mDrawingState.traverseInZOrder([&](Layer* layer) {
David Sodman2b406362017-12-15 13:33:47 -08001974 if (layer->onPreComposition(mRefreshStartTime)) {
Mathias Agopiancd60f992012-08-16 16:28:27 -07001975 needExtraInvalidate = true;
1976 }
Robert Carr2047fae2016-11-28 14:09:09 -08001977 });
1978
Mathias Agopiancd60f992012-08-16 16:28:27 -07001979 if (needExtraInvalidate) {
1980 signalLayerUpdate();
1981 }
1982}
1983
Ana Krulece588e312018-09-18 12:32:24 -07001984void SurfaceFlinger::updateCompositorTiming(const DisplayStatInfo& stats, nsecs_t compositeTime,
1985 std::shared_ptr<FenceTime>& presentFenceTime) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001986 // Update queue of past composite+present times and determine the
1987 // most recently known composite to present latency.
David Sodman99974d22017-11-28 12:04:33 -08001988 getBE().mCompositePresentTimes.push({compositeTime, presentFenceTime});
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001989 nsecs_t compositeToPresentLatency = -1;
David Sodman99974d22017-11-28 12:04:33 -08001990 while (!getBE().mCompositePresentTimes.empty()) {
1991 SurfaceFlingerBE::CompositePresentTime& cpt = getBE().mCompositePresentTimes.front();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001992 // Cached values should have been updated before calling this method,
1993 // which helps avoid duplicate syscalls.
1994 nsecs_t displayTime = cpt.display->getCachedSignalTime();
1995 if (displayTime == Fence::SIGNAL_TIME_PENDING) {
1996 break;
1997 }
1998 compositeToPresentLatency = displayTime - cpt.composite;
David Sodman99974d22017-11-28 12:04:33 -08001999 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002000 }
2001
2002 // Don't let mCompositePresentTimes grow unbounded, just in case.
David Sodman99974d22017-11-28 12:04:33 -08002003 while (getBE().mCompositePresentTimes.size() > 16) {
2004 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002005 }
2006
Ana Krulece588e312018-09-18 12:32:24 -07002007 setCompositorTimingSnapped(stats, compositeToPresentLatency);
Brian Andersond0010582017-03-07 13:20:31 -08002008}
2009
Ana Krulece588e312018-09-18 12:32:24 -07002010void SurfaceFlinger::setCompositorTimingSnapped(const DisplayStatInfo& stats,
2011 nsecs_t compositeToPresentLatency) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002012 // Integer division and modulo round toward 0 not -inf, so we need to
2013 // treat negative and positive offsets differently.
Ana Krulec757f63a2019-01-25 10:46:18 -08002014 nsecs_t idealLatency = (mPhaseOffsets->getCurrentSfOffset() > 0)
2015 ? (stats.vsyncPeriod - (mPhaseOffsets->getCurrentSfOffset() % stats.vsyncPeriod))
2016 : ((-mPhaseOffsets->getCurrentSfOffset()) % stats.vsyncPeriod);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002017
Ana Krulec757f63a2019-01-25 10:46:18 -08002018 // Just in case mPhaseOffsets->getCurrentSfOffset() == -vsyncInterval.
Brian Andersond0010582017-03-07 13:20:31 -08002019 if (idealLatency <= 0) {
Ana Krulece588e312018-09-18 12:32:24 -07002020 idealLatency = stats.vsyncPeriod;
Brian Andersond0010582017-03-07 13:20:31 -08002021 }
2022
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002023 // Snap the latency to a value that removes scheduling jitter from the
2024 // composition and present times, which often have >1ms of jitter.
2025 // Reducing jitter is important if an app attempts to extrapolate
2026 // something (such as user input) to an accurate diasplay time.
Ana Krulec757f63a2019-01-25 10:46:18 -08002027 // Snapping also allows an app to precisely calculate mPhaseOffsets->getCurrentSfOffset()
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002028 // with (presentLatency % interval).
Ana Krulece588e312018-09-18 12:32:24 -07002029 nsecs_t bias = stats.vsyncPeriod / 2;
2030 int64_t extraVsyncs = (compositeToPresentLatency - idealLatency + bias) / stats.vsyncPeriod;
2031 nsecs_t snappedCompositeToPresentLatency =
2032 (extraVsyncs > 0) ? idealLatency + (extraVsyncs * stats.vsyncPeriod) : idealLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002033
David Sodman99974d22017-11-28 12:04:33 -08002034 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
Ana Krulece588e312018-09-18 12:32:24 -07002035 getBE().mCompositorTiming.deadline = stats.vsyncTime - idealLatency;
2036 getBE().mCompositorTiming.interval = stats.vsyncPeriod;
David Sodman99974d22017-11-28 12:04:33 -08002037 getBE().mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002038}
2039
David Sodman2b406362017-12-15 13:33:47 -08002040void SurfaceFlinger::postComposition()
Mathias Agopiancd60f992012-08-16 16:28:27 -07002041{
Dan Stoza9e56aa02015-11-02 13:00:03 -08002042 ATRACE_CALL();
2043 ALOGV("postComposition");
2044
Brian Anderson3546a3f2016-07-14 11:51:14 -07002045 // Release any buffers which were replaced this frame
Brian Andersonf6386862016-10-31 16:34:13 -07002046 nsecs_t dequeueReadyTime = systemTime();
Brian Anderson3546a3f2016-07-14 11:51:14 -07002047 for (auto& layer : mLayersWithQueuedFrames) {
Brian Andersonf6386862016-10-31 16:34:13 -07002048 layer->releasePendingBuffer(dequeueReadyTime);
Brian Anderson3546a3f2016-07-14 11:51:14 -07002049 }
2050
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07002051 // |mStateLock| not needed as we are on the main thread
Lloyd Pique32cbe282018-10-19 13:09:22 -07002052 const auto displayDevice = getDefaultDisplayDeviceLocked();
Brian Anderson3d4039d2016-09-23 16:31:30 -07002053
David Sodman73beded2017-11-15 11:56:06 -08002054 getBE().mGlCompositionDoneTimeline.updateSignalTimes();
Brian Anderson3d4039d2016-09-23 16:31:30 -07002055 std::shared_ptr<FenceTime> glCompositionDoneFenceTime;
Lloyd Pique32cbe282018-10-19 13:09:22 -07002056 if (displayDevice && getHwComposer().hasClientComposition(displayDevice->getId())) {
Brian Anderson3d4039d2016-09-23 16:31:30 -07002057 glCompositionDoneFenceTime =
Lloyd Pique31cb2942018-10-19 17:23:03 -07002058 std::make_shared<FenceTime>(displayDevice->getCompositionDisplay()
2059 ->getRenderSurface()
2060 ->getClientTargetAcquireFence());
David Sodman73beded2017-11-15 11:56:06 -08002061 getBE().mGlCompositionDoneTimeline.push(glCompositionDoneFenceTime);
Brian Anderson3d4039d2016-09-23 16:31:30 -07002062 } else {
2063 glCompositionDoneFenceTime = FenceTime::NO_FENCE;
2064 }
Brian Anderson3d4039d2016-09-23 16:31:30 -07002065
David Sodman73beded2017-11-15 11:56:06 -08002066 getBE().mDisplayTimeline.updateSignalTimes();
Ady Abrahambe0f9482019-04-24 15:41:53 -07002067 mPreviousPresentFences[1] = mPreviousPresentFences[0];
2068 mPreviousPresentFences[0] = displayDevice
2069 ? getHwComposer().getPresentFence(*displayDevice->getId())
2070 : Fence::NO_FENCE;
2071 auto presentFenceTime = std::make_shared<FenceTime>(mPreviousPresentFences[0]);
David Sodman73beded2017-11-15 11:56:06 -08002072 getBE().mDisplayTimeline.push(presentFenceTime);
Brian Anderson3d4039d2016-09-23 16:31:30 -07002073
Ana Krulece588e312018-09-18 12:32:24 -07002074 DisplayStatInfo stats;
Ana Krulecc2870422019-01-29 19:00:58 -08002075 mScheduler->getDisplayStatInfo(&stats);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002076
David Sodman2b406362017-12-15 13:33:47 -08002077 // We use the mRefreshStartTime which might be sampled a little later than
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002078 // when we started doing work for this frame, but that should be okay
2079 // since updateCompositorTiming has snapping logic.
Ana Krulece588e312018-09-18 12:32:24 -07002080 updateCompositorTiming(stats, mRefreshStartTime, presentFenceTime);
Brian Andersond0010582017-03-07 13:20:31 -08002081 CompositorTiming compositorTiming;
2082 {
David Sodman99974d22017-11-28 12:04:33 -08002083 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
2084 compositorTiming = getBE().mCompositorTiming;
Brian Andersond0010582017-03-07 13:20:31 -08002085 }
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002086
Robert Carr2047fae2016-11-28 14:09:09 -08002087 mDrawingState.traverseInZOrder([&](Layer* layer) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07002088 bool frameLatched =
2089 layer->onPostComposition(displayDevice->getId(), glCompositionDoneFenceTime,
2090 presentFenceTime, compositorTiming);
Dan Stozae77c7662016-05-13 11:37:28 -07002091 if (frameLatched) {
Robert Carr2047fae2016-11-28 14:09:09 -08002092 recordBufferingStats(layer->getName().string(),
2093 layer->getOccupancyHistory(false));
Dan Stozae77c7662016-05-13 11:37:28 -07002094 }
Robert Carr2047fae2016-11-28 14:09:09 -08002095 });
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002096
Brian Andersonfbc80ae2017-05-26 16:23:54 -07002097 if (presentFenceTime->isValid()) {
Ana Krulecc2870422019-01-29 19:00:58 -08002098 mScheduler->addPresentFence(presentFenceTime);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07002099 }
2100
Fabien Sanglardcbf153b2017-03-10 17:57:12 -08002101 if (!hasSyncFramework) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07002102 if (displayDevice && getHwComposer().isConnected(*displayDevice->getId()) &&
2103 displayDevice->isPoweredOn()) {
Ana Krulecc2870422019-01-29 19:00:58 -08002104 mScheduler->enableHardwareVsync();
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07002105 }
2106 }
2107
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002108 if (mAnimCompositionPending) {
2109 mAnimCompositionPending = false;
2110
Brian Anderson4e606e32017-03-16 15:34:57 -07002111 if (presentFenceTime->isValid()) {
Brian Anderson3d4039d2016-09-23 16:31:30 -07002112 mAnimFrameTracker.setActualPresentFence(
Brian Anderson4e606e32017-03-16 15:34:57 -07002113 std::move(presentFenceTime));
Lloyd Pique32cbe282018-10-19 13:09:22 -07002114 } else if (displayDevice && getHwComposer().isConnected(*displayDevice->getId())) {
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002115 // The HWC doesn't support present fences, so use the refresh
2116 // timestamp instead.
Lloyd Pique32cbe282018-10-19 13:09:22 -07002117 const nsecs_t presentTime =
2118 getHwComposer().getRefreshTimestamp(*displayDevice->getId());
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002119 mAnimFrameTracker.setActualPresentTime(presentTime);
2120 }
2121 mAnimFrameTracker.advanceFrame();
2122 }
Dan Stozab90cf072015-03-05 11:05:59 -08002123
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002124 mTimeStats->incrementTotalFrames();
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07002125 if (mHadClientComposition) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002126 mTimeStats->incrementClientCompositionFrames();
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07002127 }
2128
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002129 mTimeStats->setPresentFenceGlobal(presentFenceTime);
Yiwei Zhangce6ebc02018-10-20 12:42:38 -07002130
Lloyd Pique32cbe282018-10-19 13:09:22 -07002131 if (displayDevice && getHwComposer().isConnected(*displayDevice->getId()) &&
2132 !displayDevice->isPoweredOn()) {
Dan Stozab90cf072015-03-05 11:05:59 -08002133 return;
2134 }
2135
2136 nsecs_t currentTime = systemTime();
2137 if (mHasPoweredOff) {
2138 mHasPoweredOff = false;
2139 } else {
David Sodman4a36e932017-11-07 14:29:47 -08002140 nsecs_t elapsedTime = currentTime - getBE().mLastSwapTime;
Ana Krulece588e312018-09-18 12:32:24 -07002141 size_t numPeriods = static_cast<size_t>(elapsedTime / stats.vsyncPeriod);
David Sodman4a36e932017-11-07 14:29:47 -08002142 if (numPeriods < SurfaceFlingerBE::NUM_BUCKETS - 1) {
2143 getBE().mFrameBuckets[numPeriods] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002144 } else {
David Sodman4a36e932017-11-07 14:29:47 -08002145 getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002146 }
David Sodman4a36e932017-11-07 14:29:47 -08002147 getBE().mTotalTime += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002148 }
David Sodman4a36e932017-11-07 14:29:47 -08002149 getBE().mLastSwapTime = currentTime;
Dan Stoza436ccf32018-06-21 12:10:12 -07002150
2151 {
2152 std::lock_guard lock(mTexturePoolMutex);
Dan Stoza67765d82019-05-07 14:58:27 -07002153 if (mTexturePool.size() < mTexturePoolSize) {
2154 const size_t refillCount = mTexturePoolSize - mTexturePool.size();
Dan Stoza436ccf32018-06-21 12:10:12 -07002155 const size_t offset = mTexturePool.size();
2156 mTexturePool.resize(mTexturePoolSize);
2157 getRenderEngine().genTextures(refillCount, mTexturePool.data() + offset);
2158 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Dan Stoza67765d82019-05-07 14:58:27 -07002159 } else if (mTexturePool.size() > mTexturePoolSize) {
2160 const size_t deleteCount = mTexturePool.size() - mTexturePoolSize;
2161 const size_t offset = mTexturePoolSize;
2162 getRenderEngine().deleteTextures(deleteCount, mTexturePool.data() + offset);
2163 mTexturePool.resize(mTexturePoolSize);
2164 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Dan Stoza436ccf32018-06-21 12:10:12 -07002165 }
2166 }
Marissa Walle2ffb422018-10-12 11:33:52 -07002167
Ady Abrahambe0f9482019-04-24 15:41:53 -07002168 mTransactionCompletedThread.addPresentFence(mPreviousPresentFences[0]);
Marissa Wallefb71af2019-06-27 14:45:53 -07002169 mTransactionCompletedThread.sendCallbacks();
Ady Abraham8164d482019-01-11 14:47:59 -08002170
Kevin DuBois413287f2019-02-25 08:46:47 -08002171 if (mLumaSampling && mRegionSamplingThread) {
2172 mRegionSamplingThread->notifyNewContent();
Dan Stozaec460082018-12-17 15:35:09 -08002173 }
Dan Stoza45de5ba2019-04-25 14:12:09 -07002174
2175 // Even though ATRACE_INT64 already checks if tracing is enabled, it doesn't prevent the
2176 // side-effect of getTotalSize(), so we check that again here
2177 if (ATRACE_ENABLED()) {
2178 ATRACE_INT64("Total Buffer Size", GraphicBufferAllocator::get().getTotalSize());
2179 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07002180}
2181
Vishnu Nair4351ad52019-02-11 14:13:02 -08002182void SurfaceFlinger::computeLayerBounds() {
2183 for (const auto& pair : mDisplays) {
2184 const auto& displayDevice = pair.second;
2185 const auto display = displayDevice->getCompositionDisplay();
2186 for (const auto& layer : mDrawingState.layersSortedByZ) {
2187 // only consider the layers on the given layer stack
2188 if (!display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
Vishnu Nair01ace762019-02-12 14:25:24 -08002189 continue;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002190 }
2191
2192 layer->computeBounds(displayDevice->getViewport().toFloatRect(), ui::Transform());
2193 }
2194 }
2195}
2196
Mathias Agopiancd60f992012-08-16 16:28:27 -07002197void SurfaceFlinger::rebuildLayerStacks() {
Dan Stoza9e56aa02015-11-02 13:00:03 -08002198 ATRACE_CALL();
2199 ALOGV("rebuildLayerStacks");
2200
Mathias Agopiancd60f992012-08-16 16:28:27 -07002201 // rebuild the visible layer list per screen
Jeff Sharkey76488112017-02-27 14:15:18 -07002202 if (CC_UNLIKELY(mVisibleRegionsDirty)) {
Siarhei Vishniakoufc2589e2017-09-21 15:35:13 -07002203 ATRACE_NAME("rebuildLayerStacks VR Dirty");
Jeff Sharkey76488112017-02-27 14:15:18 -07002204 invalidateHwcGeometry();
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002205
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002206 for (const auto& pair : mDisplays) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07002207 const auto& displayDevice = pair.second;
2208 auto display = displayDevice->getCompositionDisplay();
2209 const auto& displayState = display->getState();
Jeff Sharkey76488112017-02-27 14:15:18 -07002210 Region opaqueRegion;
2211 Region dirtyRegion;
Lloyd Piquecc01a452018-12-04 17:24:00 -08002212 compositionengine::Output::OutputLayers layersSortedByZ;
2213 Vector<sp<Layer>> deprecated_layersSortedByZ;
Chia-I Wu83806892017-11-16 10:50:20 -08002214 Vector<sp<Layer>> layersNeedingFences;
Lloyd Pique32cbe282018-10-19 13:09:22 -07002215 const ui::Transform& tr = displayState.transform;
2216 const Rect bounds = displayState.bounds;
2217 if (displayState.isEnabled) {
2218 computeVisibleRegions(displayDevice, dirtyRegion, opaqueRegion);
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002219
Jeff Sharkey76488112017-02-27 14:15:18 -07002220 mDrawingState.traverseInZOrder([&](Layer* layer) {
Lloyd Piquecc01a452018-12-04 17:24:00 -08002221 auto compositionLayer = layer->getCompositionLayer();
2222 if (compositionLayer == nullptr) {
2223 return;
2224 }
2225
Lloyd Pique32cbe282018-10-19 13:09:22 -07002226 const auto displayId = displayDevice->getId();
Lloyd Piquecc01a452018-12-04 17:24:00 -08002227 sp<compositionengine::LayerFE> layerFE = compositionLayer->getLayerFE();
2228 LOG_ALWAYS_FATAL_IF(layerFE.get() == nullptr);
2229
Lloyd Pique07e33212018-12-18 16:33:37 -08002230 bool needsOutputLayer = false;
2231
Lloyd Piqueef36b002019-01-23 17:52:04 -08002232 if (display->belongsInOutput(layer->getLayerStack(),
2233 layer->getPrimaryDisplayOnly())) {
Jeff Sharkey76488112017-02-27 14:15:18 -07002234 Region drawRegion(tr.transform(
2235 layer->visibleNonTransparentRegion));
2236 drawRegion.andSelf(bounds);
2237 if (!drawRegion.isEmpty()) {
Lloyd Pique07e33212018-12-18 16:33:37 -08002238 needsOutputLayer = true;
Jeff Sharkey76488112017-02-27 14:15:18 -07002239 }
Chia-I Wu83806892017-11-16 10:50:20 -08002240 }
2241
Lloyd Pique07e33212018-12-18 16:33:37 -08002242 if (needsOutputLayer) {
2243 layersSortedByZ.emplace_back(
2244 display->getOrCreateOutputLayer(displayId, compositionLayer,
2245 layerFE));
2246 deprecated_layersSortedByZ.add(layer);
2247
2248 auto& outputLayerState = layersSortedByZ.back()->editState();
2249 outputLayerState.visibleRegion =
2250 tr.transform(layer->visibleRegion.intersect(displayState.viewport));
2251 } else if (displayId) {
2252 // For layers that are being removed from a HWC display,
2253 // and that have queued frames, add them to a a list of
2254 // released layers so we can properly set a fence.
2255 bool hasExistingOutputLayer =
2256 display->getOutputLayerForLayer(compositionLayer.get()) != nullptr;
2257 bool hasQueuedFrames = std::find(mLayersWithQueuedFrames.cbegin(),
2258 mLayersWithQueuedFrames.cend(),
2259 layer) != mLayersWithQueuedFrames.cend();
2260
2261 if (hasExistingOutputLayer && hasQueuedFrames) {
Chia-I Wu83806892017-11-16 10:50:20 -08002262 layersNeedingFences.add(layer);
2263 }
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002264 }
Jeff Sharkey76488112017-02-27 14:15:18 -07002265 });
2266 }
Lloyd Piquecc01a452018-12-04 17:24:00 -08002267
2268 display->setOutputLayersOrderedByZ(std::move(layersSortedByZ));
2269
2270 displayDevice->setVisibleLayersSortedByZ(deprecated_layersSortedByZ);
Lloyd Pique32cbe282018-10-19 13:09:22 -07002271 displayDevice->setLayersNeedingFences(layersNeedingFences);
2272
2273 Region undefinedRegion{bounds};
2274 undefinedRegion.subtractSelf(tr.transform(opaqueRegion));
2275
2276 display->editState().undefinedRegion = undefinedRegion;
2277 display->editState().dirtyRegion.orSelf(dirtyRegion);
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002278 }
Fabien Sanglard3beb7112017-02-24 17:33:52 -08002279 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07002280}
Mathias Agopian3b1d2b62012-07-11 13:48:17 -07002281
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002282// Returns a data space that fits all visible layers. The returned data space
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002283// can only be one of
Chia-I Wu7a28ecb2018-05-04 10:38:39 -07002284// - Dataspace::SRGB (use legacy dataspace and let HWC saturate when colors are enhanced)
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002285// - Dataspace::DISPLAY_P3
Valerie Hau9758ae02018-10-09 16:05:09 -07002286// - Dataspace::DISPLAY_BT2020
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002287// The returned HDR data space is one of
2288// - Dataspace::UNKNOWN
2289// - Dataspace::BT2020_HLG
2290// - Dataspace::BT2020_PQ
Peiyong Lin03912882019-04-16 15:34:46 -07002291Dataspace SurfaceFlinger::getBestDataspace(const sp<DisplayDevice>& display,
2292 Dataspace* outHdrDataSpace,
2293 bool* outIsHdrClientComposition) const {
Peiyong Lin14724e62018-12-05 07:27:30 -08002294 Dataspace bestDataSpace = Dataspace::V0_SRGB;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002295 *outHdrDataSpace = Dataspace::UNKNOWN;
2296
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002297 for (const auto& layer : display->getVisibleLayersSortedByZ()) {
Chia-I Wu01591c92018-05-22 12:03:00 -07002298 switch (layer->getDataSpace()) {
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002299 case Dataspace::V0_SCRGB:
2300 case Dataspace::V0_SCRGB_LINEAR:
Valerie Hau9758ae02018-10-09 16:05:09 -07002301 case Dataspace::BT2020:
2302 case Dataspace::BT2020_ITU:
2303 case Dataspace::BT2020_LINEAR:
2304 case Dataspace::DISPLAY_BT2020:
2305 bestDataSpace = Dataspace::DISPLAY_BT2020;
2306 break;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002307 case Dataspace::DISPLAY_P3:
Chia-I Wube02ec02018-05-18 10:59:36 -07002308 bestDataSpace = Dataspace::DISPLAY_P3;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002309 break;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002310 case Dataspace::BT2020_PQ:
2311 case Dataspace::BT2020_ITU_PQ:
Peiyong Linf6eb7662019-02-05 15:39:15 -08002312 bestDataSpace = Dataspace::DISPLAY_P3;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002313 *outHdrDataSpace = Dataspace::BT2020_PQ;
Lloyd Piquef5275482019-01-29 18:42:42 -08002314 *outIsHdrClientComposition =
2315 layer->getCompositionLayer()->getState().frontEnd.forceClientComposition;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002316 break;
Peiyong Linf59a7192018-04-25 11:19:31 -07002317 case Dataspace::BT2020_HLG:
2318 case Dataspace::BT2020_ITU_HLG:
Peiyong Linf6eb7662019-02-05 15:39:15 -08002319 bestDataSpace = Dataspace::DISPLAY_P3;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002320 // When there's mixed PQ content and HLG content, we set the HDR
2321 // data space to be BT2020_PQ and convert HLG to PQ.
2322 if (*outHdrDataSpace == Dataspace::UNKNOWN) {
2323 *outHdrDataSpace = Dataspace::BT2020_HLG;
Peiyong Linf59a7192018-04-25 11:19:31 -07002324 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002325 break;
2326 default:
2327 break;
2328 }
Romain Guy54f154a2017-10-24 21:40:32 +01002329 }
2330
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002331 return bestDataSpace;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06002332}
2333
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002334// Pick the ColorMode / Dataspace for the display device.
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002335void SurfaceFlinger::pickColorMode(const sp<DisplayDevice>& display, ColorMode* outMode,
2336 Dataspace* outDataSpace, RenderIntent* outRenderIntent) const {
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002337 if (mDisplayColorSetting == DisplayColorSetting::UNMANAGED) {
2338 *outMode = ColorMode::NATIVE;
2339 *outDataSpace = Dataspace::UNKNOWN;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002340 *outRenderIntent = RenderIntent::COLORIMETRIC;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002341 return;
Chia-I Wu5c6e4632018-01-11 08:54:38 -08002342 }
Romain Guy88d37dd2017-05-26 17:57:05 -07002343
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002344 Dataspace hdrDataSpace;
Peiyong Lin03912882019-04-16 15:34:46 -07002345 bool isHdrClientComposition = false;
2346 Dataspace bestDataSpace = getBestDataspace(display, &hdrDataSpace, &isHdrClientComposition);
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002347
Lloyd Pique3d0c02e2018-10-19 18:38:12 -07002348 auto* profile = display->getCompositionDisplay()->getDisplayColorProfile();
2349
Peiyong Lina3ea5592019-02-10 14:45:00 -08002350 switch (mForceColorMode) {
2351 case ColorMode::SRGB:
2352 bestDataSpace = Dataspace::V0_SRGB;
2353 break;
2354 case ColorMode::DISPLAY_P3:
2355 bestDataSpace = Dataspace::DISPLAY_P3;
2356 break;
2357 default:
2358 break;
2359 }
2360
Peiyong Lindfde5112018-06-05 10:58:41 -07002361 // respect hdrDataSpace only when there is no legacy HDR support
Peiyong Lin03912882019-04-16 15:34:46 -07002362 const bool isHdr = hdrDataSpace != Dataspace::UNKNOWN &&
2363 !profile->hasLegacyHdrSupport(hdrDataSpace) && !isHdrClientComposition;
Chia-I Wuc4b08bd2018-05-29 12:57:23 -07002364 if (isHdr) {
2365 bestDataSpace = hdrDataSpace;
2366 }
2367
Chia-I Wu0d711262018-05-21 15:19:35 -07002368 RenderIntent intent;
2369 switch (mDisplayColorSetting) {
2370 case DisplayColorSetting::MANAGED:
2371 case DisplayColorSetting::UNMANAGED:
Chia-I Wuc4b08bd2018-05-29 12:57:23 -07002372 intent = isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC;
Chia-I Wu0d711262018-05-21 15:19:35 -07002373 break;
2374 case DisplayColorSetting::ENHANCED:
Chia-I Wuc4b08bd2018-05-29 12:57:23 -07002375 intent = isHdr ? RenderIntent::TONE_MAP_ENHANCE : RenderIntent::ENHANCE;
Chia-I Wu0d711262018-05-21 15:19:35 -07002376 break;
2377 default: // vendor display color setting
2378 intent = static_cast<RenderIntent>(mDisplayColorSetting);
2379 break;
2380 }
Chia-I Wube02ec02018-05-18 10:59:36 -07002381
Lloyd Pique3d0c02e2018-10-19 18:38:12 -07002382 profile->getBestColorMode(bestDataSpace, intent, outDataSpace, outMode, outRenderIntent);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -06002383}
2384
Lloyd Pique32cbe282018-10-19 13:09:22 -07002385void SurfaceFlinger::beginFrame(const sp<DisplayDevice>& displayDevice) {
2386 auto display = displayDevice->getCompositionDisplay();
2387 const auto& displayState = display->getState();
2388
Alec Mourie7d1d4a2019-02-05 01:13:46 +00002389 bool dirty = !display->getDirtyRegion(false).isEmpty();
Lloyd Pique32cbe282018-10-19 13:09:22 -07002390 bool empty = displayDevice->getVisibleLayersSortedByZ().size() == 0;
2391 bool wasEmpty = !displayState.lastCompositionHadVisibleLayers;
David Sodman2b406362017-12-15 13:33:47 -08002392
David Sodmanfa9b2af2017-12-24 13:28:59 -08002393 // If nothing has changed (!dirty), don't recompose.
2394 // If something changed, but we don't currently have any visible layers,
2395 // and didn't when we last did a composition, then skip it this time.
2396 // The second rule does two things:
2397 // - When all layers are removed from a display, we'll emit one black
2398 // frame, then nothing more until we get new layers.
2399 // - When a display is created with a private layer stack, we won't
2400 // emit any black frames until a layer is added to the layer stack.
2401 bool mustRecompose = dirty && !(empty && wasEmpty);
David Sodman2b406362017-12-15 13:33:47 -08002402
Dominik Laskowski075d3172018-05-24 15:50:06 -07002403 const char flagPrefix[] = {'-', '+'};
2404 static_cast<void>(flagPrefix);
Lloyd Pique32cbe282018-10-19 13:09:22 -07002405 ALOGV_IF(displayDevice->isVirtual(), "%s: %s composition for %s (%cdirty %cempty %cwasEmpty)",
2406 __FUNCTION__, mustRecompose ? "doing" : "skipping",
2407 displayDevice->getDebugName().c_str(), flagPrefix[dirty], flagPrefix[empty],
2408 flagPrefix[wasEmpty]);
David Sodman2b406362017-12-15 13:33:47 -08002409
Lloyd Pique31cb2942018-10-19 17:23:03 -07002410 display->getRenderSurface()->beginFrame(mustRecompose);
David Sodman2b406362017-12-15 13:33:47 -08002411
David Sodmanfa9b2af2017-12-24 13:28:59 -08002412 if (mustRecompose) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07002413 display->editState().lastCompositionHadVisibleLayers = !empty;
David Sodman2b406362017-12-15 13:33:47 -08002414 }
2415}
2416
Lloyd Pique32cbe282018-10-19 13:09:22 -07002417void SurfaceFlinger::prepareFrame(const sp<DisplayDevice>& displayDevice) {
2418 auto display = displayDevice->getCompositionDisplay();
2419 const auto& displayState = display->getState();
2420
2421 if (!displayState.isEnabled) {
David Sodmanfa9b2af2017-12-24 13:28:59 -08002422 return;
David Sodman2b406362017-12-15 13:33:47 -08002423 }
David Sodmanfa9b2af2017-12-24 13:28:59 -08002424
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08002425 status_t result = display->getRenderSurface()->prepareFrame();
Dominik Laskowski075d3172018-05-24 15:50:06 -07002426 ALOGE_IF(result != NO_ERROR, "prepareFrame failed for %s: %d (%s)",
Lloyd Pique32cbe282018-10-19 13:09:22 -07002427 displayDevice->getDebugName().c_str(), result, strerror(-result));
David Sodman2b406362017-12-15 13:33:47 -08002428}
Mathias Agopian52bbb1a2012-07-31 19:01:53 -07002429
Lloyd Pique32cbe282018-10-19 13:09:22 -07002430void SurfaceFlinger::doComposition(const sp<DisplayDevice>& displayDevice, bool repaintEverything) {
Mathias Agopiancd60f992012-08-16 16:28:27 -07002431 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08002432 ALOGV("doComposition");
2433
Lloyd Pique32cbe282018-10-19 13:09:22 -07002434 auto display = displayDevice->getCompositionDisplay();
2435 const auto& displayState = display->getState();
2436
2437 if (displayState.isEnabled) {
David Sodmanfa9b2af2017-12-24 13:28:59 -08002438 // transform the dirty region into this screen's coordinate space
Alec Mourie7d1d4a2019-02-05 01:13:46 +00002439 const Region dirtyRegion = display->getDirtyRegion(repaintEverything);
Mathias Agopian02b95102012-11-05 17:50:57 -08002440
David Sodmanfa9b2af2017-12-24 13:28:59 -08002441 // repaint the framebuffer (if needed)
Lloyd Pique32cbe282018-10-19 13:09:22 -07002442 doDisplayComposition(displayDevice, dirtyRegion);
Mathias Agopian02b95102012-11-05 17:50:57 -08002443
Lloyd Pique32cbe282018-10-19 13:09:22 -07002444 display->editState().dirtyRegion.clear();
Lloyd Pique31cb2942018-10-19 17:23:03 -07002445 display->getRenderSurface()->flip();
Mathias Agopian4fec8732012-06-29 14:12:52 -07002446 }
Lloyd Pique32cbe282018-10-19 13:09:22 -07002447 postFramebuffer(displayDevice);
Mathias Agopian4fec8732012-06-29 14:12:52 -07002448}
2449
David Sodmanfa9b2af2017-12-24 13:28:59 -08002450void SurfaceFlinger::postFrame()
2451{
2452 // |mStateLock| not needed as we are on the main thread
Dominik Laskowski075d3172018-05-24 15:50:06 -07002453 const auto display = getDefaultDisplayDeviceLocked();
2454 if (display && getHwComposer().isConnected(*display->getId())) {
2455 uint32_t flipCount = display->getPageFlipCount();
David Sodmanfa9b2af2017-12-24 13:28:59 -08002456 if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
2457 logFrameStats();
2458 }
2459 }
2460}
2461
Lloyd Pique32cbe282018-10-19 13:09:22 -07002462void SurfaceFlinger::postFramebuffer(const sp<DisplayDevice>& displayDevice) {
Mathias Agopian841cde52012-03-01 15:44:37 -08002463 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08002464 ALOGV("postFramebuffer");
Mathias Agopianb048cef2012-02-04 15:44:04 -08002465
Lloyd Pique32cbe282018-10-19 13:09:22 -07002466 auto display = displayDevice->getCompositionDisplay();
2467 const auto& displayState = display->getState();
2468 const auto displayId = display->getId();
2469
Lloyd Pique32cbe282018-10-19 13:09:22 -07002470 if (displayState.isEnabled) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002471 if (displayId) {
2472 getHwComposer().presentAndGetReleaseFences(*displayId);
Mathias Agopian2a231842012-09-24 18:12:35 -07002473 }
Lloyd Pique31cb2942018-10-19 17:23:03 -07002474 display->getRenderSurface()->onPresentDisplayCompleted();
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002475 for (auto& layer : display->getOutputLayersOrderedByZ()) {
Chia-I Wu0f509fb2018-06-21 15:52:50 +08002476 sp<Fence> releaseFence = Fence::NO_FENCE;
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002477 bool usedClientComposition = true;
David Sodman15094112018-10-11 09:39:37 -07002478
Chia-I Wu7b549592017-11-15 09:14:57 -08002479 // The layer buffer from the previous frame (if any) is released
2480 // by HWC only when the release fence from this frame (if any) is
2481 // signaled. Always get the release fence from HWC first.
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002482 if (layer->getState().hwc) {
2483 const auto& hwcState = *layer->getState().hwc;
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08002484 releaseFence =
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002485 getHwComposer().getLayerReleaseFence(*displayId, hwcState.hwcLayer.get());
2486 usedClientComposition =
2487 hwcState.hwcCompositionType == Hwc2::IComposerClient::Composition::CLIENT;
Chia-I Wu0f509fb2018-06-21 15:52:50 +08002488 }
Chia-I Wu7b549592017-11-15 09:14:57 -08002489
2490 // If the layer was client composited in the previous frame, we
2491 // need to merge with the previous client target acquire fence.
2492 // Since we do not track that, always merge with the current
2493 // client target acquire fence when it is available, even though
2494 // this is suboptimal.
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002495 if (usedClientComposition) {
Lloyd Pique31cb2942018-10-19 17:23:03 -07002496 releaseFence =
2497 Fence::merge("LayerRelease", releaseFence,
2498 display->getRenderSurface()->getClientTargetAcquireFence());
Mathias Agopian52bbb1a2012-07-31 19:01:53 -07002499 }
Chia-I Wu7b549592017-11-15 09:14:57 -08002500
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002501 layer->getLayerFE().onLayerDisplayed(releaseFence);
Dan Stoza9e56aa02015-11-02 13:00:03 -08002502 }
Chia-I Wu83806892017-11-16 10:50:20 -08002503
2504 // We've got a list of layers needing fences, that are disjoint with
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002505 // display->getVisibleLayersSortedByZ. The best we can do is to
Chia-I Wu83806892017-11-16 10:50:20 -08002506 // supply them with the present fence.
Lloyd Pique32cbe282018-10-19 13:09:22 -07002507 if (!displayDevice->getLayersNeedingFences().isEmpty()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002508 sp<Fence> presentFence =
Lloyd Pique441d5042018-10-18 16:49:51 -07002509 displayId ? getHwComposer().getPresentFence(*displayId) : Fence::NO_FENCE;
Lloyd Pique32cbe282018-10-19 13:09:22 -07002510 for (auto& layer : displayDevice->getLayersNeedingFences()) {
Lloyd Piquecb54b3b2019-01-29 18:42:54 -08002511 layer->getCompositionLayer()->getLayerFE()->onLayerDisplayed(presentFence);
Chia-I Wu83806892017-11-16 10:50:20 -08002512 }
2513 }
2514
Dominik Laskowski075d3172018-05-24 15:50:06 -07002515 if (displayId) {
2516 getHwComposer().clearReleaseFences(*displayId);
Jesse Hallef194142012-06-14 14:45:17 -07002517 }
Jamie Gennise8696a42012-01-15 18:54:57 -08002518 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002519}
2520
Mathias Agopian87baae12012-07-31 12:38:26 -07002521void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002522{
Mathias Agopian841cde52012-03-01 15:44:37 -08002523 ATRACE_CALL();
2524
Mathias Agopian7cc6df52013-06-05 14:30:54 -07002525 // here we keep a copy of the drawing state (that is the state that's
2526 // going to be overwritten by handleTransactionLocked()) outside of
2527 // mStateLock so that the side-effects of the State assignment
2528 // don't happen with mStateLock held (which can cause deadlocks).
2529 State drawingState(mDrawingState);
2530
Mathias Agopianca4d3602011-05-19 15:38:14 -07002531 Mutex::Autolock _l(mStateLock);
Dominik Laskowski9dab3432019-03-27 13:21:10 -07002532 mDebugInTransaction = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002533
Mathias Agopianca4d3602011-05-19 15:38:14 -07002534 // Here we're guaranteed that some transaction flags are set
2535 // so we can call handleTransactionLocked() unconditionally.
2536 // We call getTransactionFlags(), which will also clear the flags,
2537 // with mStateLock held to guarantee that mCurrentState won't change
2538 // until the transaction is committed.
Mathias Agopian4da75192010-08-10 17:19:56 -07002539
Jorim Jaggif15c3be2018-04-12 12:56:58 +01002540 mVsyncModulator.onTransactionHandled();
Mathias Agopiane57f2922012-08-09 16:29:12 -07002541 transactionFlags = getTransactionFlags(eTransactionMask);
Mathias Agopian87baae12012-07-31 12:38:26 -07002542 handleTransactionLocked(transactionFlags);
Mathias Agopiandea20b12011-05-03 17:04:02 -07002543
Mathias Agopianca4d3602011-05-19 15:38:14 -07002544 mDebugInTransaction = 0;
2545 invalidateHwcGeometry();
2546 // here the transaction has been committed
Mathias Agopian3d579642009-06-04 18:46:21 -07002547}
2548
Lloyd Piqueba04e622017-12-14 17:11:26 -08002549void SurfaceFlinger::processDisplayHotplugEventsLocked() {
2550 for (const auto& event : mPendingHotplugEvents) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002551 const std::optional<DisplayIdentificationInfo> info =
2552 getHwComposer().onHotplug(event.hwcDisplayId, event.connection);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002553
Dominik Laskowski075d3172018-05-24 15:50:06 -07002554 if (!info) {
Lloyd Piqueba04e622017-12-14 17:11:26 -08002555 continue;
2556 }
2557
Lloyd Piqueba04e622017-12-14 17:11:26 -08002558 if (event.connection == HWC2::Connection::Connected) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002559 if (!mPhysicalDisplayTokens.count(info->id)) {
Dominik Laskowski34157762018-10-31 13:07:19 -07002560 ALOGV("Creating display %s", to_string(info->id).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07002561 mPhysicalDisplayTokens[info->id] = new BBinder();
2562 DisplayDeviceState state;
2563 state.displayId = info->id;
2564 state.isSecure = true; // All physical displays are currently considered secure.
2565 state.displayName = info->name;
2566 mCurrentState.displays.add(mPhysicalDisplayTokens[info->id], state);
2567 mInterceptor->saveDisplayCreation(state);
Steven Thomaseb6d2052018-03-20 15:40:48 -07002568 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08002569 } else {
Dominik Laskowski34157762018-10-31 13:07:19 -07002570 ALOGV("Removing display %s", to_string(info->id).c_str());
Lloyd Piqueba04e622017-12-14 17:11:26 -08002571
Dominik Laskowski075d3172018-05-24 15:50:06 -07002572 ssize_t index = mCurrentState.displays.indexOfKey(mPhysicalDisplayTokens[info->id]);
2573 if (index >= 0) {
2574 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
2575 mInterceptor->saveDisplayDeletion(state.sequenceId);
2576 mCurrentState.displays.removeItemsAt(index);
Lloyd Piquefcd86612017-12-14 17:15:36 -08002577 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07002578 mPhysicalDisplayTokens.erase(info->id);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002579 }
2580
2581 processDisplayChangesLocked();
2582 }
2583
2584 mPendingHotplugEvents.clear();
2585}
2586
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002587void SurfaceFlinger::dispatchDisplayHotplugEvent(PhysicalDisplayId displayId, bool connected) {
Ana Krulecc2870422019-01-29 19:00:58 -08002588 mScheduler->hotplugReceived(mAppConnectionHandle, displayId, connected);
2589 mScheduler->hotplugReceived(mSfConnectionHandle, displayId, connected);
Dominik Laskowski1eba0202019-01-24 09:14:40 -08002590}
2591
Lloyd Pique99d3da52018-01-22 17:48:03 -08002592sp<DisplayDevice> SurfaceFlinger::setupNewDisplayDeviceInternal(
Dominik Laskowski075d3172018-05-24 15:50:06 -07002593 const wp<IBinder>& displayToken, const std::optional<DisplayId>& displayId,
Lloyd Pique542307f2018-10-19 13:24:08 -07002594 const DisplayDeviceState& state, const sp<compositionengine::DisplaySurface>& dispSurface,
Dominik Laskowski075d3172018-05-24 15:50:06 -07002595 const sp<IGraphicBufferProducer>& producer) {
2596 DisplayDeviceCreationArgs creationArgs(this, displayToken, displayId);
Dominik Laskowskie9774092018-12-11 10:04:24 -08002597 creationArgs.sequenceId = state.sequenceId;
Dominik Laskowski075d3172018-05-24 15:50:06 -07002598 creationArgs.isVirtual = state.isVirtual();
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002599 creationArgs.isSecure = state.isSecure;
2600 creationArgs.displaySurface = dispSurface;
2601 creationArgs.hasWideColorGamut = false;
2602 creationArgs.supportedPerFrameMetadata = 0;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002603
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002604 const bool isInternalDisplay = displayId && displayId == getInternalDisplayIdLocked();
Dominik Laskowski075d3172018-05-24 15:50:06 -07002605 creationArgs.isPrimary = isInternalDisplay;
2606
2607 if (useColorManagement && displayId) {
2608 std::vector<ColorMode> modes = getHwComposer().getColorModes(*displayId);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002609 for (ColorMode colorMode : modes) {
Peiyong Linfca547f2018-07-09 13:03:33 -07002610 if (isWideColorMode(colorMode)) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002611 creationArgs.hasWideColorGamut = true;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002612 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002613
Dominik Laskowski7e045462018-05-30 13:02:02 -07002614 std::vector<RenderIntent> renderIntents =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002615 getHwComposer().getRenderIntents(*displayId, colorMode);
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002616 creationArgs.hwcColorModes.emplace(colorMode, renderIntents);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002617 }
tangrobin6753a022018-08-10 10:58:54 +08002618 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002619
Dominik Laskowski075d3172018-05-24 15:50:06 -07002620 if (displayId) {
2621 getHwComposer().getHdrCapabilities(*displayId, &creationArgs.hdrCapabilities);
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002622 creationArgs.supportedPerFrameMetadata =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002623 getHwComposer().getSupportedPerFrameMetadata(*displayId);
Chia-I Wu0f509fb2018-06-21 15:52:50 +08002624 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002625
Lloyd Pique90c115d2018-09-18 21:39:42 -07002626 auto nativeWindowSurface = getFactory().createNativeWindowSurface(producer);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002627 auto nativeWindow = nativeWindowSurface->getNativeWindow();
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002628 creationArgs.nativeWindow = nativeWindow;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002629
Lloyd Pique99d3da52018-01-22 17:48:03 -08002630 // Make sure that composition can never be stalled by a virtual display
2631 // consumer that isn't processing buffers fast enough. We have to do this
Alec Mouri0a9c7b82018-11-16 13:05:25 -08002632 // here, in case the display is composed entirely by HWC.
Dominik Laskowski281644e2018-04-19 15:47:35 -07002633 if (state.isVirtual()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002634 nativeWindow->setSwapInterval(nativeWindow.get(), 0);
2635 }
2636
Dominik Laskowski075d3172018-05-24 15:50:06 -07002637 creationArgs.displayInstallOrientation =
2638 isInternalDisplay ? primaryDisplayOrientation : DisplayState::eOrientationDefault;
Chia-I Wua02871c2018-08-27 14:38:23 -07002639
Lloyd Pique99d3da52018-01-22 17:48:03 -08002640 // virtual displays are always considered enabled
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002641 creationArgs.initialPowerMode = state.isVirtual() ? HWC_POWER_MODE_NORMAL : HWC_POWER_MODE_OFF;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002642
Lloyd Pique90c115d2018-09-18 21:39:42 -07002643 sp<DisplayDevice> display = getFactory().createDisplayDevice(std::move(creationArgs));
Lloyd Pique99d3da52018-01-22 17:48:03 -08002644
2645 if (maxFrameBufferAcquiredBuffers >= 3) {
2646 nativeWindowSurface->preallocateBuffers();
2647 }
2648
2649 ColorMode defaultColorMode = ColorMode::NATIVE;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002650 Dataspace defaultDataSpace = Dataspace::UNKNOWN;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002651 if (display->hasWideColorGamut()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002652 defaultColorMode = ColorMode::SRGB;
Peiyong Lin14724e62018-12-05 07:27:30 -08002653 defaultDataSpace = Dataspace::V0_SRGB;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002654 }
Lloyd Pique32cbe282018-10-19 13:09:22 -07002655 display->getCompositionDisplay()->setColorMode(defaultColorMode, defaultDataSpace,
Lloyd Piquef5275482019-01-29 18:42:42 -08002656 RenderIntent::COLORIMETRIC, Dataspace::UNKNOWN);
Dominik Laskowski075d3172018-05-24 15:50:06 -07002657 if (!state.isVirtual()) {
2658 LOG_ALWAYS_FATAL_IF(!displayId);
2659 display->setActiveConfig(getHwComposer().getActiveConfigIndex(*displayId));
Lloyd Pique3c085a02018-05-09 19:38:32 -07002660 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07002661
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002662 display->setLayerStack(state.layerStack);
2663 display->setProjection(state.orientation, state.viewport, state.frame);
2664 display->setDisplayName(state.displayName);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002665
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002666 return display;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002667}
2668
Lloyd Pique347200f2017-12-14 17:00:15 -08002669void SurfaceFlinger::processDisplayChangesLocked() {
2670 // here we take advantage of Vector's copy-on-write semantics to
2671 // improve performance by skipping the transaction entirely when
2672 // know that the lists are identical
2673 const KeyedVector<wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
2674 const KeyedVector<wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
2675 if (!curr.isIdenticalTo(draw)) {
2676 mVisibleRegionsDirty = true;
2677 const size_t cc = curr.size();
2678 size_t dc = draw.size();
2679
2680 // find the displays that were removed
2681 // (ie: in drawing state but not in current state)
2682 // also handle displays that changed
2683 // (ie: displays that are in both lists)
2684 for (size_t i = 0; i < dc;) {
2685 const ssize_t j = curr.indexOfKey(draw.keyAt(i));
2686 if (j < 0) {
2687 // in drawing state but not in current state
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002688 if (const auto display = getDisplayDeviceLocked(draw.keyAt(i))) {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002689 // Save display ID before disconnecting.
2690 const auto displayId = display->getId();
Lloyd Pique45a165a2018-10-19 11:54:47 -07002691 display->disconnect();
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002692
2693 if (!display->isVirtual()) {
2694 LOG_ALWAYS_FATAL_IF(!displayId);
2695 dispatchDisplayHotplugEvent(displayId->value, false);
2696 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002697 }
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002698
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002699 mDisplays.erase(draw.keyAt(i));
Lloyd Pique347200f2017-12-14 17:00:15 -08002700 } else {
2701 // this display is in both lists. see if something changed.
2702 const DisplayDeviceState& state(curr[j]);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002703 const wp<IBinder>& displayToken = curr.keyAt(j);
Lloyd Pique347200f2017-12-14 17:00:15 -08002704 const sp<IBinder> state_binder = IInterface::asBinder(state.surface);
2705 const sp<IBinder> draw_binder = IInterface::asBinder(draw[i].surface);
2706 if (state_binder != draw_binder) {
2707 // changing the surface is like destroying and
2708 // recreating the DisplayDevice, so we just remove it
2709 // from the drawing state, so that it get re-added
2710 // below.
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002711 if (const auto display = getDisplayDeviceLocked(displayToken)) {
Lloyd Pique45a165a2018-10-19 11:54:47 -07002712 display->disconnect();
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002713 }
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002714 mDisplays.erase(displayToken);
Lloyd Pique347200f2017-12-14 17:00:15 -08002715 mDrawingState.displays.removeItemsAt(i);
2716 dc--;
2717 // at this point we must loop to the next item
2718 continue;
2719 }
2720
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002721 if (const auto display = getDisplayDeviceLocked(displayToken)) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002722 if (state.layerStack != draw[i].layerStack) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002723 display->setLayerStack(state.layerStack);
Lloyd Pique347200f2017-12-14 17:00:15 -08002724 }
2725 if ((state.orientation != draw[i].orientation) ||
2726 (state.viewport != draw[i].viewport) || (state.frame != draw[i].frame)) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002727 display->setProjection(state.orientation, state.viewport, state.frame);
Lloyd Pique347200f2017-12-14 17:00:15 -08002728 }
2729 if (state.width != draw[i].width || state.height != draw[i].height) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002730 display->setDisplaySize(state.width, state.height);
Lloyd Pique347200f2017-12-14 17:00:15 -08002731 }
2732 }
2733 }
2734 ++i;
2735 }
2736
2737 // find displays that were added
2738 // (ie: in current state but not in drawing state)
2739 for (size_t i = 0; i < cc; i++) {
2740 if (draw.indexOfKey(curr.keyAt(i)) < 0) {
2741 const DisplayDeviceState& state(curr[i]);
2742
Lloyd Pique542307f2018-10-19 13:24:08 -07002743 sp<compositionengine::DisplaySurface> dispSurface;
Lloyd Pique347200f2017-12-14 17:00:15 -08002744 sp<IGraphicBufferProducer> producer;
2745 sp<IGraphicBufferProducer> bqProducer;
2746 sp<IGraphicBufferConsumer> bqConsumer;
Lloyd Pique90c115d2018-09-18 21:39:42 -07002747 getFactory().createBufferQueue(&bqProducer, &bqConsumer, false);
Lloyd Pique347200f2017-12-14 17:00:15 -08002748
Dominik Laskowski075d3172018-05-24 15:50:06 -07002749 std::optional<DisplayId> displayId;
Dominik Laskowski663bd282018-04-19 15:26:54 -07002750 if (state.isVirtual()) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002751 // Virtual displays without a surface are dormant:
2752 // they have external state (layer stack, projection,
2753 // etc.) but no internal state (i.e. a DisplayDevice).
2754 if (state.surface != nullptr) {
2755 // Allow VR composer to use virtual displays.
Dominik Laskowski075d3172018-05-24 15:50:06 -07002756 if (mUseHwcVirtualDisplays || getHwComposer().isUsingVrComposer()) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002757 int width = 0;
2758 int status = state.surface->query(NATIVE_WINDOW_WIDTH, &width);
2759 ALOGE_IF(status != NO_ERROR, "Unable to query width (%d)", status);
2760 int height = 0;
2761 status = state.surface->query(NATIVE_WINDOW_HEIGHT, &height);
2762 ALOGE_IF(status != NO_ERROR, "Unable to query height (%d)", status);
2763 int intFormat = 0;
2764 status = state.surface->query(NATIVE_WINDOW_FORMAT, &intFormat);
2765 ALOGE_IF(status != NO_ERROR, "Unable to query format (%d)", status);
Peiyong Lin34beb7a2018-03-28 11:57:12 -07002766 auto format = static_cast<ui::PixelFormat>(intFormat);
Lloyd Pique347200f2017-12-14 17:00:15 -08002767
Dominik Laskowski075d3172018-05-24 15:50:06 -07002768 displayId =
2769 getHwComposer().allocateVirtualDisplay(width, height, &format);
Lloyd Pique347200f2017-12-14 17:00:15 -08002770 }
2771
2772 // TODO: Plumb requested format back up to consumer
2773
2774 sp<VirtualDisplaySurface> vds =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002775 new VirtualDisplaySurface(getHwComposer(), displayId, state.surface,
Lloyd Pique347200f2017-12-14 17:00:15 -08002776 bqProducer, bqConsumer,
2777 state.displayName);
2778
2779 dispSurface = vds;
2780 producer = vds;
2781 }
2782 } else {
2783 ALOGE_IF(state.surface != nullptr,
2784 "adding a supported display, but rendering "
2785 "surface is provided (%p), ignoring it",
2786 state.surface.get());
2787
Dominik Laskowski075d3172018-05-24 15:50:06 -07002788 displayId = state.displayId;
2789 LOG_ALWAYS_FATAL_IF(!displayId);
2790 dispSurface = new FramebufferSurface(getHwComposer(), *displayId, bqConsumer);
Lloyd Pique347200f2017-12-14 17:00:15 -08002791 producer = bqProducer;
2792 }
2793
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002794 const wp<IBinder>& displayToken = curr.keyAt(i);
Lloyd Pique347200f2017-12-14 17:00:15 -08002795 if (dispSurface != nullptr) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002796 mDisplays.emplace(displayToken,
Dominik Laskowski7e045462018-05-30 13:02:02 -07002797 setupNewDisplayDeviceInternal(displayToken, displayId, state,
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002798 dispSurface, producer));
Dominik Laskowski663bd282018-04-19 15:26:54 -07002799 if (!state.isVirtual()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002800 LOG_ALWAYS_FATAL_IF(!displayId);
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002801 dispatchDisplayHotplugEvent(displayId->value, true);
Lloyd Pique347200f2017-12-14 17:00:15 -08002802 }
2803 }
2804 }
2805 }
2806 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08002807
2808 mDrawingState.displays = mCurrentState.displays;
Lloyd Pique347200f2017-12-14 17:00:15 -08002809}
2810
Mathias Agopian87baae12012-07-31 12:38:26 -07002811void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
Mathias Agopian3d579642009-06-04 18:46:21 -07002812{
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07002813 const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
2814
Dan Stoza7dde5992015-05-22 09:51:44 -07002815 // Notify all layers of available frames
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07002816 mCurrentState.traverseInZOrder([expectedPresentTime](Layer* layer) {
2817 layer->notifyAvailableFrames(expectedPresentTime);
Robert Carr2047fae2016-11-28 14:09:09 -08002818 });
Dan Stoza7dde5992015-05-22 09:51:44 -07002819
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002820 /*
2821 * Traversal of the children
2822 * (perform the transaction for each of them if needed)
2823 */
2824
Marissa Wall06255332019-03-27 13:48:27 -07002825 if ((transactionFlags & eTraversalNeeded) || mTraversalNeededMainThread) {
Robert Carr2047fae2016-11-28 14:09:09 -08002826 mCurrentState.traverseInZOrder([&](Layer* layer) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002827 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
Robert Carr2047fae2016-11-28 14:09:09 -08002828 if (!trFlags) return;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002829
2830 const uint32_t flags = layer->doTransaction(0);
2831 if (flags & Layer::eVisibleRegion)
2832 mVisibleRegionsDirty = true;
Robert Carr720e5062018-07-30 17:45:14 -07002833
2834 if (flags & Layer::eInputInfoChanged) {
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002835 mInputInfoChanged = true;
Robert Carr720e5062018-07-30 17:45:14 -07002836 }
Robert Carr2047fae2016-11-28 14:09:09 -08002837 });
Marissa Wall06255332019-03-27 13:48:27 -07002838 mTraversalNeededMainThread = false;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002839 }
2840
2841 /*
Mathias Agopian3559b072012-08-15 13:46:03 -07002842 * Perform display own transactions if needed
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002843 */
2844
Mathias Agopiane57f2922012-08-09 16:29:12 -07002845 if (transactionFlags & eDisplayTransactionNeeded) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002846 processDisplayChangesLocked();
Lloyd Piqueba04e622017-12-14 17:11:26 -08002847 processDisplayHotplugEventsLocked();
Mathias Agopian3559b072012-08-15 13:46:03 -07002848 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002849
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002850 if (transactionFlags & (eDisplayLayerStackChanged|eDisplayTransactionNeeded)) {
Mathias Agopian84300952012-11-21 16:02:13 -08002851 // The transform hint might have changed for some layers
2852 // (either because a display has changed, or because a layer
2853 // as changed).
2854 //
2855 // Walk through all the layers in currentLayers,
2856 // and update their transform hint.
2857 //
2858 // If a layer is visible only on a single display, then that
2859 // display is used to calculate the hint, otherwise we use the
2860 // default display.
2861 //
2862 // NOTE: we do this here, rather than in rebuildLayerStacks() so that
2863 // the hint is set before we acquire a buffer from the surface texture.
2864 //
2865 // NOTE: layer transactions have taken place already, so we use their
2866 // drawing state. However, SurfaceFlinger's own transaction has not
2867 // happened yet, so we must use the current state layer list
2868 // (soon to become the drawing state list).
2869 //
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002870 sp<const DisplayDevice> hintDisplay;
Mathias Agopian84300952012-11-21 16:02:13 -08002871 uint32_t currentlayerStack = 0;
Robert Carr2047fae2016-11-28 14:09:09 -08002872 bool first = true;
2873 mCurrentState.traverseInZOrder([&](Layer* layer) {
Mathias Agopian84300952012-11-21 16:02:13 -08002874 // NOTE: we rely on the fact that layers are sorted by
2875 // layerStack first (so we don't have to traverse the list
2876 // of displays for every layer).
Robert Carr1f0a16a2016-10-24 16:27:39 -07002877 uint32_t layerStack = layer->getLayerStack();
Robert Carr2047fae2016-11-28 14:09:09 -08002878 if (first || currentlayerStack != layerStack) {
Mathias Agopian84300952012-11-21 16:02:13 -08002879 currentlayerStack = layerStack;
2880 // figure out if this layerstack is mirrored
2881 // (more than one display) if so, pick the default display,
2882 // if not, pick the only display it's on.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002883 hintDisplay = nullptr;
2884 for (const auto& [token, display] : mDisplays) {
Lloyd Piqueef36b002019-01-23 17:52:04 -08002885 if (display->getCompositionDisplay()
2886 ->belongsInOutput(layer->getLayerStack(),
2887 layer->getPrimaryDisplayOnly())) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002888 if (hintDisplay) {
2889 hintDisplay = nullptr;
Mathias Agopian84300952012-11-21 16:02:13 -08002890 break;
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002891 } else {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002892 hintDisplay = display;
Mathias Agopian84300952012-11-21 16:02:13 -08002893 }
2894 }
2895 }
2896 }
Chet Haase91d25932013-04-11 15:24:55 -07002897
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002898 if (!hintDisplay) {
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002899 // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
2900 // redraw after transform hint changes. See bug 8508397.
Robert Carr56a0b9a2017-12-04 16:06:13 -08002901
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002902 // could be null when this layer is using a layerStack
2903 // that is not visible on any display. Also can occur at
2904 // screen off/on times.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002905 hintDisplay = getDefaultDisplayDeviceLocked();
Mathias Agopian84300952012-11-21 16:02:13 -08002906 }
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002907
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002908 // could be null if there is no display available at all to get
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002909 // the transform hint from.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002910 if (hintDisplay) {
2911 layer->updateTransformHint(hintDisplay);
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08002912 }
Robert Carr2047fae2016-11-28 14:09:09 -08002913
2914 first = false;
2915 });
Mathias Agopian84300952012-11-21 16:02:13 -08002916 }
2917
2918
Mathias Agopian3559b072012-08-15 13:46:03 -07002919 /*
2920 * Perform our own transaction if needed
2921 */
Robert Carr1f0a16a2016-10-24 16:27:39 -07002922
2923 if (mLayersAdded) {
2924 mLayersAdded = false;
2925 // Layers have been added.
Mathias Agopian3559b072012-08-15 13:46:03 -07002926 mVisibleRegionsDirty = true;
2927 }
2928
2929 // some layers might have been removed, so
2930 // we need to update the regions they're exposing.
2931 if (mLayersRemoved) {
2932 mLayersRemoved = false;
2933 mVisibleRegionsDirty = true;
Robert Carr2047fae2016-11-28 14:09:09 -08002934 mDrawingState.traverseInZOrder([&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07002935 if (mLayersPendingRemoval.indexOf(layer) >= 0) {
Mathias Agopian3559b072012-08-15 13:46:03 -07002936 // this layer is not visible anymore
Robert Carr1f0a16a2016-10-24 16:27:39 -07002937 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002938 visibleReg.set(layer->getScreenBounds());
Chia-I Wuab0c3192017-08-01 11:29:00 -07002939 invalidateLayerStack(layer, visibleReg);
Mathias Agopian0aa758d2009-04-22 15:23:34 -07002940 }
Robert Carr2047fae2016-11-28 14:09:09 -08002941 });
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002942 }
2943
Vishnu Nairec0ab382019-02-13 15:32:56 -08002944 commitInputWindowCommands();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002945 commitTransaction();
Riley Andrews03414a12014-07-01 14:22:59 -07002946}
2947
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002948void SurfaceFlinger::updateInputFlinger() {
Robert Carr720e5062018-07-30 17:45:14 -07002949 ATRACE_CALL();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002950 if (!mInputFlinger) {
Vishnu Nairde19f852018-12-18 16:11:53 -08002951 return;
2952 }
2953
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002954 if (mVisibleRegionsDirty || mInputInfoChanged) {
2955 mInputInfoChanged = false;
2956 updateInputWindowInfo();
chaviw95ef3c42019-02-14 10:55:09 -08002957 } else if (mInputWindowCommands.syncInputWindows) {
2958 // If the caller requested to sync input windows, but there are no
2959 // changes to input windows, notify immediately.
2960 setInputWindowsFinished();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002961 }
2962
2963 executeInputWindowCommands();
2964}
2965
2966void SurfaceFlinger::updateInputWindowInfo() {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002967 std::vector<InputWindowInfo> inputHandles;
Robert Carr720e5062018-07-30 17:45:14 -07002968
2969 mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
2970 if (layer->hasInput()) {
Vishnu Nair51625fa2018-12-06 13:54:33 -08002971 // When calculating the screen bounds we ignore the transparent region since it may
2972 // result in an unwanted offset.
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002973 inputHandles.push_back(layer->fillInputInfo());
Robert Carr720e5062018-07-30 17:45:14 -07002974 }
2975 });
chaviw291d88a2019-02-14 10:33:58 -08002976
2977 mInputFlinger->setInputWindows(inputHandles,
2978 mInputWindowCommands.syncInputWindows ? mSetInputWindowsListener
2979 : nullptr);
Robert Carr720e5062018-07-30 17:45:14 -07002980}
2981
Vishnu Nairec0ab382019-02-13 15:32:56 -08002982void SurfaceFlinger::commitInputWindowCommands() {
chaviw4fe36852019-04-15 16:25:49 -07002983 mInputWindowCommands = mPendingInputWindowCommands;
Vishnu Nairec0ab382019-02-13 15:32:56 -08002984 mPendingInputWindowCommands.clear();
2985}
2986
chaviwfbe5d9c2018-12-26 12:23:37 -08002987void SurfaceFlinger::executeInputWindowCommands() {
chaviwfbe5d9c2018-12-26 12:23:37 -08002988 for (const auto& transferTouchFocusCommand : mInputWindowCommands.transferTouchFocusCommands) {
2989 if (transferTouchFocusCommand.fromToken != nullptr &&
2990 transferTouchFocusCommand.toToken != nullptr &&
2991 transferTouchFocusCommand.fromToken != transferTouchFocusCommand.toToken) {
2992 mInputFlinger->transferTouchFocus(transferTouchFocusCommand.fromToken,
2993 transferTouchFocusCommand.toToken);
2994 }
2995 }
2996
2997 mInputWindowCommands.clear();
2998}
2999
Riley Andrews03414a12014-07-01 14:22:59 -07003000void SurfaceFlinger::updateCursorAsync()
3001{
Dominik Laskowski9fae1022018-05-29 13:17:40 -07003002 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07003003 if (!display->getId()) {
Riley Andrews03414a12014-07-01 14:22:59 -07003004 continue;
3005 }
Dan Stoza9e56aa02015-11-02 13:00:03 -08003006
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003007 for (auto& layer : display->getVisibleLayersSortedByZ()) {
3008 layer->updateCursorPosition(display);
Riley Andrews03414a12014-07-01 14:22:59 -07003009 }
3010 }
Mathias Agopian4fec8732012-06-29 14:12:52 -07003011}
3012
chaviw61626f22018-11-15 16:26:27 -08003013void SurfaceFlinger::latchAndReleaseBuffer(const sp<Layer>& layer) {
3014 if (layer->hasReadyFrame()) {
Robert Carra0629232019-02-07 15:28:54 -08003015 bool ignored = false;
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003016 layer->latchBuffer(ignored, systemTime(), 0 /* expectedPresentTime */);
chaviw61626f22018-11-15 16:26:27 -08003017 }
3018 layer->releasePendingBuffer(systemTime());
3019}
3020
Mathias Agopian4fec8732012-06-29 14:12:52 -07003021void SurfaceFlinger::commitTransaction()
3022{
Steve Pfetsch598f6d52016-10-25 21:47:58 +00003023 if (!mLayersPendingRemoval.isEmpty()) {
Mathias Agopian4fec8732012-06-29 14:12:52 -07003024 // Notify removed layers now that they can't be drawn from
Robert Carr1f0a16a2016-10-24 16:27:39 -07003025 for (const auto& l : mLayersPendingRemoval) {
3026 recordBufferingStats(l->getName().string(),
3027 l->getOccupancyHistory(true));
Robert Carr2e102c92018-10-23 12:11:15 -07003028
Lloyd Pique07e33212018-12-18 16:33:37 -08003029 // Ensure any buffers set to display on any children are released.
Robert Carr2e102c92018-10-23 12:11:15 -07003030 if (l->isRemovedFromCurrentState()) {
Robert Carr6fb1a7e2018-12-11 12:07:25 -08003031 latchAndReleaseBuffer(l);
Robert Carr2e102c92018-10-23 12:11:15 -07003032 }
chaviw74d90ad2019-04-26 14:45:26 -07003033
3034 // If the layer has been removed and has no parent, then it will not be reachable
3035 // when traversing layers on screen. Add the layer to the offscreenLayers set to
3036 // ensure we can copy its current to drawing state.
3037 if (!l->getParent()) {
3038 mOffscreenLayers.emplace(l.get());
3039 }
Mathias Agopian4fec8732012-06-29 14:12:52 -07003040 }
3041 mLayersPendingRemoval.clear();
3042 }
3043
Jamie Gennis4b0eba92013-02-05 13:30:24 -08003044 // If this transaction is part of a window animation then the next frame
3045 // we composite should be considered an animation as well.
3046 mAnimCompositionPending = mAnimTransactionPending;
3047
Nataniel Borges2b796da2019-02-15 13:32:18 -08003048 withTracingLock([&]() {
3049 mDrawingState = mCurrentState;
3050 // clear the "changed" flags in current state
3051 mCurrentState.colorMatrixChanged = false;
Chia-I Wu28f320b2018-05-03 11:02:56 -07003052
chaviw74d90ad2019-04-26 14:45:26 -07003053 mDrawingState.traverseInZOrder([&](Layer* layer) {
3054 layer->commitChildList();
3055
3056 // If the layer can be reached when traversing mDrawingState, then the layer is no
3057 // longer offscreen. Remove the layer from the offscreenLayer set.
3058 if (mOffscreenLayers.count(layer)) {
3059 mOffscreenLayers.erase(layer);
3060 }
3061 });
3062
3063 commitOffscreenLayers();
Robert Carr1f0a16a2016-10-24 16:27:39 -07003064 });
Nataniel Borges2b796da2019-02-15 13:32:18 -08003065
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003066 mTransactionPending = false;
3067 mAnimTransactionPending = false;
Mathias Agopian4fec8732012-06-29 14:12:52 -07003068 mTransactionCV.broadcast();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003069}
3070
Nataniel Borges2b796da2019-02-15 13:32:18 -08003071void SurfaceFlinger::withTracingLock(std::function<void()> lockedOperation) {
3072 if (mTracingEnabledChanged) {
3073 mTracingEnabled = mTracing.isEnabled();
3074 mTracingEnabledChanged = false;
3075 }
3076
3077 // Synchronize with Tracing thread
3078 std::unique_lock<std::mutex> lock;
3079 if (mTracingEnabled) {
3080 lock = std::unique_lock<std::mutex>(mDrawingStateLock);
3081 }
3082
3083 lockedOperation();
3084
3085 // Synchronize with Tracing thread
3086 if (mTracingEnabled) {
3087 lock.unlock();
3088 }
3089}
3090
chaviw74d90ad2019-04-26 14:45:26 -07003091void SurfaceFlinger::commitOffscreenLayers() {
3092 for (Layer* offscreenLayer : mOffscreenLayers) {
3093 offscreenLayer->traverseInZOrder(LayerVector::StateSet::Drawing, [](Layer* layer) {
3094 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
3095 if (!trFlags) return;
3096
3097 layer->doTransaction(0);
3098 layer->commitChildList();
3099 });
3100 }
3101}
3102
Lloyd Pique32cbe282018-10-19 13:09:22 -07003103void SurfaceFlinger::computeVisibleRegions(const sp<const DisplayDevice>& displayDevice,
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003104 Region& outDirtyRegion, Region& outOpaqueRegion) {
Mathias Agopian841cde52012-03-01 15:44:37 -08003105 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08003106 ALOGV("computeVisibleRegions");
Mathias Agopian841cde52012-03-01 15:44:37 -08003107
Lloyd Pique32cbe282018-10-19 13:09:22 -07003108 auto display = displayDevice->getCompositionDisplay();
3109
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003110 Region aboveOpaqueLayers;
3111 Region aboveCoveredLayers;
3112 Region dirty;
3113
Mathias Agopian87baae12012-07-31 12:38:26 -07003114 outDirtyRegion.clear();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003115
Robert Carr2047fae2016-11-28 14:09:09 -08003116 mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08003117 // start with the whole surface at its current location
3118 const Layer::State& s(layer->getDrawingState());
3119
Jesse Hall01e29052013-02-19 16:13:35 -08003120 // only consider the layers on the given layer stack
Lloyd Piqueef36b002019-01-23 17:52:04 -08003121 if (!display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
Robert Carr2047fae2016-11-28 14:09:09 -08003122 return;
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003123 }
Mathias Agopian87baae12012-07-31 12:38:26 -07003124
Mathias Agopianab028732010-03-16 16:41:46 -07003125 /*
3126 * opaqueRegion: area of a surface that is fully opaque.
3127 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003128 Region opaqueRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07003129
3130 /*
3131 * visibleRegion: area of a surface that is visible on screen
3132 * and not fully transparent. This is essentially the layer's
3133 * footprint minus the opaque regions above it.
3134 * Areas covered by a translucent surface are considered visible.
3135 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003136 Region visibleRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07003137
3138 /*
3139 * coveredRegion: area of a surface that is covered by all
3140 * visible regions above it (which includes the translucent areas).
3141 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003142 Region coveredRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07003143
Jesse Halla8026d22012-09-25 13:25:04 -07003144 /*
3145 * transparentRegion: area of a surface that is hinted to be completely
3146 * transparent. This is only used to tell when the layer has no visible
3147 * non-transparent regions and can be removed from the layer list. It
3148 * does not affect the visibleRegion of this layer or any layers
3149 * beneath it. The hint may not be correct if apps don't respect the
3150 * SurfaceView restrictions (which, sadly, some don't).
3151 */
3152 Region transparentRegion;
3153
Mathias Agopianab028732010-03-16 16:41:46 -07003154
3155 // handle hidden surfaces by setting the visible region to empty
Mathias Agopianda27af92012-09-13 18:17:13 -07003156 if (CC_LIKELY(layer->isVisible())) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08003157 const bool translucent = !layer->isOpaque(s);
Vishnu Nair4351ad52019-02-11 14:13:02 -08003158 Rect bounds(layer->getScreenBounds());
Robert Carr720e5062018-07-30 17:45:14 -07003159
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003160 visibleRegion.set(bounds);
Peiyong Linefefaac2018-08-17 12:27:51 -07003161 ui::Transform tr = layer->getTransform();
Mathias Agopianab028732010-03-16 16:41:46 -07003162 if (!visibleRegion.isEmpty()) {
3163 // Remove the transparent area from the visible region
3164 if (translucent) {
Dan Stoza22f7fc42016-05-10 16:19:53 -07003165 if (tr.preserveRects()) {
3166 // transform the transparent region
Lloyd Pique0449b0f2018-12-20 16:23:45 -08003167 transparentRegion = tr.transform(layer->getActiveTransparentRegion(s));
Mathias Agopian4fec8732012-06-29 14:12:52 -07003168 } else {
Dan Stoza22f7fc42016-05-10 16:19:53 -07003169 // transformation too complex, can't do the
3170 // transparent region optimization.
3171 transparentRegion.clear();
Mathias Agopian4fec8732012-06-29 14:12:52 -07003172 }
Mathias Agopianab028732010-03-16 16:41:46 -07003173 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003174
Mathias Agopianab028732010-03-16 16:41:46 -07003175 // compute the opaque region
Robert Carr1f0a16a2016-10-24 16:27:39 -07003176 const int32_t layerOrientation = tr.getOrientation();
Jorim Jaggi039bbb82017-09-06 18:12:05 +02003177 if (layer->getAlpha() == 1.0f && !translucent &&
Lucas Dupin1b6531c2018-07-05 17:18:21 -07003178 layer->getRoundedCornerState().radius == 0.0f &&
Peiyong Linefefaac2018-08-17 12:27:51 -07003179 ((layerOrientation & ui::Transform::ROT_INVALID) == false)) {
Mathias Agopianab028732010-03-16 16:41:46 -07003180 // the opaque region is the layer's footprint
3181 opaqueRegion = visibleRegion;
3182 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003183 }
3184 }
3185
Robert Carre5f4f692018-01-12 13:12:28 -08003186 if (visibleRegion.isEmpty()) {
3187 layer->clearVisibilityRegions();
3188 return;
3189 }
3190
Mathias Agopianab028732010-03-16 16:41:46 -07003191 // Clip the covered region to the visible region
3192 coveredRegion = aboveCoveredLayers.intersect(visibleRegion);
3193
3194 // Update aboveCoveredLayers for next (lower) layer
3195 aboveCoveredLayers.orSelf(visibleRegion);
3196
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003197 // subtract the opaque region covered by the layers above us
3198 visibleRegion.subtractSelf(aboveOpaqueLayers);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003199
3200 // compute this layer's dirty region
3201 if (layer->contentDirty) {
3202 // we need to invalidate the whole region
3203 dirty = visibleRegion;
3204 // as well, as the old visible region
Mathias Agopian4fec8732012-06-29 14:12:52 -07003205 dirty.orSelf(layer->visibleRegion);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003206 layer->contentDirty = false;
3207 } else {
Mathias Agopiana8d44f72009-06-28 02:54:16 -07003208 /* compute the exposed region:
Mathias Agopianab028732010-03-16 16:41:46 -07003209 * the exposed region consists of two components:
3210 * 1) what's VISIBLE now and was COVERED before
3211 * 2) what's EXPOSED now less what was EXPOSED before
3212 *
3213 * note that (1) is conservative, we start with the whole
3214 * visible region but only keep what used to be covered by
3215 * something -- which mean it may have been exposed.
3216 *
3217 * (2) handles areas that were not covered by anything but got
3218 * exposed because of a resize.
Mathias Agopiana8d44f72009-06-28 02:54:16 -07003219 */
Mathias Agopianab028732010-03-16 16:41:46 -07003220 const Region newExposed = visibleRegion - coveredRegion;
Mathias Agopian4fec8732012-06-29 14:12:52 -07003221 const Region oldVisibleRegion = layer->visibleRegion;
3222 const Region oldCoveredRegion = layer->coveredRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07003223 const Region oldExposed = oldVisibleRegion - oldCoveredRegion;
3224 dirty = (visibleRegion&oldCoveredRegion) | (newExposed-oldExposed);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003225 }
3226 dirty.subtractSelf(aboveOpaqueLayers);
3227
3228 // accumulate to the screen dirty region
Mathias Agopian87baae12012-07-31 12:38:26 -07003229 outDirtyRegion.orSelf(dirty);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003230
Mathias Agopianab028732010-03-16 16:41:46 -07003231 // Update aboveOpaqueLayers for next (lower) layer
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003232 aboveOpaqueLayers.orSelf(opaqueRegion);
Andreas Huber8b42e8a2010-08-16 08:49:37 -07003233
Jesse Halla8026d22012-09-25 13:25:04 -07003234 // Store the visible region in screen space
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003235 layer->setVisibleRegion(visibleRegion);
3236 layer->setCoveredRegion(coveredRegion);
Jesse Halla8026d22012-09-25 13:25:04 -07003237 layer->setVisibleNonTransparentRegion(
3238 visibleRegion.subtract(transparentRegion));
Robert Carr2047fae2016-11-28 14:09:09 -08003239 });
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003240
Mathias Agopian87baae12012-07-31 12:38:26 -07003241 outOpaqueRegion = aboveOpaqueLayers;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003242}
3243
Chia-I Wuab0c3192017-08-01 11:29:00 -07003244void SurfaceFlinger::invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003245 for (const auto& [token, displayDevice] : mDisplays) {
3246 auto display = displayDevice->getCompositionDisplay();
Lloyd Piqueef36b002019-01-23 17:52:04 -08003247 if (display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003248 display->editState().dirtyRegion.orSelf(dirty);
Mathias Agopian92a979a2012-08-02 18:32:23 -07003249 }
3250 }
Mathias Agopian87baae12012-07-31 12:38:26 -07003251}
3252
Dan Stoza6b9454d2014-11-07 16:00:59 -08003253bool SurfaceFlinger::handlePageFlip()
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003254{
Ady Abraham09bd3922019-04-08 10:44:56 -07003255 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08003256 ALOGV("handlePageFlip");
3257
Brian Andersond6927fb2016-07-23 23:37:30 -07003258 nsecs_t latchTime = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003259
Mathias Agopian4fec8732012-06-29 14:12:52 -07003260 bool visibleRegions = false;
Dan Stoza6b9454d2014-11-07 16:00:59 -08003261 bool frameQueued = false;
Mike Stroyan0cd76192017-04-20 12:10:48 -06003262 bool newDataLatched = false;
Eric Penner51c59cd2014-07-28 19:51:58 -07003263
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003264 const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
3265
Eric Penner51c59cd2014-07-28 19:51:58 -07003266 // Store the set of layers that need updates. This set must not change as
3267 // buffers are being latched, as this could result in a deadlock.
3268 // Example: Two producers share the same command stream and:
3269 // 1.) Layer 0 is latched
3270 // 2.) Layer 0 gets a new frame
3271 // 2.) Layer 1 gets a new frame
3272 // 3.) Layer 1 is latched.
3273 // Display is now waiting on Layer 1's frame, which is behind layer 0's
3274 // second frame. But layer 0's second frame could be waiting on display.
Robert Carr2047fae2016-11-28 14:09:09 -08003275 mDrawingState.traverseInZOrder([&](Layer* layer) {
Marissa Wallfd668622018-05-10 10:21:13 -07003276 if (layer->hasReadyFrame()) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08003277 frameQueued = true;
Ana Krulec010d2192018-10-08 06:29:54 -07003278 if (layer->shouldPresentNow(expectedPresentTime)) {
Robert Carr2047fae2016-11-28 14:09:09 -08003279 mLayersWithQueuedFrames.push_back(layer);
Dan Stozaee44edd2015-03-23 15:50:23 -07003280 } else {
Ady Abraham09bd3922019-04-08 10:44:56 -07003281 ATRACE_NAME("!layer->shouldPresentNow()");
Dan Stozaee44edd2015-03-23 15:50:23 -07003282 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08003283 }
Dan Stozaee44edd2015-03-23 15:50:23 -07003284 } else {
3285 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08003286 }
Robert Carr2047fae2016-11-28 14:09:09 -08003287 });
3288
Lloyd Piquef2c79392018-12-20 16:23:33 -08003289 if (!mLayersWithQueuedFrames.empty()) {
3290 // mStateLock is needed for latchBuffer as LayerRejecter::reject()
3291 // writes to Layer current state. See also b/119481871
3292 Mutex::Autolock lock(mStateLock);
3293
3294 for (auto& layer : mLayersWithQueuedFrames) {
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003295 if (layer->latchBuffer(visibleRegions, latchTime, expectedPresentTime)) {
Vishnu Nair6194e2e2019-02-06 12:58:39 -08003296 mLayersPendingRefresh.push_back(layer);
3297 }
Lloyd Piquef2c79392018-12-20 16:23:33 -08003298 layer->useSurfaceDamage();
Lloyd Piquef2c79392018-12-20 16:23:33 -08003299 if (layer->isBufferLatched()) {
3300 newDataLatched = true;
3301 }
Mike Stroyan0cd76192017-04-20 12:10:48 -06003302 }
Mathias Agopian4fec8732012-06-29 14:12:52 -07003303 }
Mathias Agopian4da75192010-08-10 17:19:56 -07003304
Mathias Agopian3b1d2b62012-07-11 13:48:17 -07003305 mVisibleRegionsDirty |= visibleRegions;
Dan Stoza6b9454d2014-11-07 16:00:59 -08003306
3307 // If we will need to wake up at some time in the future to deal with a
3308 // queued frame that shouldn't be displayed during this vsync period, wake
3309 // up during the next vsync period to check again.
Chia-I Wua36bf922017-06-30 12:51:05 -07003310 if (frameQueued && (mLayersWithQueuedFrames.empty() || !newDataLatched)) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08003311 signalLayerUpdate();
3312 }
3313
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08003314 // enter boot animation on first buffer latch
3315 if (CC_UNLIKELY(mBootStage == BootStage::BOOTLOADER && newDataLatched)) {
3316 ALOGI("Enter boot animation");
3317 mBootStage = BootStage::BOOTANIMATION;
3318 }
3319
Dan Stoza6b9454d2014-11-07 16:00:59 -08003320 // Only continue with the refresh if there is actually new work to do
Mike Stroyan0cd76192017-04-20 12:10:48 -06003321 return !mLayersWithQueuedFrames.empty() && newDataLatched;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003322}
3323
Mathias Agopianad456f92011-01-13 17:53:01 -08003324void SurfaceFlinger::invalidateHwcGeometry()
3325{
Dan Stoza9e56aa02015-11-02 13:00:03 -08003326 mGeometryInvalid = true;
Mathias Agopianad456f92011-01-13 17:53:01 -08003327}
3328
Lloyd Pique32cbe282018-10-19 13:09:22 -07003329void SurfaceFlinger::doDisplayComposition(const sp<DisplayDevice>& displayDevice,
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003330 const Region& inDirtyRegion) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003331 auto display = displayDevice->getCompositionDisplay();
Dan Stoza71433162014-02-04 16:22:36 -08003332 // We only need to actually compose the display if:
3333 // 1) It is being handled by hardware composer, which may need this to
3334 // keep its virtual display state machine in sync, or
3335 // 2) There is work to be done (the dirty region isn't empty)
Lloyd Pique32cbe282018-10-19 13:09:22 -07003336 if (!displayDevice->getId() && inDirtyRegion.isEmpty()) {
Dan Stoza9e56aa02015-11-02 13:00:03 -08003337 ALOGV("Skipping display composition");
Dan Stoza71433162014-02-04 16:22:36 -08003338 return;
3339 }
3340
Dan Stoza9e56aa02015-11-02 13:00:03 -08003341 ALOGV("doDisplayComposition");
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003342 base::unique_fd readyFence;
3343 if (!doComposeSurfaces(displayDevice, Region::INVALID_REGION, &readyFence)) return;
Mathias Agopianda27af92012-09-13 18:17:13 -07003344
3345 // swap buffers (presentation)
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003346 display->getRenderSurface()->queueBuffer(std::move(readyFence));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003347}
3348
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003349bool SurfaceFlinger::doComposeSurfaces(const sp<DisplayDevice>& displayDevice,
3350 const Region& debugRegion, base::unique_fd* readyFence) {
Alec Mouri820c7402019-01-23 13:02:39 -08003351 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08003352 ALOGV("doComposeSurfaces");
Mathias Agopiancd20eb02011-09-22 20:57:04 -07003353
Lloyd Pique32cbe282018-10-19 13:09:22 -07003354 auto display = displayDevice->getCompositionDisplay();
3355 const auto& displayState = display->getState();
Dominik Laskowski7e045462018-05-30 13:02:02 -07003356 const auto displayId = display->getId();
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08003357 auto& renderEngine = getRenderEngine();
Peiyong Lin548d4fa2019-04-02 18:14:44 -07003358 const bool supportProtectedContent = renderEngine.supportsProtectedContent();
Lloyd Pique32cbe282018-10-19 13:09:22 -07003359
3360 const Region bounds(displayState.bounds);
3361 const DisplayRenderArea renderArea(displayDevice);
Ady Abraham50204dd2019-07-19 15:47:11 -07003362 const TracedOrdinal<bool> hasClientComposition = {"hasClientComposition",
3363 getHwComposer().hasClientComposition(
3364 displayId)};
Dan Stoza9f26a9c2016-06-22 14:51:09 -07003365
Chia-I Wu8e50e692018-05-04 10:12:37 -07003366 bool applyColorMatrix = false;
Dan Stoza9f26a9c2016-06-22 14:51:09 -07003367
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003368 renderengine::DisplaySettings clientCompositionDisplay;
3369 std::vector<renderengine::LayerSettings> clientCompositionLayers;
3370 sp<GraphicBuffer> buf;
Alec Mouri6338c9d2019-02-07 16:57:51 -08003371 base::unique_fd fd;
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003372
Dan Stoza9e56aa02015-11-02 13:00:03 -08003373 if (hasClientComposition) {
3374 ALOGV("hasClientComposition");
3375
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08003376 if (displayDevice->isPrimary() && supportProtectedContent) {
3377 bool needsProtected = false;
3378 for (auto& layer : displayDevice->getVisibleLayersSortedByZ()) {
3379 // If the layer is a protected layer, mark protected context is needed.
3380 if (layer->isProtected()) {
3381 needsProtected = true;
3382 break;
3383 }
3384 }
Peiyong Lin52010312019-05-02 14:22:16 -07003385 if (needsProtected != renderEngine.isProtected()) {
3386 renderEngine.useProtectedContext(needsProtected);
3387 }
3388 if (needsProtected != display->getRenderSurface()->isProtected() &&
3389 needsProtected == renderEngine.isProtected()) {
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08003390 display->getRenderSurface()->setProtected(needsProtected);
3391 }
3392 }
3393
Alec Mouri6338c9d2019-02-07 16:57:51 -08003394 buf = display->getRenderSurface()->dequeueBuffer(&fd);
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08003395
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003396 if (buf == nullptr) {
3397 ALOGW("Dequeuing buffer for display [%s] failed, bailing out of "
3398 "client composition for this frame",
Lloyd Pique32cbe282018-10-19 13:09:22 -07003399 displayDevice->getDisplayName().c_str());
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003400 return false;
3401 }
3402
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003403 clientCompositionDisplay.physicalDisplay = displayState.scissor;
3404 clientCompositionDisplay.clip = displayState.scissor;
3405 const ui::Transform& displayTransform = displayState.transform;
Lloyd Pique7e06e7f2019-03-15 18:36:44 -07003406 clientCompositionDisplay.globalTransform = displayTransform.asMatrix4();
Peiyong Linb1925962019-04-01 16:37:10 -07003407 clientCompositionDisplay.orientation = displayState.orientation;
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003408
Lloyd Pique3d0c02e2018-10-19 18:38:12 -07003409 const auto* profile = display->getDisplayColorProfile();
Peiyong Lin34beb7a2018-03-28 11:57:12 -07003410 Dataspace outputDataspace = Dataspace::UNKNOWN;
Lloyd Pique3d0c02e2018-10-19 18:38:12 -07003411 if (profile->hasWideColorGamut()) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003412 outputDataspace = displayState.dataspace;
Chia-I Wu69bf10f2018-02-20 13:04:50 -08003413 }
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003414 clientCompositionDisplay.outputDataspace = outputDataspace;
3415 clientCompositionDisplay.maxLuminance =
3416 profile->getHdrCapabilities().getDesiredMaxLuminance();
Chia-I Wu69bf10f2018-02-20 13:04:50 -08003417
Lloyd Pique441d5042018-10-18 16:49:51 -07003418 const bool hasDeviceComposition = getHwComposer().hasDeviceComposition(displayId);
Peiyong Lined531a32018-10-26 18:27:56 -07003419 const bool skipClientColorTransform =
Lloyd Pique441d5042018-10-18 16:49:51 -07003420 getHwComposer()
3421 .hasDisplayCapability(displayId,
3422 HWC2::DisplayCapability::SkipClientColorTransform);
Chia-I Wu8e50e692018-05-04 10:12:37 -07003423
Peiyong Lind3788632018-09-18 16:01:31 -07003424 // Compute the global color transform matrix.
Chia-I Wu8e50e692018-05-04 10:12:37 -07003425 applyColorMatrix = !hasDeviceComposition && !skipClientColorTransform;
3426 if (applyColorMatrix) {
Alec Mouric7e8ce82019-04-02 12:28:05 -07003427 clientCompositionDisplay.colorTransform = displayState.colorTransformMat;
Mathias Agopianf45c5102012-10-24 16:29:17 -07003428 }
Mathias Agopian85d751c2012-08-29 16:59:24 -07003429 }
Mathias Agopian4b2ba532012-03-29 12:23:51 -07003430
Mathias Agopian85d751c2012-08-29 16:59:24 -07003431 /*
3432 * and then, render the layers targeted at the framebuffer
3433 */
Mathias Agopian4b2ba532012-03-29 12:23:51 -07003434
Dan Stoza9e56aa02015-11-02 13:00:03 -08003435 ALOGV("Rendering client layers");
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003436 bool firstLayer = true;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003437 Region clearRegion = Region::INVALID_REGION;
Lloyd Pique32cbe282018-10-19 13:09:22 -07003438 for (auto& layer : displayDevice->getVisibleLayersSortedByZ()) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003439 const Region viewportRegion(displayState.viewport);
3440 const Region clip(viewportRegion.intersect(layer->visibleRegion));
David Sodmanc1498e62018-09-12 14:36:26 -07003441 ALOGV("Layer: %s", layer->getName().string());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08003442 ALOGV(" Composition type: %s", toString(layer->getCompositionType(displayDevice)).c_str());
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003443 if (!clip.isEmpty()) {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08003444 switch (layer->getCompositionType(displayDevice)) {
3445 case Hwc2::IComposerClient::Composition::CURSOR:
3446 case Hwc2::IComposerClient::Composition::DEVICE:
3447 case Hwc2::IComposerClient::Composition::SIDEBAND:
3448 case Hwc2::IComposerClient::Composition::SOLID_COLOR: {
Dominik Laskowski075d3172018-05-24 15:50:06 -07003449 LOG_ALWAYS_FATAL_IF(!displayId);
Lloyd Pique0449b0f2018-12-20 16:23:45 -08003450 const Layer::State& state(layer->getDrawingState());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08003451 if (layer->getClearClientTarget(displayDevice) && !firstLayer &&
Lloyd Pique0449b0f2018-12-20 16:23:45 -08003452 layer->isOpaque(state) && (layer->getAlpha() == 1.0f) &&
Lucas Dupin1b6531c2018-07-05 17:18:21 -07003453 layer->getRoundedCornerState().radius == 0.0f && hasClientComposition) {
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003454 // never clear the very first layer since we're
3455 // guaranteed the FB is already cleared
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003456 renderengine::LayerSettings layerSettings;
3457 Region dummyRegion;
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08003458 bool prepared =
3459 layer->prepareClientLayer(renderArea, clip, dummyRegion,
3460 supportProtectedContent, layerSettings);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003461
3462 if (prepared) {
3463 layerSettings.source.buffer.buffer = nullptr;
3464 layerSettings.source.solidColor = half3(0.0, 0.0, 0.0);
3465 layerSettings.alpha = half(0.0);
3466 layerSettings.disableBlending = true;
3467 clientCompositionLayers.push_back(layerSettings);
3468 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07003469 }
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003470 break;
Mathias Agopiancd60f992012-08-16 16:28:27 -07003471 }
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08003472 case Hwc2::IComposerClient::Composition::CLIENT: {
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003473 renderengine::LayerSettings layerSettings;
3474 bool prepared =
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08003475 layer->prepareClientLayer(renderArea, clip, clearRegion,
3476 supportProtectedContent, layerSettings);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003477 if (prepared) {
3478 clientCompositionLayers.push_back(layerSettings);
Peiyong Lind3788632018-09-18 16:01:31 -07003479 }
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003480 break;
3481 }
3482 default:
3483 break;
Mathias Agopian85d751c2012-08-29 16:59:24 -07003484 }
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003485 } else {
3486 ALOGV(" Skipping for empty clip");
Mathias Agopian85d751c2012-08-29 16:59:24 -07003487 }
Chia-I Wu5e9a43e2018-05-03 14:27:39 -07003488 firstLayer = false;
Mathias Agopian4b2ba532012-03-29 12:23:51 -07003489 }
Mathias Agopianf45c5102012-10-24 16:29:17 -07003490
Alec Mouri820c7402019-01-23 13:02:39 -08003491 // Perform some cleanup steps if we used client composition.
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003492 if (hasClientComposition) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003493 clientCompositionDisplay.clearRegion = clearRegion;
Peiyong Lin74ca2f42019-01-14 19:36:57 -08003494
3495 // We boost GPU frequency here because there will be color spaces conversion
3496 // and it's expensive. We boost the GPU frequency so that GPU composition can
3497 // finish in time. We must reset GPU frequency afterwards, because high frequency
3498 // consumes extra battery.
3499 const bool expensiveRenderingExpected =
3500 clientCompositionDisplay.outputDataspace == Dataspace::DISPLAY_P3;
3501 if (expensiveRenderingExpected && displayId) {
3502 mPowerAdvisor.setExpensiveRenderingExpected(*displayId, true);
3503 }
Alec Mourie7d1d4a2019-02-05 01:13:46 +00003504 if (!debugRegion.isEmpty()) {
3505 Region::const_iterator it = debugRegion.begin();
3506 Region::const_iterator end = debugRegion.end();
3507 while (it != end) {
3508 const Rect& rect = *it++;
3509 renderengine::LayerSettings layerSettings;
3510 layerSettings.source.buffer.buffer = nullptr;
3511 layerSettings.source.solidColor = half3(1.0, 0.0, 1.0);
3512 layerSettings.geometry.boundaries = rect.toFloatRect();
3513 layerSettings.alpha = half(1.0);
3514 clientCompositionLayers.push_back(layerSettings);
3515 }
3516 }
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08003517 renderEngine.drawLayers(clientCompositionDisplay, clientCompositionLayers,
Alec Mourife0d72b2019-03-21 14:05:56 -07003518 buf->getNativeBuffer(), /*useFramebufferCache=*/true, std::move(fd),
3519 readyFence);
Peiyong Lin8ec87f82019-04-05 11:30:51 -07003520 } else if (displayId) {
3521 mPowerAdvisor.setExpensiveRenderingExpected(*displayId, false);
Alec Mouri0a9c7b82018-11-16 13:05:25 -08003522 }
Michael Lentine3f121fc2014-10-01 11:17:28 -07003523 return true;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003524}
3525
Robert Carrc0df3122019-04-11 13:18:21 -07003526status_t SurfaceFlinger::addClientLayer(const sp<Client>& client, const sp<IBinder>& handle,
3527 const sp<IGraphicBufferProducer>& gbc, const sp<Layer>& lbc,
3528 const sp<IBinder>& parentHandle,
3529 const sp<Layer>& parentLayer, bool addToCurrentState) {
Dan Stoza7d89d062015-04-30 13:29:25 -07003530 // add this layer to the current state list
3531 {
3532 Mutex::Autolock _l(mStateLock);
Robert Carrc0df3122019-04-11 13:18:21 -07003533 sp<Layer> parent;
3534 if (parentHandle != nullptr) {
3535 parent = fromHandle(parentHandle);
3536 if (parent == nullptr) {
3537 return NAME_NOT_FOUND;
3538 }
3539 } else {
3540 parent = parentLayer;
3541 }
3542
Robert Carr1f0a16a2016-10-24 16:27:39 -07003543 if (mNumLayers >= MAX_LAYERS) {
Courtney Goeltzenleuchterab702f52017-04-19 15:14:02 -06003544 ALOGE("AddClientLayer failed, mNumLayers (%zu) >= MAX_LAYERS (%zu)", mNumLayers,
3545 MAX_LAYERS);
Dan Stoza7d89d062015-04-30 13:29:25 -07003546 return NO_MEMORY;
3547 }
Robert Carrc0df3122019-04-11 13:18:21 -07003548
3549 mLayersByLocalBinderToken.emplace(handle->localBinder(), lbc);
3550
Robert Carrb89ea9d2018-12-10 13:01:14 -08003551 if (parent == nullptr && addToCurrentState) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003552 mCurrentState.layersSortedByZ.add(lbc);
chaviwac841852019-01-16 16:04:43 -08003553 } else if (parent == nullptr) {
3554 lbc->onRemovedFromCurrentState();
3555 } else if (parent->isRemovedFromCurrentState()) {
3556 parent->addChild(lbc);
3557 lbc->onRemovedFromCurrentState();
Robert Carrb89ea9d2018-12-10 13:01:14 -08003558 } else {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003559 parent->addChild(lbc);
3560 }
Chia-I Wu98f1c102017-05-30 14:54:08 -07003561
Yiwei Zhang243b3782018-05-15 17:40:04 -07003562 if (gbc != nullptr) {
3563 mGraphicBufferProducerList.insert(IInterface::asBinder(gbc).get());
3564 LOG_ALWAYS_FATAL_IF(mGraphicBufferProducerList.size() >
3565 mMaxGraphicBufferProducerListSize,
3566 "Suspected IGBP leak: %zu IGBPs (%zu max), %zu Layers",
3567 mGraphicBufferProducerList.size(),
3568 mMaxGraphicBufferProducerListSize, mNumLayers);
3569 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07003570 mLayersAdded = true;
Dan Stoza7d89d062015-04-30 13:29:25 -07003571 }
3572
Mathias Agopian96f08192010-06-02 23:28:45 -07003573 // attach this layer to the client
Mathias Agopianac9fa422013-02-11 16:40:36 -08003574 client->attachLayer(handle, lbc);
Mathias Agopian4f113742011-05-03 16:21:41 -07003575
Dan Stoza7d89d062015-04-30 13:29:25 -07003576 return NO_ERROR;
Mathias Agopian96f08192010-06-02 23:28:45 -07003577}
3578
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08003579uint32_t SurfaceFlinger::peekTransactionFlags() {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003580 return mTransactionFlags;
Mathias Agopiandea20b12011-05-03 17:04:02 -07003581}
3582
Mathias Agopian3f844832013-08-07 21:24:32 -07003583uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003584 return mTransactionFlags.fetch_and(~flags) & flags;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003585}
3586
Mathias Agopian3f844832013-08-07 21:24:32 -07003587uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) {
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003588 return setTransactionFlags(flags, Scheduler::TransactionStart::NORMAL);
Dan Stoza84d619e2018-03-28 17:07:36 -07003589}
3590
3591uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags,
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003592 Scheduler::TransactionStart transactionStart) {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003593 uint32_t old = mTransactionFlags.fetch_or(flags);
Dan Stoza84d619e2018-03-28 17:07:36 -07003594 mVsyncModulator.setTransactionStart(transactionStart);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003595 if ((old & flags)==0) { // wake the server up
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08003596 signalTransaction();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003597 }
3598 return old;
3599}
3600
Marissa Wall713b63f2018-10-17 15:42:43 -07003601bool SurfaceFlinger::flushTransactionQueues() {
Valerie Haufce31b82019-04-30 16:41:14 -07003602 // to prevent onHandleDestroyed from being called while the lock is held,
3603 // we must keep a copy of the transactions (specifically the composer
3604 // states) around outside the scope of the lock
3605 std::vector<const TransactionState> transactions;
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003606 bool flushedATransaction = false;
Valerie Haufce31b82019-04-30 16:41:14 -07003607 {
3608 Mutex::Autolock _l(mStateLock);
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003609
Valerie Haufce31b82019-04-30 16:41:14 -07003610 auto it = mTransactionQueues.begin();
3611 while (it != mTransactionQueues.end()) {
3612 auto& [applyToken, transactionQueue] = *it;
Marissa Wall713b63f2018-10-17 15:42:43 -07003613
Valerie Haufce31b82019-04-30 16:41:14 -07003614 while (!transactionQueue.empty()) {
3615 const auto& transaction = transactionQueue.front();
3616 if (!transactionIsReadyToBeApplied(transaction.desiredPresentTime,
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003617 true /* useCachedExpectedPresentTime */,
Valerie Haufce31b82019-04-30 16:41:14 -07003618 transaction.states)) {
3619 setTransactionFlags(eTransactionFlushNeeded);
3620 break;
3621 }
3622 transactions.push_back(transaction);
3623 applyTransactionState(transaction.states, transaction.displays, transaction.flags,
3624 mPendingInputWindowCommands, transaction.desiredPresentTime,
3625 transaction.buffer, transaction.callback,
3626 transaction.postTime, transaction.privileged,
3627 /*isMainThread*/ true);
3628 transactionQueue.pop();
3629 flushedATransaction = true;
Marissa Wall713b63f2018-10-17 15:42:43 -07003630 }
Marissa Wall713b63f2018-10-17 15:42:43 -07003631
Valerie Haufce31b82019-04-30 16:41:14 -07003632 if (transactionQueue.empty()) {
3633 it = mTransactionQueues.erase(it);
3634 mTransactionCV.broadcast();
3635 } else {
Valerie Haue5562ec2019-05-14 12:39:16 -07003636 it = std::next(it, 1);
Valerie Haufce31b82019-04-30 16:41:14 -07003637 }
Valerie Hauf6016b62019-03-28 10:49:59 -07003638 }
Marissa Wall713b63f2018-10-17 15:42:43 -07003639 }
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003640 return flushedATransaction;
3641}
3642
3643bool SurfaceFlinger::transactionFlushNeeded() {
3644 return !mTransactionQueues.empty();
Marissa Wall713b63f2018-10-17 15:42:43 -07003645}
3646
chaviwca27f252018-02-06 16:46:39 -08003647
Marissa Wall17b4e452018-12-26 16:32:34 -08003648bool SurfaceFlinger::transactionIsReadyToBeApplied(int64_t desiredPresentTime,
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003649 bool useCachedExpectedPresentTime,
Marissa Wall17b4e452018-12-26 16:32:34 -08003650 const Vector<ComposerState>& states) {
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003651 if (!useCachedExpectedPresentTime)
3652 populateExpectedPresentTime();
3653
3654 const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
Marissa Wall17b4e452018-12-26 16:32:34 -08003655 // Do not present if the desiredPresentTime has not passed unless it is more than one second
3656 // in the future. We ignore timestamps more than 1 second in the future for stability reasons.
3657 if (desiredPresentTime >= 0 && desiredPresentTime >= expectedPresentTime &&
3658 desiredPresentTime < expectedPresentTime + s2ns(1)) {
3659 return false;
3660 }
3661
Marissa Wall713b63f2018-10-17 15:42:43 -07003662 for (const ComposerState& state : states) {
3663 const layer_state_t& s = state.state;
3664 if (!(s.what & layer_state_t::eAcquireFenceChanged)) {
3665 continue;
3666 }
3667 if (s.acquireFence && s.acquireFence->getStatus() == Fence::Status::Unsignaled) {
Marissa Wall17b4e452018-12-26 16:32:34 -08003668 return false;
Marissa Wall713b63f2018-10-17 15:42:43 -07003669 }
3670 }
Marissa Wall17b4e452018-12-26 16:32:34 -08003671 return true;
Marissa Wall713b63f2018-10-17 15:42:43 -07003672}
3673
3674void SurfaceFlinger::setTransactionState(const Vector<ComposerState>& states,
3675 const Vector<DisplayState>& displays, uint32_t flags,
chaviw273171b2018-12-26 11:46:30 -08003676 const sp<IBinder>& applyToken,
Marissa Wall17b4e452018-12-26 16:32:34 -08003677 const InputWindowCommands& inputWindowCommands,
Marissa Wall78b72202019-03-15 14:58:34 -07003678 int64_t desiredPresentTime,
Marissa Wall947d34e2019-03-29 14:03:53 -07003679 const client_cache_t& uncacheBuffer,
Marissa Wall3dad52d2019-03-22 14:03:19 -07003680 const std::vector<ListenerCallbacks>& listenerCallbacks) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003681 ATRACE_CALL();
Robert Carr14167e02019-02-13 13:50:55 -08003682
Valerie Haubc6ddb12019-03-08 11:10:15 -08003683 const int64_t postTime = systemTime();
3684
Robert Carr14167e02019-02-13 13:50:55 -08003685 bool privileged = callingThreadHasUnscopedSurfaceFlingerAccess();
3686
Mathias Agopian698c0872011-06-28 19:09:31 -07003687 Mutex::Autolock _l(mStateLock);
Mathias Agopiane57f2922012-08-09 16:29:12 -07003688
Marissa Wall713b63f2018-10-17 15:42:43 -07003689 // If its TransactionQueue already has a pending TransactionState or if it is pending
Valerie Hauf6016b62019-03-28 10:49:59 -07003690 auto itr = mTransactionQueues.find(applyToken);
3691 // if this is an animation frame, wait until prior animation frame has
3692 // been applied by SF
3693 if (flags & eAnimation) {
3694 while (itr != mTransactionQueues.end()) {
3695 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
3696 if (CC_UNLIKELY(err != NO_ERROR)) {
3697 ALOGW_IF(err == TIMED_OUT,
3698 "setTransactionState timed out "
3699 "waiting for animation frame to apply");
3700 break;
3701 }
3702 itr = mTransactionQueues.find(applyToken);
3703 }
3704 }
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003705
3706 // Expected present time is computed and cached on invalidate, so it may be stale.
3707 if (itr != mTransactionQueues.end() || !transactionIsReadyToBeApplied(
3708 desiredPresentTime, false /* useCachedExpectedPresentTime */, states)) {
Robert Carr14167e02019-02-13 13:50:55 -08003709 mTransactionQueues[applyToken].emplace(states, displays, flags, desiredPresentTime,
Marissa Wall3dad52d2019-03-22 14:03:19 -07003710 uncacheBuffer, listenerCallbacks, postTime,
3711 privileged);
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003712 setTransactionFlags(eTransactionFlushNeeded);
Marissa Wall713b63f2018-10-17 15:42:43 -07003713 return;
3714 }
3715
Valerie Haubc6ddb12019-03-08 11:10:15 -08003716 applyTransactionState(states, displays, flags, inputWindowCommands, desiredPresentTime,
Marissa Wall3dad52d2019-03-22 14:03:19 -07003717 uncacheBuffer, listenerCallbacks, postTime, privileged);
Marissa Wall713b63f2018-10-17 15:42:43 -07003718}
3719
3720void SurfaceFlinger::applyTransactionState(const Vector<ComposerState>& states,
chaviw273171b2018-12-26 11:46:30 -08003721 const Vector<DisplayState>& displays, uint32_t flags,
Robert Carr14167e02019-02-13 13:50:55 -08003722 const InputWindowCommands& inputWindowCommands,
Marissa Wall78b72202019-03-15 14:58:34 -07003723 const int64_t desiredPresentTime,
Marissa Wall947d34e2019-03-29 14:03:53 -07003724 const client_cache_t& uncacheBuffer,
Marissa Wall3dad52d2019-03-22 14:03:19 -07003725 const std::vector<ListenerCallbacks>& listenerCallbacks,
Marissa Wall78b72202019-03-15 14:58:34 -07003726 const int64_t postTime, bool privileged,
3727 bool isMainThread) {
Marissa Wall713b63f2018-10-17 15:42:43 -07003728 uint32_t transactionFlags = 0;
3729
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003730 if (flags & eAnimation) {
3731 // For window updates that are part of an animation we must wait for
3732 // previous animation "frames" to be handled.
Valerie Hau38448362019-04-11 14:49:33 -07003733 while (!isMainThread && mAnimTransactionPending) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003734 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003735 if (CC_UNLIKELY(err != NO_ERROR)) {
3736 // just in case something goes wrong in SF, return to the
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003737 // caller after a few seconds.
3738 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out "
3739 "waiting for previous animation frame");
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003740 mAnimTransactionPending = false;
3741 break;
3742 }
3743 }
3744 }
3745
chaviwca27f252018-02-06 16:46:39 -08003746 for (const DisplayState& display : displays) {
3747 transactionFlags |= setDisplayStateLocked(display);
Jamie Gennisb8d69a52011-10-10 15:48:06 -07003748 }
3749
Marissa Walld600d572019-03-26 15:38:50 -07003750 // In case the client has sent a Transaction that should receive callbacks but without any
3751 // SurfaceControls that should be included in the callback, send the listener and callbackIds
3752 // to the callback thread so it can send an empty callback
3753 if (!listenerCallbacks.empty()) {
3754 mTransactionCompletedThread.run();
3755 }
Marissa Wallefb71af2019-06-27 14:45:53 -07003756 for (const auto& listenerCallback : listenerCallbacks) {
3757 mTransactionCompletedThread.startRegistration(listenerCallback);
Marissa Walld600d572019-03-26 15:38:50 -07003758 }
3759
Marissa Walle2ffb422018-10-12 11:33:52 -07003760 uint32_t clientStateFlags = 0;
chaviwca27f252018-02-06 16:46:39 -08003761 for (const ComposerState& state : states) {
Marissa Wall3dad52d2019-03-22 14:03:19 -07003762 clientStateFlags |= setClientStateLocked(state, desiredPresentTime, listenerCallbacks,
3763 postTime, privileged);
3764 }
3765
Marissa Wallefb71af2019-06-27 14:45:53 -07003766 for (const auto& listenerCallback : listenerCallbacks) {
3767 mTransactionCompletedThread.endRegistration(listenerCallback);
3768 }
3769
Marissa Walle2ffb422018-10-12 11:33:52 -07003770 // If the state doesn't require a traversal and there are callbacks, send them now
Marissa Wallb0022cc2019-04-16 14:19:55 -07003771 if (!(clientStateFlags & eTraversalNeeded) && !listenerCallbacks.empty()) {
Marissa Walle2ffb422018-10-12 11:33:52 -07003772 mTransactionCompletedThread.sendCallbacks();
3773 }
3774 transactionFlags |= clientStateFlags;
chaviwca27f252018-02-06 16:46:39 -08003775
chaviw273171b2018-12-26 11:46:30 -08003776 transactionFlags |= addInputWindowCommands(inputWindowCommands);
3777
Marissa Wall947d34e2019-03-29 14:03:53 -07003778 if (uncacheBuffer.isValid()) {
3779 ClientCache::getInstance().erase(uncacheBuffer);
Marissa Wall78b72202019-03-15 14:58:34 -07003780 }
3781
Jorim Jaggibdcf09c2017-08-08 15:22:08 +02003782 // If a synchronous transaction is explicitly requested without any changes, force a transaction
3783 // anyway. This can be used as a flush mechanism for previous async transactions.
3784 // Empty animation transaction can be used to simulate back-pressure, so also force a
3785 // transaction for empty animation transactions.
3786 if (transactionFlags == 0 &&
3787 ((flags & eSynchronous) || (flags & eAnimation))) {
Robert Carr2a7dbb42016-05-24 11:41:28 -07003788 transactionFlags = eTransactionNeeded;
3789 }
3790
Marissa Wall06255332019-03-27 13:48:27 -07003791 // If we are on the main thread, we are about to preform a traversal. Clear the traversal bit
3792 // so we don't have to wake up again next frame to preform an uneeded traversal.
3793 if (isMainThread && (transactionFlags & eTraversalNeeded)) {
3794 transactionFlags = transactionFlags & (~eTraversalNeeded);
3795 mTraversalNeededMainThread = true;
3796 }
3797
Mathias Agopian386aa982011-11-07 21:58:03 -08003798 if (transactionFlags) {
Lloyd Pique4dccc412018-01-22 17:21:36 -08003799 if (mInterceptor->isEnabled()) {
3800 mInterceptor->saveTransaction(states, mCurrentState.displays, displays, flags);
Irvelffc9efc2016-07-27 15:16:37 -07003801 }
Irvel468051e2016-06-13 16:44:44 -07003802
Mathias Agopian386aa982011-11-07 21:58:03 -08003803 // this triggers the transaction
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003804 const auto start = (flags & eEarlyWakeup) ? Scheduler::TransactionStart::EARLY
3805 : Scheduler::TransactionStart::NORMAL;
Dan Stoza84d619e2018-03-28 17:07:36 -07003806 setTransactionFlags(transactionFlags, start);
Mathias Agopian386aa982011-11-07 21:58:03 -08003807
3808 // if this is a synchronous transaction, wait for it to take effect
3809 // before returning.
3810 if (flags & eSynchronous) {
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003811 mTransactionPending = true;
Mathias Agopian386aa982011-11-07 21:58:03 -08003812 }
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003813 if (flags & eAnimation) {
3814 mAnimTransactionPending = true;
3815 }
chaviw4fe36852019-04-15 16:25:49 -07003816 if (mPendingInputWindowCommands.syncInputWindows) {
3817 mPendingSyncInputWindows = true;
3818 }
Valerie Hau0779ded2019-03-19 12:43:04 -07003819
3820 // applyTransactionState can be called by either the main SF thread or by
3821 // another process through setTransactionState. While a given process may wish
3822 // to wait on synchronous transactions, the main SF thread should never
3823 // be blocked. Therefore, we only wait if isMainThread is false.
3824 while (!isMainThread && (mTransactionPending || mPendingSyncInputWindows)) {
Mathias Agopian386aa982011-11-07 21:58:03 -08003825 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
3826 if (CC_UNLIKELY(err != NO_ERROR)) {
3827 // just in case something goes wrong in SF, return to the
3828 // called after a few seconds.
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003829 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");
3830 mTransactionPending = false;
chaviw95ef3c42019-02-14 10:55:09 -08003831 mPendingSyncInputWindows = false;
Mathias Agopian386aa982011-11-07 21:58:03 -08003832 break;
3833 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -07003834 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003835 }
3836}
3837
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003838uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s) {
3839 const ssize_t index = mCurrentState.displays.indexOfKey(s.token);
3840 if (index < 0) return 0;
Jesse Hall9a143922012-10-04 16:29:19 -07003841
Mathias Agopiane57f2922012-08-09 16:29:12 -07003842 uint32_t flags = 0;
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003843 DisplayDeviceState& state = mCurrentState.displays.editValueAt(index);
3844
3845 const uint32_t what = s.what;
3846 if (what & DisplayState::eSurfaceChanged) {
3847 if (IInterface::asBinder(state.surface) != IInterface::asBinder(s.surface)) {
3848 state.surface = s.surface;
3849 flags |= eDisplayTransactionNeeded;
Michael Lentine47e45402014-07-18 15:34:25 -07003850 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07003851 }
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003852 if (what & DisplayState::eLayerStackChanged) {
3853 if (state.layerStack != s.layerStack) {
3854 state.layerStack = s.layerStack;
3855 flags |= eDisplayTransactionNeeded;
3856 }
3857 }
3858 if (what & DisplayState::eDisplayProjectionChanged) {
3859 if (state.orientation != s.orientation) {
3860 state.orientation = s.orientation;
3861 flags |= eDisplayTransactionNeeded;
3862 }
3863 if (state.frame != s.frame) {
3864 state.frame = s.frame;
3865 flags |= eDisplayTransactionNeeded;
3866 }
3867 if (state.viewport != s.viewport) {
3868 state.viewport = s.viewport;
3869 flags |= eDisplayTransactionNeeded;
3870 }
3871 }
3872 if (what & DisplayState::eDisplaySizeChanged) {
3873 if (state.width != s.width) {
3874 state.width = s.width;
3875 flags |= eDisplayTransactionNeeded;
3876 }
3877 if (state.height != s.height) {
3878 state.height = s.height;
3879 flags |= eDisplayTransactionNeeded;
3880 }
3881 }
3882
Mathias Agopiane57f2922012-08-09 16:29:12 -07003883 return flags;
3884}
3885
Robert Carr14167e02019-02-13 13:50:55 -08003886bool SurfaceFlinger::callingThreadHasUnscopedSurfaceFlingerAccess() {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003887 IPCThreadState* ipc = IPCThreadState::self();
3888 const int pid = ipc->getCallingPid();
3889 const int uid = ipc->getCallingUid();
Robert Carrd4ae7f32018-06-07 16:10:57 -07003890 if ((uid != AID_GRAPHICS && uid != AID_SYSTEM) &&
Ana Krulec13be8ad2018-08-21 02:43:56 +00003891 !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003892 return false;
3893 }
3894 return true;
3895}
3896
Marissa Wall3dad52d2019-03-22 14:03:19 -07003897uint32_t SurfaceFlinger::setClientStateLocked(
3898 const ComposerState& composerState, int64_t desiredPresentTime,
3899 const std::vector<ListenerCallbacks>& listenerCallbacks, int64_t postTime,
3900 bool privileged) {
chaviwca27f252018-02-06 16:46:39 -08003901 const layer_state_t& s = composerState.state;
chaviwca27f252018-02-06 16:46:39 -08003902
Vishnu Nairf03652d2019-07-16 17:56:56 -07003903 sp<Layer> layer(fromHandle(s.surface));
chaviw8b3871a2017-11-01 17:41:01 -07003904 if (layer == nullptr) {
Marissa Wall88e20482019-06-24 10:49:42 -07003905 for (auto& listenerCallback : listenerCallbacks) {
Marissa Wallefb71af2019-06-27 14:45:53 -07003906 mTransactionCompletedThread.registerUnpresentedCallbackHandle(
Marissa Wall88e20482019-06-24 10:49:42 -07003907 new CallbackHandle(listenerCallback.transactionCompletedListener,
3908 listenerCallback.callbackIds, s.surface));
3909 }
chaviw8b3871a2017-11-01 17:41:01 -07003910 return 0;
3911 }
3912
chaviw8b3871a2017-11-01 17:41:01 -07003913 uint32_t flags = 0;
3914
Garfield Tan8a3083e2018-12-03 13:21:07 -08003915 const uint64_t what = s.what;
chaviw8b3871a2017-11-01 17:41:01 -07003916 bool geometryAppliesWithResize =
3917 what & layer_state_t::eGeometryAppliesWithResize;
Jorim Jaggidba32732018-05-28 17:43:52 +02003918
3919 // If we are deferring transaction, make sure to push the pending state, as otherwise the
3920 // pending state will also be deferred.
Marissa Wallf58c14b2018-07-24 10:50:43 -07003921 if (what & layer_state_t::eDeferTransaction_legacy) {
Jorim Jaggidba32732018-05-28 17:43:52 +02003922 layer->pushPendingState();
3923 }
3924
chaviw8b3871a2017-11-01 17:41:01 -07003925 if (what & layer_state_t::ePositionChanged) {
3926 if (layer->setPosition(s.x, s.y, !geometryAppliesWithResize)) {
3927 flags |= eTraversalNeeded;
Mathias Agopiane57f2922012-08-09 16:29:12 -07003928 }
chaviw8b3871a2017-11-01 17:41:01 -07003929 }
3930 if (what & layer_state_t::eLayerChanged) {
3931 // NOTE: index needs to be calculated before we update the state
3932 const auto& p = layer->getParent();
3933 if (p == nullptr) {
chaviw64f7b422017-07-12 10:31:58 -07003934 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
chaviw8b3871a2017-11-01 17:41:01 -07003935 if (layer->setLayer(s.z) && idx >= 0) {
Mathias Agopiane57f2922012-08-09 16:29:12 -07003936 mCurrentState.layersSortedByZ.removeAt(idx);
3937 mCurrentState.layersSortedByZ.add(layer);
3938 // we need traversal (state changed)
3939 // AND transaction (list changed)
3940 flags |= eTransactionNeeded|eTraversalNeeded;
3941 }
chaviw8b3871a2017-11-01 17:41:01 -07003942 } else {
3943 if (p->setChildLayer(layer, s.z)) {
chaviw06178942017-07-27 10:25:59 -07003944 flags |= eTransactionNeeded|eTraversalNeeded;
3945 }
3946 }
chaviw8b3871a2017-11-01 17:41:01 -07003947 }
3948 if (what & layer_state_t::eRelativeLayerChanged) {
Robert Carr503c7042017-09-27 15:06:08 -07003949 // NOTE: index needs to be calculated before we update the state
3950 const auto& p = layer->getParent();
3951 if (p == nullptr) {
3952 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
3953 if (layer->setRelativeLayer(s.relativeLayerHandle, s.z) && idx >= 0) {
3954 mCurrentState.layersSortedByZ.removeAt(idx);
3955 mCurrentState.layersSortedByZ.add(layer);
3956 // we need traversal (state changed)
3957 // AND transaction (list changed)
3958 flags |= eTransactionNeeded|eTraversalNeeded;
3959 }
3960 } else {
3961 if (p->setChildRelativeLayer(layer, s.relativeLayerHandle, s.z)) {
3962 flags |= eTransactionNeeded|eTraversalNeeded;
3963 }
chaviw8b3871a2017-11-01 17:41:01 -07003964 }
3965 }
3966 if (what & layer_state_t::eSizeChanged) {
3967 if (layer->setSize(s.w, s.h)) {
3968 flags |= eTraversalNeeded;
3969 }
3970 }
3971 if (what & layer_state_t::eAlphaChanged) {
3972 if (layer->setAlpha(s.alpha))
3973 flags |= eTraversalNeeded;
3974 }
3975 if (what & layer_state_t::eColorChanged) {
3976 if (layer->setColor(s.color))
3977 flags |= eTraversalNeeded;
3978 }
Peiyong Lind3788632018-09-18 16:01:31 -07003979 if (what & layer_state_t::eColorTransformChanged) {
3980 if (layer->setColorTransform(s.colorTransform)) {
3981 flags |= eTraversalNeeded;
3982 }
3983 }
Valerie Haudd0b7572019-01-29 14:59:27 -08003984 if (what & layer_state_t::eBackgroundColorChanged) {
3985 if (layer->setBackgroundColor(s.color, s.bgColorAlpha, s.bgColorDataspace)) {
3986 flags |= eTraversalNeeded;
3987 }
3988 }
chaviw8b3871a2017-11-01 17:41:01 -07003989 if (what & layer_state_t::eMatrixChanged) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003990 // TODO: b/109894387
3991 //
3992 // SurfaceFlinger's renderer is not prepared to handle cropping in the face of arbitrary
3993 // rotation. To see the problem observe that if we have a square parent, and a child
3994 // of the same size, then we rotate the child 45 degrees around it's center, the child
3995 // must now be cropped to a non rectangular 8 sided region.
3996 //
3997 // Of course we can fix this in the future. For now, we are lucky, SurfaceControl is
3998 // private API, and the WindowManager only uses rotation in one case, which is on a top
3999 // level layer in which cropping is not an issue.
4000 //
4001 // However given that abuse of rotation matrices could lead to surfaces extending outside
4002 // of cropped areas, we need to prevent non-root clients without permission ACCESS_SURFACE_FLINGER
4003 // (a.k.a. everyone except WindowManager and tests) from setting non rectangle preserving
4004 // transformations.
Robert Carr14167e02019-02-13 13:50:55 -08004005 if (layer->setMatrix(s.matrix, privileged))
chaviw8b3871a2017-11-01 17:41:01 -07004006 flags |= eTraversalNeeded;
4007 }
4008 if (what & layer_state_t::eTransparentRegionChanged) {
4009 if (layer->setTransparentRegionHint(s.transparentRegion))
4010 flags |= eTraversalNeeded;
4011 }
4012 if (what & layer_state_t::eFlagsChanged) {
4013 if (layer->setFlags(s.flags, s.mask))
4014 flags |= eTraversalNeeded;
4015 }
Marissa Wallf58c14b2018-07-24 10:50:43 -07004016 if (what & layer_state_t::eCropChanged_legacy) {
4017 if (layer->setCrop_legacy(s.crop_legacy, !geometryAppliesWithResize))
chaviw8b3871a2017-11-01 17:41:01 -07004018 flags |= eTraversalNeeded;
4019 }
Lucas Dupin1b6531c2018-07-05 17:18:21 -07004020 if (what & layer_state_t::eCornerRadiusChanged) {
4021 if (layer->setCornerRadius(s.cornerRadius))
4022 flags |= eTraversalNeeded;
4023 }
chaviw8b3871a2017-11-01 17:41:01 -07004024 if (what & layer_state_t::eLayerStackChanged) {
4025 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
4026 // We only allow setting layer stacks for top level layers,
4027 // everything else inherits layer stack from its parent.
4028 if (layer->hasParent()) {
4029 ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
4030 layer->getName().string());
4031 } else if (idx < 0) {
4032 ALOGE("Attempt to set layer stack on layer without parent (%s) that "
4033 "that also does not appear in the top level layer list. Something"
4034 " has gone wrong.", layer->getName().string());
4035 } else if (layer->setLayerStack(s.layerStack)) {
4036 mCurrentState.layersSortedByZ.removeAt(idx);
4037 mCurrentState.layersSortedByZ.add(layer);
4038 // we need traversal (state changed)
4039 // AND transaction (list changed)
Lloyd Piqued432a7c2018-03-23 16:05:31 -07004040 flags |= eTransactionNeeded|eTraversalNeeded|eDisplayLayerStackChanged;
chaviw8b3871a2017-11-01 17:41:01 -07004041 }
4042 }
Marissa Wallf58c14b2018-07-24 10:50:43 -07004043 if (what & layer_state_t::eDeferTransaction_legacy) {
4044 if (s.barrierHandle_legacy != nullptr) {
4045 layer->deferTransactionUntil_legacy(s.barrierHandle_legacy, s.frameNumber_legacy);
4046 } else if (s.barrierGbp_legacy != nullptr) {
4047 const sp<IGraphicBufferProducer>& gbp = s.barrierGbp_legacy;
chaviw8b3871a2017-11-01 17:41:01 -07004048 if (authenticateSurfaceTextureLocked(gbp)) {
4049 const auto& otherLayer =
4050 (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
Marissa Wallf58c14b2018-07-24 10:50:43 -07004051 layer->deferTransactionUntil_legacy(otherLayer, s.frameNumber_legacy);
chaviw8b3871a2017-11-01 17:41:01 -07004052 } else {
4053 ALOGE("Attempt to defer transaction to to an"
4054 " unrecognized GraphicBufferProducer");
Robert Carr1db73f62016-12-21 12:58:51 -08004055 }
4056 }
chaviw8b3871a2017-11-01 17:41:01 -07004057 // We don't trigger a traversal here because if no other state is
4058 // changed, we don't want this to cause any more work
4059 }
4060 if (what & layer_state_t::eReparent) {
chaviw8ea97bb2017-11-29 10:05:15 -08004061 bool hadParent = layer->hasParent();
chaviw8b3871a2017-11-01 17:41:01 -07004062 if (layer->reparent(s.parentHandleForChild)) {
chaviw8ea97bb2017-11-29 10:05:15 -08004063 if (!hadParent) {
4064 mCurrentState.layersSortedByZ.remove(layer);
4065 }
chaviw8b3871a2017-11-01 17:41:01 -07004066 flags |= eTransactionNeeded|eTraversalNeeded;
Robert Carr9524cb32017-02-13 11:32:32 -08004067 }
chaviw8b3871a2017-11-01 17:41:01 -07004068 }
4069 if (what & layer_state_t::eReparentChildren) {
4070 if (layer->reparentChildren(s.reparentHandle)) {
4071 flags |= eTransactionNeeded|eTraversalNeeded;
Robert Carrc3574f72016-03-24 12:19:32 -07004072 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07004073 }
chaviw8b3871a2017-11-01 17:41:01 -07004074 if (what & layer_state_t::eDetachChildren) {
4075 layer->detachChildren();
4076 }
4077 if (what & layer_state_t::eOverrideScalingModeChanged) {
4078 layer->setOverrideScalingMode(s.overrideScalingMode);
4079 // We don't trigger a traversal here because if no other state is
4080 // changed, we don't want this to cause any more work
4081 }
Marissa Wall61c58622018-07-18 10:12:20 -07004082 if (what & layer_state_t::eTransformChanged) {
4083 if (layer->setTransform(s.transform)) flags |= eTraversalNeeded;
4084 }
4085 if (what & layer_state_t::eTransformToDisplayInverseChanged) {
4086 if (layer->setTransformToDisplayInverse(s.transformToDisplayInverse))
4087 flags |= eTraversalNeeded;
4088 }
4089 if (what & layer_state_t::eCropChanged) {
4090 if (layer->setCrop(s.crop)) flags |= eTraversalNeeded;
4091 }
Marissa Wall861616d2018-10-22 12:52:23 -07004092 if (what & layer_state_t::eFrameChanged) {
4093 if (layer->setFrame(s.frame)) flags |= eTraversalNeeded;
4094 }
Marissa Wall61c58622018-07-18 10:12:20 -07004095 if (what & layer_state_t::eAcquireFenceChanged) {
4096 if (layer->setAcquireFence(s.acquireFence)) flags |= eTraversalNeeded;
4097 }
4098 if (what & layer_state_t::eDataspaceChanged) {
4099 if (layer->setDataspace(s.dataspace)) flags |= eTraversalNeeded;
4100 }
4101 if (what & layer_state_t::eHdrMetadataChanged) {
4102 if (layer->setHdrMetadata(s.hdrMetadata)) flags |= eTraversalNeeded;
4103 }
4104 if (what & layer_state_t::eSurfaceDamageRegionChanged) {
4105 if (layer->setSurfaceDamageRegion(s.surfaceDamageRegion)) flags |= eTraversalNeeded;
4106 }
4107 if (what & layer_state_t::eApiChanged) {
4108 if (layer->setApi(s.api)) flags |= eTraversalNeeded;
4109 }
4110 if (what & layer_state_t::eSidebandStreamChanged) {
4111 if (layer->setSidebandStream(s.sidebandStream)) flags |= eTraversalNeeded;
4112 }
Robert Carr720e5062018-07-30 17:45:14 -07004113 if (what & layer_state_t::eInputInfoChanged) {
Vishnu Nairce5d0cc2019-02-28 14:38:41 -08004114 if (privileged) {
Robert Carr11ac2012019-01-22 09:05:25 -08004115 layer->setInputInfo(s.inputInfo);
4116 flags |= eTraversalNeeded;
4117 } else {
4118 ALOGE("Attempt to update InputWindowInfo without permission ACCESS_SURFACE_FLINGER");
4119 }
Robert Carr720e5062018-07-30 17:45:14 -07004120 }
Evan Rosky1f6d6d52018-12-06 10:47:26 -08004121 if (what & layer_state_t::eMetadataChanged) {
4122 if (layer->setMetadata(s.metadata)) flags |= eTraversalNeeded;
4123 }
Peiyong Linc502cb72019-03-01 15:00:23 -08004124 if (what & layer_state_t::eColorSpaceAgnosticChanged) {
4125 if (layer->setColorSpaceAgnostic(s.colorSpaceAgnostic)) {
4126 flags |= eTraversalNeeded;
4127 }
4128 }
Marissa Walle2ffb422018-10-12 11:33:52 -07004129 std::vector<sp<CallbackHandle>> callbackHandles;
Marissa Wall3dad52d2019-03-22 14:03:19 -07004130 if ((what & layer_state_t::eHasListenerCallbacksChanged) && (!listenerCallbacks.empty())) {
Marissa Wall3dad52d2019-03-22 14:03:19 -07004131 for (const auto& [listener, callbackIds] : listenerCallbacks) {
Marissa Walle2ffb422018-10-12 11:33:52 -07004132 callbackHandles.emplace_back(new CallbackHandle(listener, callbackIds, s.surface));
4133 }
4134 }
Marissa Wall78b72202019-03-15 14:58:34 -07004135 bool bufferChanged = what & layer_state_t::eBufferChanged;
4136 bool cacheIdChanged = what & layer_state_t::eCachedBufferChanged;
4137 sp<GraphicBuffer> buffer;
4138 if (bufferChanged && cacheIdChanged) {
Marissa Wall947d34e2019-03-29 14:03:53 -07004139 ClientCache::getInstance().add(s.cachedBuffer, s.buffer);
Alec Mouri1c8d7202019-06-01 18:51:35 -07004140 ClientCache::getInstance().registerErasedRecipient(s.cachedBuffer,
4141 wp<ClientCache::ErasedRecipient>(layer));
4142 getRenderEngine().cacheExternalTextureBuffer(s.buffer);
Marissa Wall78b72202019-03-15 14:58:34 -07004143 buffer = s.buffer;
4144 } else if (cacheIdChanged) {
Marissa Wall947d34e2019-03-29 14:03:53 -07004145 buffer = ClientCache::getInstance().get(s.cachedBuffer);
Marissa Wall78b72202019-03-15 14:58:34 -07004146 } else if (bufferChanged) {
4147 buffer = s.buffer;
Marissa Wall73411622019-01-25 10:45:41 -08004148 }
Marissa Wall78b72202019-03-15 14:58:34 -07004149 if (buffer) {
Marissa Wall947d34e2019-03-29 14:03:53 -07004150 if (layer->setBuffer(buffer, postTime, desiredPresentTime, s.cachedBuffer)) {
Valerie Haubc6ddb12019-03-08 11:10:15 -08004151 flags |= eTraversalNeeded;
Valerie Haubc6ddb12019-03-08 11:10:15 -08004152 }
Marissa Wallebc2c052019-01-16 19:16:55 -08004153 }
Marissa Walle2ffb422018-10-12 11:33:52 -07004154 if (layer->setTransactionCompletedListeners(callbackHandles)) flags |= eTraversalNeeded;
4155 // Do not put anything that updates layer state or modifies flags after
4156 // setTransactionCompletedListener
Mathias Agopiane57f2922012-08-09 16:29:12 -07004157 return flags;
4158}
4159
chaviw273171b2018-12-26 11:46:30 -08004160uint32_t SurfaceFlinger::addInputWindowCommands(const InputWindowCommands& inputWindowCommands) {
4161 uint32_t flags = 0;
4162 if (!inputWindowCommands.transferTouchFocusCommands.empty()) {
4163 flags |= eTraversalNeeded;
4164 }
4165
chaviwa911b102019-02-14 10:18:33 -08004166 if (inputWindowCommands.syncInputWindows) {
4167 flags |= eTraversalNeeded;
4168 }
4169
Vishnu Nairec0ab382019-02-13 15:32:56 -08004170 mPendingInputWindowCommands.merge(inputWindowCommands);
chaviw273171b2018-12-26 11:46:30 -08004171 return flags;
4172}
4173
Marissa Wall2d814fb2019-04-09 18:52:57 +00004174status_t SurfaceFlinger::createLayer(const String8& name, const sp<Client>& client, uint32_t w,
4175 uint32_t h, PixelFormat format, uint32_t flags,
4176 LayerMetadata metadata, sp<IBinder>* handle,
Robert Carrc0df3122019-04-11 13:18:21 -07004177 sp<IGraphicBufferProducer>* gbp,
4178 const sp<IBinder>& parentHandle,
4179 const sp<Layer>& parentLayer) {
Mathias Agopian6e2d6482009-07-09 18:16:43 -07004180 if (int32_t(w|h) < 0) {
Mathias Agopian921e6ac2012-07-23 23:11:29 -07004181 ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
Mathias Agopian6e2d6482009-07-09 18:16:43 -07004182 int(w), int(h));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004183 return BAD_VALUE;
Mathias Agopian6e2d6482009-07-09 18:16:43 -07004184 }
Andreas Huber8b42e8a2010-08-16 08:49:37 -07004185
Robert Carrc0df3122019-04-11 13:18:21 -07004186 ALOG_ASSERT(parentLayer == nullptr || parentHandle == nullptr,
4187 "Expected only one of parentLayer or parentHandle to be non-null. "
4188 "Programmer error?");
4189
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004190 status_t result = NO_ERROR;
4191
4192 sp<Layer> layer;
4193
Cody Northropbc755282017-03-31 12:00:08 -06004194 String8 uniqueName = getUniqueLayerName(name);
4195
Evan Roskya1f1e152019-01-24 16:17:46 -08004196 bool primaryDisplayOnly = false;
4197
4198 // window type is WINDOW_TYPE_DONT_SCREENSHOT from SurfaceControl.java
4199 // TODO b/64227542
4200 if (metadata.has(METADATA_WINDOW_TYPE)) {
4201 int32_t windowType = metadata.getInt32(METADATA_WINDOW_TYPE, 0);
4202 if (windowType == 441731) {
Ady Abraham8f1ee7f2019-04-05 10:32:50 -07004203 metadata.setInt32(METADATA_WINDOW_TYPE, InputWindowInfo::TYPE_NAVIGATION_BAR_PANEL);
Evan Roskya1f1e152019-01-24 16:17:46 -08004204 primaryDisplayOnly = true;
4205 }
4206 }
4207
Mathias Agopian3165cc22012-08-08 19:42:09 -07004208 switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
Marissa Wall61c58622018-07-18 10:12:20 -07004209 case ISurfaceComposerClient::eFXSurfaceBufferQueue:
Evan Roskya1f1e152019-01-24 16:17:46 -08004210 result = createBufferQueueLayer(client, uniqueName, w, h, flags, std::move(metadata),
4211 format, handle, gbp, &layer);
David Sodman0c69cad2017-08-21 12:12:51 -07004212
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004213 break;
Marissa Wall61c58622018-07-18 10:12:20 -07004214 case ISurfaceComposerClient::eFXSurfaceBufferState:
Evan Roskya1f1e152019-01-24 16:17:46 -08004215 result = createBufferStateLayer(client, uniqueName, w, h, flags, std::move(metadata),
4216 handle, &layer);
Marissa Wall61c58622018-07-18 10:12:20 -07004217 break;
chaviw13fdc492017-06-27 12:40:18 -07004218 case ISurfaceComposerClient::eFXSurfaceColor:
Vishnu Nair88a11f22018-11-28 18:30:57 -08004219 // check if buffer size is set for color layer.
4220 if (w > 0 || h > 0) {
4221 ALOGE("createLayer() failed, w or h cannot be set for color layer (w=%d, h=%d)",
4222 int(w), int(h));
4223 return BAD_VALUE;
4224 }
4225
Evan Roskya1f1e152019-01-24 16:17:46 -08004226 result = createColorLayer(client, uniqueName, w, h, flags, std::move(metadata), handle,
4227 &layer);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004228 break;
Robert Carr6b3f6c52018-08-13 13:05:17 -07004229 case ISurfaceComposerClient::eFXSurfaceContainer:
Vishnu Nair88a11f22018-11-28 18:30:57 -08004230 // check if buffer size is set for container layer.
4231 if (w > 0 || h > 0) {
4232 ALOGE("createLayer() failed, w or h cannot be set for container layer (w=%d, h=%d)",
4233 int(w), int(h));
4234 return BAD_VALUE;
4235 }
Evan Roskya1f1e152019-01-24 16:17:46 -08004236 result = createContainerLayer(client, uniqueName, w, h, flags, std::move(metadata),
4237 handle, &layer);
Robert Carr6b3f6c52018-08-13 13:05:17 -07004238 break;
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004239 default:
4240 result = BAD_VALUE;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004241 break;
4242 }
4243
Dan Stoza7d89d062015-04-30 13:29:25 -07004244 if (result != NO_ERROR) {
4245 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004246 }
Dan Stoza7d89d062015-04-30 13:29:25 -07004247
Evan Roskya1f1e152019-01-24 16:17:46 -08004248 if (primaryDisplayOnly) {
4249 layer->setPrimaryDisplayOnly();
Chia-I Wuab0c3192017-08-01 11:29:00 -07004250 }
4251
Robert Carrb89ea9d2018-12-10 13:01:14 -08004252 bool addToCurrentState = callingThreadHasUnscopedSurfaceFlingerAccess();
Robert Carrc0df3122019-04-11 13:18:21 -07004253 result = addClientLayer(client, *handle, *gbp, layer, parentHandle, parentLayer,
4254 addToCurrentState);
Dan Stoza7d89d062015-04-30 13:29:25 -07004255 if (result != NO_ERROR) {
4256 return result;
4257 }
Lloyd Pique4dccc412018-01-22 17:21:36 -08004258 mInterceptor->saveSurfaceCreation(layer);
Dan Stoza7d89d062015-04-30 13:29:25 -07004259
4260 setTransactionFlags(eTransactionNeeded);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004261 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004262}
4263
Cody Northropbc755282017-03-31 12:00:08 -06004264String8 SurfaceFlinger::getUniqueLayerName(const String8& name)
4265{
4266 bool matchFound = true;
4267 uint32_t dupeCounter = 0;
4268
4269 // Tack on our counter whether there is a hit or not, so everyone gets a tag
4270 String8 uniqueName = name + "#" + String8(std::to_string(dupeCounter).c_str());
4271
Dan Stoza436ccf32018-06-21 12:10:12 -07004272 // Grab the state lock since we're accessing mCurrentState
4273 Mutex::Autolock lock(mStateLock);
4274
Cody Northropbc755282017-03-31 12:00:08 -06004275 // Loop over layers until we're sure there is no matching name
4276 while (matchFound) {
4277 matchFound = false;
Dan Stoza436ccf32018-06-21 12:10:12 -07004278 mCurrentState.traverseInZOrder([&](Layer* layer) {
Cody Northropbc755282017-03-31 12:00:08 -06004279 if (layer->getName() == uniqueName) {
4280 matchFound = true;
4281 uniqueName = name + "#" + String8(std::to_string(++dupeCounter).c_str());
4282 }
4283 });
4284 }
4285
Marissa Wallf1de4bd2018-05-22 13:05:01 -07004286 ALOGV_IF(dupeCounter > 0, "duplicate layer name: changing %s to %s", name.c_str(),
4287 uniqueName.c_str());
Cody Northropbc755282017-03-31 12:00:08 -06004288
4289 return uniqueName;
4290}
4291
Marissa Wallfd668622018-05-10 10:21:13 -07004292status_t SurfaceFlinger::createBufferQueueLayer(const sp<Client>& client, const String8& name,
4293 uint32_t w, uint32_t h, uint32_t flags,
Evan Roskya1f1e152019-01-24 16:17:46 -08004294 LayerMetadata metadata, PixelFormat& format,
4295 sp<IBinder>* handle,
Marissa Wallfd668622018-05-10 10:21:13 -07004296 sp<IGraphicBufferProducer>* gbp,
4297 sp<Layer>* outLayer) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004298 // initialize the surfaces
Mathias Agopian92a979a2012-08-02 18:32:23 -07004299 switch (format) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004300 case PIXEL_FORMAT_TRANSPARENT:
4301 case PIXEL_FORMAT_TRANSLUCENT:
4302 format = PIXEL_FORMAT_RGBA_8888;
4303 break;
4304 case PIXEL_FORMAT_OPAQUE:
Mathias Agopian8f105402010-04-05 18:01:24 -07004305 format = PIXEL_FORMAT_RGBX_8888;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004306 break;
4307 }
4308
Evan Roskya1f1e152019-01-24 16:17:46 -08004309 sp<BufferQueueLayer> layer = getFactory().createBufferQueueLayer(
4310 LayerCreationArgs(this, client, name, w, h, flags, std::move(metadata)));
Marissa Wallfd668622018-05-10 10:21:13 -07004311 status_t err = layer->setDefaultBufferProperties(w, h, format);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004312 if (err == NO_ERROR) {
David Sodman0c69cad2017-08-21 12:12:51 -07004313 *handle = layer->getHandle();
4314 *gbp = layer->getProducer();
4315 *outLayer = layer;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004316 }
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004317
Marissa Wallfd668622018-05-10 10:21:13 -07004318 ALOGE_IF(err, "createBufferQueueLayer() failed (%s)", strerror(-err));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004319 return err;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004320}
4321
Marissa Wall61c58622018-07-18 10:12:20 -07004322status_t SurfaceFlinger::createBufferStateLayer(const sp<Client>& client, const String8& name,
4323 uint32_t w, uint32_t h, uint32_t flags,
Evan Roskya1f1e152019-01-24 16:17:46 -08004324 LayerMetadata metadata, sp<IBinder>* handle,
4325 sp<Layer>* outLayer) {
4326 sp<BufferStateLayer> layer = getFactory().createBufferStateLayer(
4327 LayerCreationArgs(this, client, name, w, h, flags, std::move(metadata)));
Marissa Wall61c58622018-07-18 10:12:20 -07004328 *handle = layer->getHandle();
4329 *outLayer = layer;
4330
4331 return NO_ERROR;
4332}
4333
Evan Roskya1f1e152019-01-24 16:17:46 -08004334status_t SurfaceFlinger::createColorLayer(const sp<Client>& client, const String8& name, uint32_t w,
4335 uint32_t h, uint32_t flags, LayerMetadata metadata,
4336 sp<IBinder>* handle, sp<Layer>* outLayer) {
4337 *outLayer = getFactory().createColorLayer(
4338 LayerCreationArgs(this, client, name, w, h, flags, std::move(metadata)));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004339 *handle = (*outLayer)->getHandle();
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004340 return NO_ERROR;
Mathias Agopian118d0242011-10-13 16:02:48 -07004341}
4342
Evan Roskya1f1e152019-01-24 16:17:46 -08004343status_t SurfaceFlinger::createContainerLayer(const sp<Client>& client, const String8& name,
4344 uint32_t w, uint32_t h, uint32_t flags,
4345 LayerMetadata metadata, sp<IBinder>* handle,
4346 sp<Layer>* outLayer) {
4347 *outLayer = getFactory().createContainerLayer(
4348 LayerCreationArgs(this, client, name, w, h, flags, std::move(metadata)));
Robert Carr6b3f6c52018-08-13 13:05:17 -07004349 *handle = (*outLayer)->getHandle();
4350 return NO_ERROR;
4351}
4352
4353
Robert Carr6fb1a7e2018-12-11 12:07:25 -08004354void SurfaceFlinger::markLayerPendingRemovalLocked(const sp<Layer>& layer) {
Robert Carr2e102c92018-10-23 12:11:15 -07004355 mLayersPendingRemoval.add(layer);
4356 mLayersRemoved = true;
4357 setTransactionFlags(eTransactionNeeded);
4358}
4359
Robert Carr695d5282018-12-18 15:27:58 -08004360void SurfaceFlinger::onHandleDestroyed(sp<Layer>& layer)
Rob Carr4bba3702018-10-08 21:53:30 +00004361{
Robert Carr2e102c92018-10-23 12:11:15 -07004362 Mutex::Autolock lock(mStateLock);
Robert Carr6fb1a7e2018-12-11 12:07:25 -08004363 // If a layer has a parent, we allow it to out-live it's handle
4364 // with the idea that the parent holds a reference and will eventually
4365 // be cleaned up. However no one cleans up the top-level so we do so
4366 // here.
4367 if (layer->getParent() == nullptr) {
4368 mCurrentState.layersSortedByZ.remove(layer);
4369 }
4370 markLayerPendingRemovalLocked(layer);
Robert Carrc0df3122019-04-11 13:18:21 -07004371
4372 auto it = mLayersByLocalBinderToken.begin();
4373 while (it != mLayersByLocalBinderToken.end()) {
4374 if (it->second == layer) {
4375 it = mLayersByLocalBinderToken.erase(it);
4376 } else {
4377 it++;
4378 }
4379 }
4380
Robert Carr695d5282018-12-18 15:27:58 -08004381 layer.clear();
Rob Carr4bba3702018-10-08 21:53:30 +00004382}
4383
Mathias Agopianb60314a2012-04-10 22:09:54 -07004384// ---------------------------------------------------------------------------
4385
Andy McFadden13a082e2012-08-24 10:16:42 -07004386void SurfaceFlinger::onInitializeDisplays() {
Dominik Laskowski83b88212018-12-11 13:34:06 -08004387 const auto display = getDefaultDisplayDeviceLocked();
4388 if (!display) return;
4389
4390 const sp<IBinder> token = display->getDisplayToken().promote();
4391 LOG_ALWAYS_FATAL_IF(token == nullptr);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004392
Jesse Hall01e29052013-02-19 16:13:35 -08004393 // reset screen orientation and use primary layer stack
Andy McFadden13a082e2012-08-24 10:16:42 -07004394 Vector<ComposerState> state;
4395 Vector<DisplayState> displays;
4396 DisplayState d;
Jesse Hall01e29052013-02-19 16:13:35 -08004397 d.what = DisplayState::eDisplayProjectionChanged |
4398 DisplayState::eLayerStackChanged;
Dominik Laskowski83b88212018-12-11 13:34:06 -08004399 d.token = token;
Jesse Hall01e29052013-02-19 16:13:35 -08004400 d.layerStack = 0;
Andy McFadden13a082e2012-08-24 10:16:42 -07004401 d.orientation = DisplayState::eOrientationDefault;
Jeff Brown4c05dd12012-09-09 00:07:17 -07004402 d.frame.makeInvalid();
4403 d.viewport.makeInvalid();
Michael Lentine47e45402014-07-18 15:34:25 -07004404 d.width = 0;
4405 d.height = 0;
Andy McFadden13a082e2012-08-24 10:16:42 -07004406 displays.add(d);
Marissa Wall3dad52d2019-03-22 14:03:19 -07004407 setTransactionState(state, displays, 0, nullptr, mPendingInputWindowCommands, -1, {}, {});
Jamie Gennis6547ff42013-07-16 20:12:42 -07004408
Dominik Laskowskie9774092018-12-11 10:04:24 -08004409 setPowerModeInternal(display, HWC_POWER_MODE_NORMAL);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004410
Dominik Laskowski83b88212018-12-11 13:34:06 -08004411 const nsecs_t vsyncPeriod = getVsyncPeriod();
4412 mAnimFrameTracker.setDisplayRefreshPeriod(vsyncPeriod);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08004413
Brian Andersond0010582017-03-07 13:20:31 -08004414 // Use phase of 0 since phase is not known.
4415 // Use latency of 0, which will snap to the ideal latency.
Dominik Laskowski83b88212018-12-11 13:34:06 -08004416 DisplayStatInfo stats{0 /* vsyncTime */, vsyncPeriod};
Ana Krulece588e312018-09-18 12:32:24 -07004417 setCompositorTimingSnapped(stats, 0);
Andy McFadden13a082e2012-08-24 10:16:42 -07004418}
4419
4420void SurfaceFlinger::initializeDisplays() {
Dominik Laskowski8c001672018-05-30 16:52:06 -07004421 // Async since we may be called from the main thread.
Dominik Laskowski83b88212018-12-11 13:34:06 -08004422 postMessageAsync(
4423 new LambdaMessage([this]() NO_THREAD_SAFETY_ANALYSIS { onInitializeDisplays(); }));
Andy McFadden13a082e2012-08-24 10:16:42 -07004424}
4425
Ady Abraham27c70212019-06-11 10:52:26 -07004426void SurfaceFlinger::setVsyncEnabledInHWC(DisplayId displayId, HWC2::Vsync enabled) {
4427 if (mHWCVsyncState != enabled) {
4428 getHwComposer().setVsyncEnabled(displayId, enabled);
4429 mHWCVsyncState = enabled;
4430 }
4431}
4432
Dominik Laskowskie9774092018-12-11 10:04:24 -08004433void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& display, int mode) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004434 if (display->isVirtual()) {
4435 ALOGE("%s: Invalid operation on virtual display", __FUNCTION__);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004436 return;
4437 }
4438
Dominik Laskowski075d3172018-05-24 15:50:06 -07004439 const auto displayId = display->getId();
4440 LOG_ALWAYS_FATAL_IF(!displayId);
4441
Dominik Laskowski34157762018-10-31 13:07:19 -07004442 ALOGD("Setting power mode %d on display %s", mode, to_string(*displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004443
4444 int currentMode = display->getPowerMode();
4445 if (mode == currentMode) {
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004446 return;
4447 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004448
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004449 display->setPowerMode(mode);
4450
Lloyd Pique4dccc412018-01-22 17:21:36 -08004451 if (mInterceptor->isEnabled()) {
Dominik Laskowskie9774092018-12-11 10:04:24 -08004452 mInterceptor->savePowerModeUpdate(display->getSequenceId(), mode);
Irvelffc9efc2016-07-27 15:16:37 -07004453 }
4454
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004455 if (currentMode == HWC_POWER_MODE_OFF) {
Tim Murrayf9d4e442016-08-02 15:43:59 -07004456 // Turn on the display
Dominik Laskowski075d3172018-05-24 15:50:06 -07004457 getHwComposer().setPowerMode(*displayId, mode);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004458 if (display->isPrimary() && mode != HWC_POWER_MODE_DOZE_SUSPEND) {
Ady Abraham27c70212019-06-11 10:52:26 -07004459 setVsyncEnabledInHWC(*displayId, mHWCVsyncPendingState);
Ana Krulecc2870422019-01-29 19:00:58 -08004460 mScheduler->onScreenAcquired(mAppConnectionHandle);
4461 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004462 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004463
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004464 mVisibleRegionsDirty = true;
Dan Stozab90cf072015-03-05 11:05:59 -08004465 mHasPoweredOff = true;
Dan Stozac7a25ad2018-04-12 11:45:09 -07004466 repaintEverything();
Tim Murrayf9d4e442016-08-02 15:43:59 -07004467
4468 struct sched_param param = {0};
4469 param.sched_priority = 1;
4470 if (sched_setscheduler(0, SCHED_FIFO, &param) != 0) {
4471 ALOGW("Couldn't set SCHED_FIFO on display on");
4472 }
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004473 } else if (mode == HWC_POWER_MODE_OFF) {
Tim Murrayf9d4e442016-08-02 15:43:59 -07004474 // Turn off the display
4475 struct sched_param param = {0};
4476 if (sched_setscheduler(0, SCHED_OTHER, &param) != 0) {
4477 ALOGW("Couldn't set SCHED_OTHER on display off");
4478 }
4479
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004480 if (display->isPrimary() && currentMode != HWC_POWER_MODE_DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08004481 mScheduler->disableHardwareVsync(true);
4482 mScheduler->onScreenReleased(mAppConnectionHandle);
Mathias Agopiancde87a32012-09-13 14:09:01 -07004483 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004484
Ady Abraham27c70212019-06-11 10:52:26 -07004485 // Make sure HWVsync is disabled before turning off the display
4486 setVsyncEnabledInHWC(*displayId, HWC2::Vsync::Disable);
4487
Dominik Laskowski075d3172018-05-24 15:50:06 -07004488 getHwComposer().setPowerMode(*displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004489 mVisibleRegionsDirty = true;
4490 // from this point on, SF will stop drawing on this display
Matthew Bouyack38d49612017-05-12 12:49:32 -07004491 } else if (mode == HWC_POWER_MODE_DOZE ||
4492 mode == HWC_POWER_MODE_NORMAL) {
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004493 // Update display while dozing
Dominik Laskowski075d3172018-05-24 15:50:06 -07004494 getHwComposer().setPowerMode(*displayId, mode);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004495 if (display->isPrimary() && currentMode == HWC_POWER_MODE_DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08004496 mScheduler->onScreenAcquired(mAppConnectionHandle);
4497 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004498 }
4499 } else if (mode == HWC_POWER_MODE_DOZE_SUSPEND) {
4500 // Leave display going to doze
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004501 if (display->isPrimary()) {
Ana Krulecc2870422019-01-29 19:00:58 -08004502 mScheduler->disableHardwareVsync(true);
4503 mScheduler->onScreenReleased(mAppConnectionHandle);
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004504 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07004505 getHwComposer().setPowerMode(*displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004506 } else {
Matthew Bouyack38d49612017-05-12 12:49:32 -07004507 ALOGE("Attempting to set unknown power mode: %d\n", mode);
Dominik Laskowski075d3172018-05-24 15:50:06 -07004508 getHwComposer().setPowerMode(*displayId, mode);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004509 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004510
Yiwei Zhang3a226d22018-10-16 09:23:03 -07004511 if (display->isPrimary()) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08004512 mTimeStats->setPowerMode(mode);
Dominik Laskowski22488f62019-03-28 09:53:04 -07004513 mRefreshRateStats.setPowerMode(mode);
Ady Abraham6fe2c172019-07-12 12:37:57 -07004514 mScheduler->setDisplayPowerState(mode == HWC_POWER_MODE_NORMAL);
Yiwei Zhang3a226d22018-10-16 09:23:03 -07004515 }
4516
Dominik Laskowski34157762018-10-31 13:07:19 -07004517 ALOGD("Finished setting power mode %d on display %s", mode, to_string(*displayId).c_str());
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004518}
4519
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004520void SurfaceFlinger::setPowerMode(const sp<IBinder>& displayToken, int mode) {
Dominik Laskowski83b88212018-12-11 13:34:06 -08004521 postMessageSync(new LambdaMessage([&]() NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004522 const auto display = getDisplayDevice(displayToken);
4523 if (!display) {
4524 ALOGE("Attempt to set power mode %d for invalid display token %p", mode,
4525 displayToken.get());
4526 } else if (display->isVirtual()) {
4527 ALOGW("Attempt to set power mode %d for virtual display", mode);
4528 } else {
Dominik Laskowskie9774092018-12-11 10:04:24 -08004529 setPowerModeInternal(display, mode);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004530 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004531 }));
Mathias Agopianb60314a2012-04-10 22:09:54 -07004532}
4533
4534// ---------------------------------------------------------------------------
4535
Dominik Laskowskic2867142019-01-21 11:33:38 -08004536status_t SurfaceFlinger::doDump(int fd, const DumpArgs& args,
4537 bool asProto) NO_THREAD_SAFETY_ANALYSIS {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004538 std::string result;
Mathias Agopian99b49842011-06-27 16:05:52 -07004539
Mathias Agopianbd115332013-04-18 16:41:04 -07004540 IPCThreadState* ipc = IPCThreadState::self();
4541 const int pid = ipc->getCallingPid();
4542 const int uid = ipc->getCallingUid();
Vishnu Nair6a408532017-10-24 09:11:27 -07004543
Mathias Agopianbd115332013-04-18 16:41:04 -07004544 if ((uid != AID_SHELL) &&
4545 !PermissionCache::checkPermission(sDump, pid, uid)) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004546 StringAppendF(&result, "Permission Denial: can't dump SurfaceFlinger from pid=%d, uid=%d\n",
4547 pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004548 } else {
Jesse Hallfcd15b42014-12-23 13:57:23 -08004549 // Try to get the main lock, but give up after one second
Mathias Agopian9795c422009-08-26 16:36:26 -07004550 // (this would indicate SF is stuck, but we want to be able to
4551 // print something in dumpsys).
Jesse Hallfcd15b42014-12-23 13:57:23 -08004552 status_t err = mStateLock.timedLock(s2ns(1));
4553 bool locked = (err == NO_ERROR);
Mathias Agopian9795c422009-08-26 16:36:26 -07004554 if (!locked) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004555 StringAppendF(&result,
4556 "SurfaceFlinger appears to be unresponsive (%s [%d]), dumping anyways "
4557 "(no locks held)\n",
4558 strerror(-err), err);
Mathias Agopian9795c422009-08-26 16:36:26 -07004559 }
4560
Dominik Laskowskic2867142019-01-21 11:33:38 -08004561 using namespace std::string_literals;
chaviwa3d7bd32017-11-03 09:41:53 -07004562
Dominik Laskowskic2867142019-01-21 11:33:38 -08004563 static const std::unordered_map<std::string, Dumper> dumpers = {
4564 {"--clear-layer-stats"s, dumper([this](std::string&) { mLayerStats.clear(); })},
4565 {"--disable-layer-stats"s, dumper([this](std::string&) { mLayerStats.disable(); })},
4566 {"--display-id"s, dumper(&SurfaceFlinger::dumpDisplayIdentificationData)},
Ady Abraham3aff9172019-02-07 19:10:26 -08004567 {"--dispsync"s, dumper([this](std::string& s) {
Ady Abraham3aff9172019-02-07 19:10:26 -08004568 mScheduler->dumpPrimaryDispSync(s);
Ady Abraham3aff9172019-02-07 19:10:26 -08004569 })},
Dominik Laskowskic2867142019-01-21 11:33:38 -08004570 {"--dump-layer-stats"s, dumper([this](std::string& s) { mLayerStats.dump(s); })},
4571 {"--enable-layer-stats"s, dumper([this](std::string&) { mLayerStats.enable(); })},
Dominik Laskowskic2867142019-01-21 11:33:38 -08004572 {"--frame-events"s, dumper(&SurfaceFlinger::dumpFrameEventsLocked)},
4573 {"--latency"s, argsDumper(&SurfaceFlinger::dumpStatsLocked)},
4574 {"--latency-clear"s, argsDumper(&SurfaceFlinger::clearStatsLocked)},
4575 {"--list"s, dumper(&SurfaceFlinger::listLayersLocked)},
4576 {"--static-screen"s, dumper(&SurfaceFlinger::dumpStaticScreenStats)},
4577 {"--timestats"s, protoDumper(&SurfaceFlinger::dumpTimeStats)},
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004578 {"--vsync"s, dumper(&SurfaceFlinger::dumpVSync)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08004579 {"--wide-color"s, dumper(&SurfaceFlinger::dumpWideColorInfo)},
4580 };
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004581
Dominik Laskowskic2867142019-01-21 11:33:38 -08004582 const auto flag = args.empty() ? ""s : std::string(String8(args[0]));
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004583
Dominik Laskowskic2867142019-01-21 11:33:38 -08004584 if (const auto it = dumpers.find(flag); it != dumpers.end()) {
4585 (it->second)(args, asProto, result);
4586 } else {
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07004587 if (asProto) {
4588 LayersProto layersProto = dumpProtoInfo(LayerVector::StateSet::Current);
4589 result.append(layersProto.SerializeAsString().c_str(), layersProto.ByteSize());
4590 } else {
Dominik Laskowskic2867142019-01-21 11:33:38 -08004591 dumpAllLocked(args, result);
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07004592 }
Mathias Agopian48b888a2011-01-19 16:15:53 -08004593 }
4594
Mathias Agopian9795c422009-08-26 16:36:26 -07004595 if (locked) {
4596 mStateLock.unlock();
4597 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004598 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08004599 write(fd, result.c_str(), result.size());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004600 return NO_ERROR;
4601}
4602
Nataniel Borges8e7dc722019-02-28 15:10:28 -08004603status_t SurfaceFlinger::dumpCritical(int fd, const DumpArgs&, bool asProto) {
4604 if (asProto && mTracing.isEnabled()) {
4605 mTracing.writeToFileAsync();
4606 }
4607
4608 return doDump(fd, DumpArgs(), asProto);
4609}
4610
Dominik Laskowskic2867142019-01-21 11:33:38 -08004611void SurfaceFlinger::listLayersLocked(std::string& result) const {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004612 mCurrentState.traverseInZOrder(
4613 [&](Layer* layer) { StringAppendF(&result, "%s\n", layer->getName().string()); });
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004614}
4615
Dominik Laskowskic2867142019-01-21 11:33:38 -08004616void SurfaceFlinger::dumpStatsLocked(const DumpArgs& args, std::string& result) const {
Dominik Laskowski83b88212018-12-11 13:34:06 -08004617 StringAppendF(&result, "%" PRId64 "\n", getVsyncPeriod());
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004618
Dominik Laskowskic2867142019-01-21 11:33:38 -08004619 if (args.size() > 1) {
4620 const auto name = String8(args[1]);
Robert Carr2047fae2016-11-28 14:09:09 -08004621 mCurrentState.traverseInZOrder([&](Layer* layer) {
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004622 if (name == layer->getName()) {
Svetoslavd85084b2014-03-20 10:28:31 -07004623 layer->dumpFrameStats(result);
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004624 }
Robert Carr2047fae2016-11-28 14:09:09 -08004625 });
Dominik Laskowskic2867142019-01-21 11:33:38 -08004626 } else {
4627 mAnimFrameTracker.dumpStats(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004628 }
4629}
4630
Dominik Laskowskic2867142019-01-21 11:33:38 -08004631void SurfaceFlinger::clearStatsLocked(const DumpArgs& args, std::string&) {
Robert Carr2047fae2016-11-28 14:09:09 -08004632 mCurrentState.traverseInZOrder([&](Layer* layer) {
Dominik Laskowskic2867142019-01-21 11:33:38 -08004633 if (args.size() < 2 || String8(args[1]) == layer->getName()) {
Svetoslavd85084b2014-03-20 10:28:31 -07004634 layer->clearFrameStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004635 }
Robert Carr2047fae2016-11-28 14:09:09 -08004636 });
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004637
Svetoslavd85084b2014-03-20 10:28:31 -07004638 mAnimFrameTracker.clearStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004639}
4640
Dominik Laskowskic2867142019-01-21 11:33:38 -08004641void SurfaceFlinger::dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const {
4642 mTimeStats->parseArgs(asProto, args, result);
4643}
4644
Jamie Gennis6547ff42013-07-16 20:12:42 -07004645// This should only be called from the main thread. Otherwise it would need
4646// the lock and should use mCurrentState rather than mDrawingState.
4647void SurfaceFlinger::logFrameStats() {
Robert Carr2047fae2016-11-28 14:09:09 -08004648 mDrawingState.traverseInZOrder([&](Layer* layer) {
Jamie Gennis6547ff42013-07-16 20:12:42 -07004649 layer->logFrameStats();
Robert Carr2047fae2016-11-28 14:09:09 -08004650 });
Jamie Gennis6547ff42013-07-16 20:12:42 -07004651
4652 mAnimFrameTracker.logAndResetStats(String8("<win-anim>"));
4653}
4654
Yiwei Zhang5434a782018-12-05 18:06:32 -08004655void SurfaceFlinger::appendSfConfigString(std::string& result) const {
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004656 result.append(" [sf");
Fabien Sanglardc93afd52017-03-13 13:02:42 -07004657
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004658 if (isLayerTripleBufferingDisabled())
4659 result.append(" DISABLE_TRIPLE_BUFFERING");
Fabien Sanglardc45a7d92017-03-14 13:24:22 -07004660
Yiwei Zhang5434a782018-12-05 18:06:32 -08004661 StringAppendF(&result, " PRESENT_TIME_OFFSET=%" PRId64, dispSyncPresentTimeOffset);
4662 StringAppendF(&result, " FORCE_HWC_FOR_RBG_TO_YUV=%d", useHwcForRgbToYuv);
4663 StringAppendF(&result, " MAX_VIRT_DISPLAY_DIM=%" PRIu64, maxVirtualDisplaySize);
4664 StringAppendF(&result, " RUNNING_WITHOUT_SYNC_FRAMEWORK=%d", !hasSyncFramework);
4665 StringAppendF(&result, " NUM_FRAMEBUFFER_SURFACE_BUFFERS=%" PRId64,
4666 maxFrameBufferAcquiredBuffers);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004667 result.append("]");
Andy McFadden4803b742012-09-24 19:07:20 -07004668}
4669
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004670void SurfaceFlinger::dumpVSync(std::string& result) const {
Ana Krulec757f63a2019-01-25 10:46:18 -08004671 mPhaseOffsets->dump(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004672 StringAppendF(&result,
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004673 " present offset: %9" PRId64 " ns\t VSYNC period: %9" PRId64 " ns\n\n",
Ana Krulec757f63a2019-01-25 10:46:18 -08004674 dispSyncPresentTimeOffset, getVsyncPeriod());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004675
Ady Abraham97d04232019-03-05 19:48:12 -08004676 StringAppendF(&result, "Scheduler enabled.");
Ana Krulecba13ab32019-02-20 14:14:12 -08004677 StringAppendF(&result, "+ Smart 90 for video detection: %s\n\n",
4678 mUseSmart90ForVideo ? "on" : "off");
Ady Abraham42b3beb2019-07-09 18:09:52 -07004679 StringAppendF(&result, "Allowed Display Configs: ");
Ady Abraham261614e2019-07-10 17:53:12 -07004680 for (auto refresh : mRefreshRateConfigs.getRefreshRates()) {
4681 if (refresh.second && isDisplayConfigAllowed(refresh.second->configId)) {
4682 StringAppendF(&result, "%dHz, ", refresh.second->fps);
Ady Abraham42b3beb2019-07-09 18:09:52 -07004683 }
4684 }
4685 StringAppendF(&result, "(config override by backdoor: %s)\n\n",
4686 mDebugDisplayConfigSetByBackdoor ? "yes" : "no");
Ana Krulecc2870422019-01-29 19:00:58 -08004687 mScheduler->dump(mAppConnectionHandle, result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004688}
4689
Yiwei Zhang5434a782018-12-05 18:06:32 -08004690void SurfaceFlinger::dumpStaticScreenStats(std::string& result) const {
4691 result.append("Static screen stats:\n");
David Sodman4a36e932017-11-07 14:29:47 -08004692 for (size_t b = 0; b < SurfaceFlingerBE::NUM_BUCKETS - 1; ++b) {
4693 float bucketTimeSec = getBE().mFrameBuckets[b] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08004694 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08004695 static_cast<float>(getBE().mFrameBuckets[b]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004696 StringAppendF(&result, " < %zd frames: %.3f s (%.1f%%)\n", b + 1, bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08004697 }
David Sodman4a36e932017-11-07 14:29:47 -08004698 float bucketTimeSec = getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08004699 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08004700 static_cast<float>(getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004701 StringAppendF(&result, " %zd+ frames: %.3f s (%.1f%%)\n", SurfaceFlingerBE::NUM_BUCKETS - 1,
4702 bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08004703}
4704
Dan Stozae77c7662016-05-13 11:37:28 -07004705void SurfaceFlinger::recordBufferingStats(const char* layerName,
4706 std::vector<OccupancyTracker::Segment>&& history) {
David Sodmancbaf0832017-11-07 14:21:36 -08004707 Mutex::Autolock lock(getBE().mBufferingStatsMutex);
4708 auto& stats = getBE().mBufferingStats[layerName];
Dan Stozae77c7662016-05-13 11:37:28 -07004709 for (const auto& segment : history) {
4710 if (!segment.usedThirdBuffer) {
4711 stats.twoBufferTime += segment.totalTime;
4712 }
4713 if (segment.occupancyAverage < 1.0f) {
4714 stats.doubleBufferedTime += segment.totalTime;
4715 } else if (segment.occupancyAverage < 2.0f) {
4716 stats.tripleBufferedTime += segment.totalTime;
4717 }
4718 ++stats.numSegments;
4719 stats.totalTime += segment.totalTime;
4720 }
4721}
4722
Yiwei Zhang5434a782018-12-05 18:06:32 -08004723void SurfaceFlinger::dumpFrameEventsLocked(std::string& result) {
4724 result.append("Layer frame timestamps:\n");
Brian Andersond6927fb2016-07-23 23:37:30 -07004725
4726 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
4727 const size_t count = currentLayers.size();
4728 for (size_t i=0 ; i<count ; i++) {
4729 currentLayers[i]->dumpFrameEvents(result);
4730 }
4731}
4732
Yiwei Zhang5434a782018-12-05 18:06:32 -08004733void SurfaceFlinger::dumpBufferingStats(std::string& result) const {
Dan Stozae77c7662016-05-13 11:37:28 -07004734 result.append("Buffering stats:\n");
4735 result.append(" [Layer name] <Active time> <Two buffer> "
4736 "<Double buffered> <Triple buffered>\n");
David Sodmancbaf0832017-11-07 14:21:36 -08004737 Mutex::Autolock lock(getBE().mBufferingStatsMutex);
Dan Stozae77c7662016-05-13 11:37:28 -07004738 typedef std::tuple<std::string, float, float, float> BufferTuple;
4739 std::map<float, BufferTuple, std::greater<float>> sorted;
David Sodmancbaf0832017-11-07 14:21:36 -08004740 for (const auto& statsPair : getBE().mBufferingStats) {
Dan Stozae77c7662016-05-13 11:37:28 -07004741 const char* name = statsPair.first.c_str();
David Sodmancbaf0832017-11-07 14:21:36 -08004742 const SurfaceFlingerBE::BufferingStats& stats = statsPair.second;
Dan Stozae77c7662016-05-13 11:37:28 -07004743 if (stats.numSegments == 0) {
4744 continue;
4745 }
4746 float activeTime = ns2ms(stats.totalTime) / 1000.0f;
4747 float twoBufferRatio = static_cast<float>(stats.twoBufferTime) /
4748 stats.totalTime;
4749 float doubleBufferRatio = static_cast<float>(
4750 stats.doubleBufferedTime) / stats.totalTime;
4751 float tripleBufferRatio = static_cast<float>(
4752 stats.tripleBufferedTime) / stats.totalTime;
4753 sorted.insert({activeTime, {name, twoBufferRatio,
4754 doubleBufferRatio, tripleBufferRatio}});
4755 }
4756 for (const auto& sortedPair : sorted) {
4757 float activeTime = sortedPair.first;
4758 const BufferTuple& values = sortedPair.second;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004759 StringAppendF(&result, " [%s] %.2f %.3f %.3f %.3f\n", std::get<0>(values).c_str(),
4760 activeTime, std::get<1>(values), std::get<2>(values), std::get<3>(values));
Dan Stozae77c7662016-05-13 11:37:28 -07004761 }
4762 result.append("\n");
4763}
4764
Yiwei Zhang5434a782018-12-05 18:06:32 -08004765void SurfaceFlinger::dumpDisplayIdentificationData(std::string& result) const {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004766 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004767 const auto displayId = display->getId();
4768 if (!displayId) {
4769 continue;
4770 }
4771 const auto hwcDisplayId = getHwComposer().fromPhysicalDisplayId(*displayId);
Dominik Laskowski7e045462018-05-30 13:02:02 -07004772 if (!hwcDisplayId) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004773 continue;
4774 }
4775
Yiwei Zhang5434a782018-12-05 18:06:32 -08004776 StringAppendF(&result,
4777 "Display %s (HWC display %" PRIu64 "): ", to_string(*displayId).c_str(),
4778 *hwcDisplayId);
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004779 uint8_t port;
4780 DisplayIdentificationData data;
Dominik Laskowski7e045462018-05-30 13:02:02 -07004781 if (!getHwComposer().getDisplayIdentificationData(*hwcDisplayId, &port, &data)) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004782 result.append("no identification data\n");
4783 continue;
4784 }
4785
4786 if (!isEdid(data)) {
4787 result.append("unknown identification data: ");
4788 for (uint8_t byte : data) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004789 StringAppendF(&result, "%x ", byte);
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004790 }
4791 result.append("\n");
4792 continue;
4793 }
4794
4795 const auto edid = parseEdid(data);
4796 if (!edid) {
4797 result.append("invalid EDID: ");
4798 for (uint8_t byte : data) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004799 StringAppendF(&result, "%x ", byte);
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004800 }
4801 result.append("\n");
4802 continue;
4803 }
4804
Yiwei Zhang5434a782018-12-05 18:06:32 -08004805 StringAppendF(&result, "port=%u pnpId=%s displayName=\"", port, edid->pnpId.data());
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004806 result.append(edid->displayName.data(), edid->displayName.length());
4807 result.append("\"\n");
4808 }
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004809}
4810
Yiwei Zhang5434a782018-12-05 18:06:32 -08004811void SurfaceFlinger::dumpWideColorInfo(std::string& result) const {
Peiyong Linff84a152019-05-17 18:36:19 -07004812 StringAppendF(&result, "Device has wide color built-in display: %d\n", hasWideColorDisplay);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004813 StringAppendF(&result, "Device uses color management: %d\n", useColorManagement);
4814 StringAppendF(&result, "DisplayColorSetting: %s\n",
4815 decodeDisplayColorSetting(mDisplayColorSetting).c_str());
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004816
4817 // TODO: print out if wide-color mode is active or not
4818
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004819 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004820 const auto displayId = display->getId();
4821 if (!displayId) {
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004822 continue;
4823 }
4824
Yiwei Zhang5434a782018-12-05 18:06:32 -08004825 StringAppendF(&result, "Display %s color modes:\n", to_string(*displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004826 std::vector<ColorMode> modes = getHwComposer().getColorModes(*displayId);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004827 for (auto&& mode : modes) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004828 StringAppendF(&result, " %s (%d)\n", decodeColorMode(mode).c_str(), mode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004829 }
4830
Lloyd Pique32cbe282018-10-19 13:09:22 -07004831 ColorMode currentMode = display->getCompositionDisplay()->getState().colorMode;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004832 StringAppendF(&result, " Current color mode: %s (%d)\n",
4833 decodeColorMode(currentMode).c_str(), currentMode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004834 }
4835 result.append("\n");
4836}
4837
Vishnu Nair9245d3b2019-03-22 13:38:56 -07004838LayersProto SurfaceFlinger::dumpProtoInfo(LayerVector::StateSet stateSet,
4839 uint32_t traceFlags) const {
chaviw1d044282017-09-27 12:19:28 -07004840 LayersProto layersProto;
Jorim Jaggi8e0af362017-11-14 16:28:28 +01004841 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
4842 const State& state = useDrawing ? mDrawingState : mCurrentState;
4843 state.traverseInZOrder([&](Layer* layer) {
chaviw1d044282017-09-27 12:19:28 -07004844 LayerProto* layerProto = layersProto.add_layers();
Vishnu Nair9245d3b2019-03-22 13:38:56 -07004845 layer->writeToProto(layerProto, stateSet, traceFlags);
chaviw1d044282017-09-27 12:19:28 -07004846 });
4847
4848 return layersProto;
4849}
4850
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004851LayersProto SurfaceFlinger::dumpVisibleLayersProtoInfo(
4852 const sp<DisplayDevice>& displayDevice) const {
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004853 LayersProto layersProto;
Yiwei Zhang60d1a192018-03-07 14:52:28 -08004854
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004855 SizeProto* resolution = layersProto.mutable_resolution();
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004856 resolution->set_w(displayDevice->getWidth());
4857 resolution->set_h(displayDevice->getHeight());
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004858
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004859 auto display = displayDevice->getCompositionDisplay();
Lloyd Pique32cbe282018-10-19 13:09:22 -07004860 const auto& displayState = display->getState();
Yiwei Zhang60d1a192018-03-07 14:52:28 -08004861
Lloyd Pique32cbe282018-10-19 13:09:22 -07004862 layersProto.set_color_mode(decodeColorMode(displayState.colorMode));
4863 layersProto.set_color_transform(decodeColorTransform(displayState.colorTransform));
4864 layersProto.set_global_transform(displayState.orientation);
4865
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004866 const auto displayId = displayDevice->getId();
Dominik Laskowski075d3172018-05-24 15:50:06 -07004867 LOG_ALWAYS_FATAL_IF(!displayId);
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004868 mDrawingState.traverseInZOrder([&](Layer* layer) {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004869 if (!layer->visibleRegion.isEmpty() && !display->getOutputLayersOrderedByZ().empty()) {
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004870 LayerProto* layerProto = layersProto.add_layers();
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004871 layer->writeToProto(layerProto, displayDevice);
Yiwei Zhang7124ad32018-02-21 13:02:45 -08004872 }
4873 });
4874
4875 return layersProto;
4876}
4877
Dominik Laskowskic2867142019-01-21 11:33:38 -08004878void SurfaceFlinger::dumpAllLocked(const DumpArgs& args, std::string& result) const {
4879 const bool colorize = !args.empty() && args[0] == String16("--color");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004880 Colorizer colorizer(colorize);
4881
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004882 // figure out if we're stuck somewhere
4883 const nsecs_t now = systemTime();
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004884 const nsecs_t inTransaction(mDebugInTransaction);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004885 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
4886
4887 /*
Andy McFadden4803b742012-09-24 19:07:20 -07004888 * Dump library configuration.
4889 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004890
4891 colorizer.bold(result);
Andy McFadden4803b742012-09-24 19:07:20 -07004892 result.append("Build configuration:");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004893 colorizer.reset(result);
Andy McFadden4803b742012-09-24 19:07:20 -07004894 appendSfConfigString(result);
4895 appendUiConfigString(result);
4896 appendGuiConfigString(result);
4897 result.append("\n");
4898
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004899 result.append("\nDisplay identification data:\n");
4900 dumpDisplayIdentificationData(result);
4901
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004902 result.append("\nWide-Color information:\n");
4903 dumpWideColorInfo(result);
4904
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004905 colorizer.bold(result);
Mathias Agopianca088332013-03-28 17:44:13 -07004906 result.append("Sync configuration: ");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004907 colorizer.reset(result);
Mathias Agopianca088332013-03-28 17:44:13 -07004908 result.append(SyncFeatures::getInstance().toString());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004909 result.append("\n\n");
Mathias Agopianca088332013-03-28 17:44:13 -07004910
Andy McFadden41d67d72014-04-25 16:58:34 -07004911 colorizer.bold(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004912 result.append("VSYNC configuration:\n");
Andy McFadden41d67d72014-04-25 16:58:34 -07004913 colorizer.reset(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004914 dumpVSync(result);
Dan Stozab90cf072015-03-05 11:05:59 -08004915 result.append("\n");
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004916
Dan Stozab90cf072015-03-05 11:05:59 -08004917 dumpStaticScreenStats(result);
4918 result.append("\n");
4919
Alec Mouri40189b02019-03-05 15:07:54 -08004920 StringAppendF(&result, "Total missed frame count: %u\n", mFrameMissedCount.load());
4921 StringAppendF(&result, "HWC missed frame count: %u\n", mHwcFrameMissedCount.load());
4922 StringAppendF(&result, "GPU missed frame count: %u\n\n", mGpuFrameMissedCount.load());
Marissa Wallcfcdaa52018-05-21 15:45:59 -07004923
Dan Stozae77c7662016-05-13 11:37:28 -07004924 dumpBufferingStats(result);
4925
Andy McFadden4803b742012-09-24 19:07:20 -07004926 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004927 * Dump the visible layer list
4928 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004929 colorizer.bold(result);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004930 StringAppendF(&result, "Visible layers (count = %zu)\n", mNumLayers);
4931 StringAppendF(&result, "GraphicBufferProducers: %zu, max %zu\n",
4932 mGraphicBufferProducerList.size(), mMaxGraphicBufferProducerListSize);
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004933 colorizer.reset(result);
chaviw1d044282017-09-27 12:19:28 -07004934
Chia-I Wu2f884132018-09-13 15:17:58 -07004935 {
4936 LayersProto layersProto = dumpProtoInfo(LayerVector::StateSet::Current);
4937 auto layerTree = LayerProtoParser::generateLayerTree(layersProto);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004938 result.append(LayerProtoParser::layerTreeToString(layerTree));
Chia-I Wu2f884132018-09-13 15:17:58 -07004939 result.append("\n");
4940 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004941
Lloyd Pique207def92019-02-28 16:09:52 -08004942 {
4943 StringAppendF(&result, "Composition layers\n");
4944 mDrawingState.traverseInZOrder([&](Layer* layer) {
4945 auto compositionLayer = layer->getCompositionLayer();
4946 if (compositionLayer) compositionLayer->dump(result);
4947 });
4948 }
4949
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004950 /*
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004951 * Dump Display state
4952 */
4953
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004954 colorizer.bold(result);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004955 StringAppendF(&result, "Displays (%zu entries)\n", mDisplays.size());
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004956 colorizer.reset(result);
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004957 for (const auto& [token, display] : mDisplays) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004958 display->dump(result);
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004959 }
Chia-I Wu1e043612018-03-01 09:45:09 -08004960 result.append("\n");
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004961
4962 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004963 * Dump SurfaceFlinger global state
4964 */
4965
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004966 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02004967 result.append("SurfaceFlinger global state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004968 colorizer.reset(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004969
Lloyd Piqueb97e04f2018-10-18 17:07:05 -07004970 getRenderEngine().dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004971
Ady Abrahama3b08ef2019-07-15 18:43:10 -07004972 DebugEGLImageTracker::getInstance()->dump(result);
4973
Dominik Laskowski075d3172018-05-24 15:50:06 -07004974 if (const auto display = getDefaultDisplayDeviceLocked()) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07004975 display->getCompositionDisplay()->getState().undefinedRegion.dump(result,
4976 "undefinedRegion");
Yiwei Zhang5434a782018-12-05 18:06:32 -08004977 StringAppendF(&result, " orientation=%d, isPoweredOn=%d\n", display->getOrientation(),
4978 display->isPoweredOn());
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08004979 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08004980 StringAppendF(&result,
4981 " transaction-flags : %08x\n"
4982 " gpu_to_cpu_unsupported : %d\n",
4983 mTransactionFlags.load(), !mGpuToCpuSupported);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004984
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08004985 if (const auto displayId = getInternalDisplayIdLocked();
Dominik Laskowski075d3172018-05-24 15:50:06 -07004986 displayId && getHwComposer().isConnected(*displayId)) {
4987 const auto activeConfig = getHwComposer().getActiveConfig(*displayId);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004988 StringAppendF(&result,
4989 " refresh-rate : %f fps\n"
4990 " x-dpi : %f\n"
4991 " y-dpi : %f\n",
4992 1e9 / activeConfig->getVsyncPeriod(), activeConfig->getDpiX(),
4993 activeConfig->getDpiY());
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004994 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004995
Yiwei Zhang5434a782018-12-05 18:06:32 -08004996 StringAppendF(&result, " transaction time: %f us\n", inTransactionDuration / 1000.0);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004997
Dan Stozae22aec72016-08-01 13:20:59 -07004998 /*
Yichi Chenadc69612018-09-15 14:51:18 +08004999 * Tracing state
5000 */
5001 mTracing.dump(result);
5002 result.append("\n");
5003
5004 /*
Dan Stozae22aec72016-08-01 13:20:59 -07005005 * HWC layer minidump
5006 */
Dominik Laskowski9fae1022018-05-29 13:17:40 -07005007 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07005008 const auto displayId = display->getId();
5009 if (!displayId) {
Dan Stozae22aec72016-08-01 13:20:59 -07005010 continue;
5011 }
5012
Yiwei Zhang5434a782018-12-05 18:06:32 -08005013 StringAppendF(&result, "Display %s HWC layers:\n", to_string(*displayId).c_str());
Dan Stozae22aec72016-08-01 13:20:59 -07005014 Layer::miniDumpHeader(result);
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08005015 const sp<DisplayDevice> displayDevice = display;
5016 mCurrentState.traverseInZOrder(
5017 [&](Layer* layer) { layer->miniDump(result, displayDevice); });
Dan Stozae22aec72016-08-01 13:20:59 -07005018 result.append("\n");
5019 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005020
5021 /*
5022 * Dump HWComposer state
5023 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005024 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02005025 result.append("h/w composer state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02005026 colorizer.reset(result);
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005027 bool hwcDisabled = mDebugDisableHWC || mDebugRegion;
Yiwei Zhang5434a782018-12-05 18:06:32 -08005028 StringAppendF(&result, " h/w composer %s\n", hwcDisabled ? "disabled" : "enabled");
Dominik Laskowski075d3172018-05-24 15:50:06 -07005029 getHwComposer().dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005030
5031 /*
5032 * Dump gralloc state
5033 */
5034 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
5035 alloc.dump(result);
Karthik Ravi Shankar171155a2017-06-28 15:40:24 -07005036
5037 /*
5038 * Dump VrFlinger state if in use.
5039 */
5040 if (mVrFlingerRequestsDisplay && mVrFlinger) {
5041 result.append("VrFlinger state:\n");
Yiwei Zhang5434a782018-12-05 18:06:32 -08005042 result.append(mVrFlinger->Dump());
Karthik Ravi Shankar171155a2017-06-28 15:40:24 -07005043 result.append("\n");
5044 }
Ana Krulecb43429d2019-01-09 14:28:51 -08005045
5046 /**
5047 * Scheduler dump state.
5048 */
Ana Krulecc2870422019-01-29 19:00:58 -08005049 result.append("\nScheduler state:\n");
5050 result.append(mScheduler->doDump() + "\n");
Ana Krulecfefd6ae2019-02-13 17:53:08 -08005051 StringAppendF(&result, "+ Smart video mode: %s\n\n", mUseSmart90ForVideo ? "on" : "off");
Dominik Laskowski22488f62019-03-28 09:53:04 -07005052 result.append(mRefreshRateStats.doDump() + "\n");
Yiwei Zhang7eb58b72019-04-22 19:00:02 -07005053
5054 result.append(mTimeStats->miniDump());
5055 result.append("\n");
Mathias Agopian82d7ab62012-01-19 18:34:40 -08005056}
5057
Dominik Laskowski075d3172018-05-24 15:50:06 -07005058const Vector<sp<Layer>>& SurfaceFlinger::getLayerSortedByZForHwcDisplay(DisplayId displayId) {
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07005059 // Note: mStateLock is held here
Dominik Laskowski9fae1022018-05-29 13:17:40 -07005060 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski7e045462018-05-30 13:02:02 -07005061 if (display->getId() == displayId) {
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07005062 return getDisplayDeviceLocked(token)->getVisibleLayersSortedByZ();
Jesse Hall48bc05b2013-03-21 14:06:52 -07005063 }
5064 }
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07005065
Dominik Laskowski34157762018-10-31 13:07:19 -07005066 ALOGE("%s: Invalid display %s", __FUNCTION__, to_string(displayId).c_str());
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07005067 static const Vector<sp<Layer>> empty;
5068 return empty;
Mathias Agopiancb558572012-10-04 15:58:54 -07005069}
5070
Chia-I Wu28f320b2018-05-03 11:02:56 -07005071void SurfaceFlinger::updateColorMatrixLocked() {
5072 mat4 colorMatrix;
5073 if (mGlobalSaturationFactor != 1.0f) {
5074 // Rec.709 luma coefficients
5075 float3 luminance{0.213f, 0.715f, 0.072f};
5076 luminance *= 1.0f - mGlobalSaturationFactor;
5077 mat4 saturationMatrix = mat4(
5078 vec4{luminance.r + mGlobalSaturationFactor, luminance.r, luminance.r, 0.0f},
5079 vec4{luminance.g, luminance.g + mGlobalSaturationFactor, luminance.g, 0.0f},
5080 vec4{luminance.b, luminance.b, luminance.b + mGlobalSaturationFactor, 0.0f},
5081 vec4{0.0f, 0.0f, 0.0f, 1.0f}
5082 );
5083 colorMatrix = mClientColorMatrix * saturationMatrix * mDaltonizer();
5084 } else {
5085 colorMatrix = mClientColorMatrix * mDaltonizer();
5086 }
5087
5088 if (mCurrentState.colorMatrix != colorMatrix) {
5089 mCurrentState.colorMatrix = colorMatrix;
5090 mCurrentState.colorMatrixChanged = true;
5091 setTransactionFlags(eTransactionNeeded);
5092 }
5093}
5094
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07005095status_t SurfaceFlinger::CheckTransactCodeCredentials(uint32_t code) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00005096#pragma clang diagnostic push
5097#pragma clang diagnostic error "-Wswitch-enum"
5098 switch (static_cast<ISurfaceComposerTag>(code)) {
5099 // These methods should at minimum make sure that the client requested
5100 // access to SF.
Dan Stozae3344402018-08-20 19:53:42 +00005101 case BOOT_FINISHED:
5102 case CLEAR_ANIMATION_FRAME_STATS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00005103 case CREATE_DISPLAY:
5104 case DESTROY_DISPLAY:
Dan Stozae3344402018-08-20 19:53:42 +00005105 case ENABLE_VSYNC_INJECTIONS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00005106 case GET_ANIMATION_FRAME_STATS:
5107 case GET_HDR_CAPABILITIES:
5108 case SET_ACTIVE_CONFIG:
Ady Abraham838de062019-02-04 10:24:03 -08005109 case SET_ALLOWED_DISPLAY_CONFIGS:
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08005110 case GET_ALLOWED_DISPLAY_CONFIGS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00005111 case SET_ACTIVE_COLOR_MODE:
Chia-I Wu90f669f2017-10-05 14:24:41 -07005112 case INJECT_VSYNC:
Kevin DuBois9c0a1762018-10-16 13:32:31 -07005113 case SET_POWER_MODE:
Kevin DuBois74e53772018-11-19 10:52:38 -08005114 case GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES:
Kevin DuBois1d4249a2018-08-29 10:45:14 -07005115 case SET_DISPLAY_CONTENT_SAMPLING_ENABLED:
Ady Abraham8532d012019-05-08 14:50:56 -07005116 case GET_DISPLAYED_CONTENT_SAMPLE:
5117 case NOTIFY_POWER_HINT: {
Robert Carrd4ae7f32018-06-07 16:10:57 -07005118 if (!callingThreadHasUnscopedSurfaceFlingerAccess()) {
5119 IPCThreadState* ipc = IPCThreadState::self();
5120 ALOGE("Permission Denial: can't access SurfaceFlinger pid=%d, uid=%d",
5121 ipc->getCallingPid(), ipc->getCallingUid());
Mathias Agopian375f5632009-06-15 18:24:59 -07005122 return PERMISSION_DENIED;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005123 }
Robert Carr1db73f62016-12-21 12:58:51 -08005124 return OK;
5125 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00005126 case GET_LAYER_DEBUG_INFO: {
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07005127 IPCThreadState* ipc = IPCThreadState::self();
5128 const int pid = ipc->getCallingPid();
5129 const int uid = ipc->getCallingUid();
Ana Krulec13be8ad2018-08-21 02:43:56 +00005130 if ((uid != AID_SHELL) && !PermissionCache::checkPermission(sDump, pid, uid)) {
5131 ALOGE("Layer debug info permission denied for pid=%d, uid=%d", pid, uid);
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07005132 return PERMISSION_DENIED;
5133 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00005134 return OK;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005135 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00005136 // Used by apps to hook Choreographer to SurfaceFlinger.
5137 case CREATE_DISPLAY_EVENT_CONNECTION:
5138 // The following calls are currently used by clients that do not
5139 // request necessary permissions. However, they do not expose any secret
5140 // information, so it is OK to pass them.
5141 case AUTHENTICATE_SURFACE:
Peiyong Lind1fedb42019-03-11 17:48:41 -07005142 case GET_ACTIVE_COLOR_MODE:
Ana Krulec13be8ad2018-08-21 02:43:56 +00005143 case GET_ACTIVE_CONFIG:
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08005144 case GET_PHYSICAL_DISPLAY_IDS:
5145 case GET_PHYSICAL_DISPLAY_TOKEN:
Ana Krulec13be8ad2018-08-21 02:43:56 +00005146 case GET_DISPLAY_COLOR_MODES:
Daniel Solomon42d04562019-01-20 21:03:19 -08005147 case GET_DISPLAY_NATIVE_PRIMARIES:
Ana Krulec13be8ad2018-08-21 02:43:56 +00005148 case GET_DISPLAY_CONFIGS:
5149 case GET_DISPLAY_STATS:
5150 case GET_SUPPORTED_FRAME_TIMESTAMPS:
5151 // Calling setTransactionState is safe, because you need to have been
5152 // granted a reference to Client* and Handle* to do anything with it.
5153 case SET_TRANSACTION_STATE:
Robert Carrb89ea9d2018-12-10 13:01:14 -08005154 case CREATE_CONNECTION:
Ady Abraham37965d42018-11-01 13:43:32 -07005155 case GET_COLOR_MANAGEMENT:
Peiyong Lin3c2791e2019-01-14 17:05:18 -08005156 case GET_COMPOSITION_PREFERENCE:
Marissa Wallebc2c052019-01-16 19:16:55 -08005157 case GET_PROTECTED_CONTENT_SUPPORT:
Dan Gittik57e63c52019-01-18 16:37:54 +00005158 case IS_WIDE_COLOR_DISPLAY:
5159 case GET_DISPLAY_BRIGHTNESS_SUPPORT:
5160 case SET_DISPLAY_BRIGHTNESS: {
Ana Krulec13be8ad2018-08-21 02:43:56 +00005161 return OK;
5162 }
Chong Zhangda6c1592019-07-16 13:45:06 -07005163 case CAPTURE_LAYERS: {
5164 IPCThreadState* ipc = IPCThreadState::self();
5165 const int pid = ipc->getCallingPid();
5166 const int uid = ipc->getCallingUid();
5167 // allow media to capture layer for video thumbnails
5168 if ((uid != AID_GRAPHICS && uid != AID_MEDIA) &&
5169 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
5170 ALOGE("Permission Denial: can't capture layer pid=%d, uid=%d", pid, uid);
5171 return PERMISSION_DENIED;
5172 }
5173 return OK;
5174 }
Dan Stoza84ab9372018-12-17 15:27:57 -08005175 case CAPTURE_SCREEN:
5176 case ADD_REGION_SAMPLING_LISTENER:
5177 case REMOVE_REGION_SAMPLING_LISTENER: {
Ana Krulec13be8ad2018-08-21 02:43:56 +00005178 // codes that require permission check
chaviwa76b2712017-09-20 12:02:26 -07005179 IPCThreadState* ipc = IPCThreadState::self();
5180 const int pid = ipc->getCallingPid();
5181 const int uid = ipc->getCallingUid();
5182 if ((uid != AID_GRAPHICS) &&
5183 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
5184 ALOGE("Permission Denial: can't read framebuffer pid=%d, uid=%d", pid, uid);
5185 return PERMISSION_DENIED;
5186 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00005187 return OK;
5188 }
5189 // The following codes are deprecated and should never be allowed to access SF.
5190 case CONNECT_DISPLAY_UNUSED:
5191 case CREATE_GRAPHIC_BUFFER_ALLOC_UNUSED: {
5192 ALOGE("Attempting to access SurfaceFlinger with unused code: %u", code);
5193 return PERMISSION_DENIED;
chaviwa76b2712017-09-20 12:02:26 -07005194 }
chaviw93df2ea2019-04-30 16:45:12 -07005195 case CAPTURE_SCREEN_BY_ID: {
5196 IPCThreadState* ipc = IPCThreadState::self();
5197 const int uid = ipc->getCallingUid();
Peiyong Lin96cfebc2019-05-15 11:36:13 -07005198 if (uid == AID_ROOT || uid == AID_GRAPHICS || uid == AID_SYSTEM || uid == AID_SHELL) {
chaviw93df2ea2019-04-30 16:45:12 -07005199 return OK;
5200 }
5201 return PERMISSION_DENIED;
5202 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005203 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00005204
5205 // These codes are used for the IBinder protocol to either interrogate the recipient
5206 // side of the transaction for its canonical interface descriptor or to dump its state.
5207 // We let them pass by default.
5208 if (code == IBinder::INTERFACE_TRANSACTION || code == IBinder::DUMP_TRANSACTION ||
5209 code == IBinder::PING_TRANSACTION || code == IBinder::SHELL_COMMAND_TRANSACTION ||
5210 code == IBinder::SYSPROPS_TRANSACTION) {
5211 return OK;
5212 }
Ady Abraham03b02dd2019-03-21 15:40:11 -07005213 // Numbers from 1000 to 1034 are currently used for backdoors. The code
Ana Krulec13be8ad2018-08-21 02:43:56 +00005214 // in onTransact verifies that the user is root, and has access to use SF.
Ady Abraham34392f72019-04-10 11:29:27 -07005215 if (code >= 1000 && code <= 1035) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00005216 ALOGV("Accessing SurfaceFlinger through backdoor code: %u", code);
5217 return OK;
5218 }
5219 ALOGE("Permission Denial: SurfaceFlinger did not recognize request code: %u", code);
5220 return PERMISSION_DENIED;
5221#pragma clang diagnostic pop
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07005222}
5223
Ana Krulec13be8ad2018-08-21 02:43:56 +00005224status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
5225 uint32_t flags) {
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07005226 status_t credentialCheck = CheckTransactCodeCredentials(code);
5227 if (credentialCheck != OK) {
5228 return credentialCheck;
5229 }
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07005230
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005231 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
5232 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
Mathias Agopianb8a55602009-06-26 19:06:36 -07005233 CHECK_INTERFACE(ISurfaceComposer, data, reply);
Romain Guy8c6bbd62017-06-05 13:51:43 -07005234 IPCThreadState* ipc = IPCThreadState::self();
5235 const int uid = ipc->getCallingUid();
5236 if (CC_UNLIKELY(uid != AID_SYSTEM
5237 && !PermissionCache::checkCallingPermission(sHardwareTest))) {
Mathias Agopian375f5632009-06-15 18:24:59 -07005238 const int pid = ipc->getCallingPid();
Steve Blocke6f43dd2012-01-06 19:20:56 +00005239 ALOGE("Permission Denial: "
Mathias Agopian375f5632009-06-15 18:24:59 -07005240 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005241 return PERMISSION_DENIED;
5242 }
5243 int n;
5244 switch (code) {
Mathias Agopian01b76682009-04-16 20:04:08 -07005245 case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
Mathias Agopian35b48d12010-09-13 22:57:58 -07005246 case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005247 return NO_ERROR;
5248 case 1002: // SHOW_UPDATES
5249 n = data.readInt32();
5250 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
Mathias Agopian53331da2011-08-22 21:44:41 -07005251 invalidateHwcGeometry();
5252 repaintEverything();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005253 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005254 case 1004:{ // repaint everything
Mathias Agopian53331da2011-08-22 21:44:41 -07005255 repaintEverything();
Mathias Agopiancbb288b2009-09-07 16:32:45 -07005256 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005257 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -07005258 case 1005:{ // force transaction
Steven Thomas6d8110b2017-08-31 18:24:21 -07005259 Mutex::Autolock _l(mStateLock);
Mathias Agopiane57f2922012-08-09 16:29:12 -07005260 setTransactionFlags(
5261 eTransactionNeeded|
5262 eDisplayTransactionNeeded|
5263 eTraversalNeeded);
Mathias Agopiancbb288b2009-09-07 16:32:45 -07005264 return NO_ERROR;
5265 }
Mathias Agopian4d143ee2012-02-23 20:05:39 -08005266 case 1006:{ // send empty update
5267 signalRefresh();
5268 return NO_ERROR;
5269 }
Mathias Agopian53331da2011-08-22 21:44:41 -07005270 case 1008: // toggle use of hw composer
5271 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005272 mDebugDisableHWC = n != 0;
Mathias Agopian53331da2011-08-22 21:44:41 -07005273 invalidateHwcGeometry();
5274 repaintEverything();
5275 return NO_ERROR;
Mathias Agopiana4583642011-08-23 18:03:18 -07005276 case 1009: // toggle use of transform hint
5277 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005278 mDebugDisableTransformHint = n != 0;
Mathias Agopiana4583642011-08-23 18:03:18 -07005279 invalidateHwcGeometry();
5280 repaintEverything();
5281 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005282 case 1010: // interrogate.
Mathias Agopian01b76682009-04-16 20:04:08 -07005283 reply->writeInt32(0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005284 reply->writeInt32(0);
5285 reply->writeInt32(mDebugRegion);
Mathias Agopianb9494d52012-04-18 02:28:45 -07005286 reply->writeInt32(0);
Dianne Hackborn12839be2012-02-06 21:21:05 -08005287 reply->writeInt32(mDebugDisableHWC);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005288 return NO_ERROR;
5289 case 1013: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005290 const auto display = getDefaultDisplayDevice();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07005291 if (!display) {
5292 return NAME_NOT_FOUND;
5293 }
5294
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005295 reply->writeInt32(display->getPageFlipCount());
Mathias Agopianff2ed702013-09-01 21:36:12 -07005296 return NO_ERROR;
5297 }
5298 case 1014: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005299 Mutex::Autolock _l(mStateLock);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005300 // daltonize
5301 n = data.readInt32();
5302 switch (n % 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005303 case 1:
5304 mDaltonizer.setType(ColorBlindnessType::Protanomaly);
5305 break;
5306 case 2:
5307 mDaltonizer.setType(ColorBlindnessType::Deuteranomaly);
5308 break;
5309 case 3:
5310 mDaltonizer.setType(ColorBlindnessType::Tritanomaly);
5311 break;
5312 default:
5313 mDaltonizer.setType(ColorBlindnessType::None);
5314 break;
Mathias Agopianff2ed702013-09-01 21:36:12 -07005315 }
5316 if (n >= 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005317 mDaltonizer.setMode(ColorBlindnessMode::Correction);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005318 } else {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005319 mDaltonizer.setMode(ColorBlindnessMode::Simulation);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005320 }
Chia-I Wu28f320b2018-05-03 11:02:56 -07005321
5322 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005323 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005324 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005325 case 1015: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005326 Mutex::Autolock _l(mStateLock);
Alan Viverette9c5a3332013-09-12 20:04:35 -07005327 // apply a color matrix
5328 n = data.readInt32();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005329 if (n) {
Romain Guy0147a172017-06-01 13:53:56 -07005330 // color matrix is sent as a column-major mat4 matrix
Alan Viverette794c5ba2013-10-03 16:40:52 -07005331 for (size_t i = 0 ; i < 4; i++) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005332 for (size_t j = 0; j < 4; j++) {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005333 mClientColorMatrix[i][j] = data.readFloat();
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005334 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005335 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005336 } else {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005337 mClientColorMatrix = mat4();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005338 }
Romain Guy88d37dd2017-05-26 17:57:05 -07005339
5340 // Check that supplied matrix's last row is {0,0,0,1} so we can avoid
5341 // the division by w in the fragment shader
Chia-I Wu28f320b2018-05-03 11:02:56 -07005342 float4 lastRow(transpose(mClientColorMatrix)[3]);
Romain Guy88d37dd2017-05-26 17:57:05 -07005343 if (any(greaterThan(abs(lastRow - float4{0, 0, 0, 1}), float4{1e-4f}))) {
5344 ALOGE("The color transform's last row must be (0, 0, 0, 1)");
5345 }
5346
Chia-I Wu28f320b2018-05-03 11:02:56 -07005347 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005348 return NO_ERROR;
5349 }
Ruchi Kandoif52b3c82014-04-24 16:42:35 -07005350 // This is an experimental interface
5351 // Needs to be shifted to proper binder interface when we productize
5352 case 1016: {
Andy McFadden645b1f72014-06-10 14:43:32 -07005353 n = data.readInt32();
Ana Krulece588e312018-09-18 12:32:24 -07005354 // TODO(b/113612090): Evaluate if this can be removed.
Ana Krulecc2870422019-01-29 19:00:58 -08005355 mScheduler->setRefreshSkipCount(n);
Ruchi Kandoif52b3c82014-04-24 16:42:35 -07005356 return NO_ERROR;
5357 }
Dan Stozaee44edd2015-03-23 15:50:23 -07005358 case 1017: {
5359 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005360 mForceFullDamage = n != 0;
Dan Stozaee44edd2015-03-23 15:50:23 -07005361 return NO_ERROR;
5362 }
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005363 case 1018: { // Modify Choreographer's phase offset
5364 n = data.readInt32();
Ana Krulecc2870422019-01-29 19:00:58 -08005365 mScheduler->setPhaseOffset(mAppConnectionHandle, static_cast<nsecs_t>(n));
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005366 return NO_ERROR;
5367 }
5368 case 1019: { // Modify SurfaceFlinger's phase offset
5369 n = data.readInt32();
Ana Krulecc2870422019-01-29 19:00:58 -08005370 mScheduler->setPhaseOffset(mSfConnectionHandle, static_cast<nsecs_t>(n));
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005371 return NO_ERROR;
5372 }
Irvel468051e2016-06-13 16:44:44 -07005373 case 1020: { // Layer updates interceptor
5374 n = data.readInt32();
5375 if (n) {
5376 ALOGV("Interceptor enabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08005377 mInterceptor->enable(mDrawingState.layersSortedByZ, mDrawingState.displays);
Irvel468051e2016-06-13 16:44:44 -07005378 }
5379 else{
5380 ALOGV("Interceptor disabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08005381 mInterceptor->disable();
Irvel468051e2016-06-13 16:44:44 -07005382 }
5383 return NO_ERROR;
5384 }
Dan Stoza8cf150a2016-08-02 10:27:31 -07005385 case 1021: { // Disable HWC virtual displays
5386 n = data.readInt32();
5387 mUseHwcVirtualDisplays = !n;
5388 return NO_ERROR;
5389 }
Romain Guy0147a172017-06-01 13:53:56 -07005390 case 1022: { // Set saturation boost
Chia-I Wu28f320b2018-05-03 11:02:56 -07005391 Mutex::Autolock _l(mStateLock);
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005392 mGlobalSaturationFactor = std::max(0.0f, std::min(data.readFloat(), 2.0f));
Romain Guy0147a172017-06-01 13:53:56 -07005393
Chia-I Wu28f320b2018-05-03 11:02:56 -07005394 updateColorMatrixLocked();
Romain Guy0147a172017-06-01 13:53:56 -07005395 return NO_ERROR;
5396 }
Romain Guy54f154a2017-10-24 21:40:32 +01005397 case 1023: { // Set native mode
Daniel Solomon7c7ede22019-07-11 16:35:40 -07005398 int32_t colorMode;
5399
Chia-I Wu0d711262018-05-21 15:19:35 -07005400 mDisplayColorSetting = static_cast<DisplayColorSetting>(data.readInt32());
Daniel Solomon7c7ede22019-07-11 16:35:40 -07005401 if (data.readInt32(&colorMode) == NO_ERROR) {
5402 mForceColorMode = static_cast<ColorMode>(colorMode);
5403 }
Romain Guy54f154a2017-10-24 21:40:32 +01005404 invalidateHwcGeometry();
5405 repaintEverything();
5406 return NO_ERROR;
5407 }
Peiyong Lin4bac91c2018-10-25 09:48:33 -07005408 // Deprecate, use 1030 to check whether the device is color managed.
5409 case 1024: {
5410 return NAME_NOT_FOUND;
Romain Guy54f154a2017-10-24 21:40:32 +01005411 }
Vishnu Nair87704c92018-01-08 15:32:57 -08005412 case 1025: { // Set layer tracing
Adrian Roos1e1a1282017-11-01 19:05:31 +01005413 n = data.readInt32();
5414 if (n) {
Yichi Chenadc69612018-09-15 14:51:18 +08005415 ALOGD("LayerTracing enabled");
Nataniel Borges2b796da2019-02-15 13:32:18 -08005416 Mutex::Autolock lock(mStateLock);
5417 mTracingEnabledChanged = true;
Adrian Roos1e1a1282017-11-01 19:05:31 +01005418 mTracing.enable();
Adrian Roos1e1a1282017-11-01 19:05:31 +01005419 reply->writeInt32(NO_ERROR);
5420 } else {
Yichi Chenadc69612018-09-15 14:51:18 +08005421 ALOGD("LayerTracing disabled");
Nataniel Borges2b796da2019-02-15 13:32:18 -08005422 bool writeFile = false;
5423 {
5424 Mutex::Autolock lock(mStateLock);
5425 mTracingEnabledChanged = true;
5426 writeFile = mTracing.disable();
5427 }
5428
5429 if (writeFile) {
5430 reply->writeInt32(mTracing.writeToFile());
5431 } else {
5432 reply->writeInt32(NO_ERROR);
5433 }
Adrian Roos1e1a1282017-11-01 19:05:31 +01005434 }
5435 return NO_ERROR;
5436 }
Vishnu Nair87704c92018-01-08 15:32:57 -08005437 case 1026: { // Get layer tracing status
5438 reply->writeBool(mTracing.isEnabled());
5439 return NO_ERROR;
5440 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005441 // Is a DisplayColorSetting supported?
5442 case 1027: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005443 const auto display = getDefaultDisplayDevice();
5444 if (!display) {
Chia-I Wu0d711262018-05-21 15:19:35 -07005445 return NAME_NOT_FOUND;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005446 }
Chia-I Wu0d711262018-05-21 15:19:35 -07005447
5448 DisplayColorSetting setting = static_cast<DisplayColorSetting>(data.readInt32());
5449 switch (setting) {
5450 case DisplayColorSetting::MANAGED:
Peiyong Lin13effd12018-07-24 17:01:47 -07005451 reply->writeBool(useColorManagement);
Chia-I Wu0d711262018-05-21 15:19:35 -07005452 break;
5453 case DisplayColorSetting::UNMANAGED:
5454 reply->writeBool(true);
5455 break;
5456 case DisplayColorSetting::ENHANCED:
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005457 reply->writeBool(display->hasRenderIntent(RenderIntent::ENHANCE));
Chia-I Wu0d711262018-05-21 15:19:35 -07005458 break;
5459 default: // vendor display color setting
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005460 reply->writeBool(
5461 display->hasRenderIntent(static_cast<RenderIntent>(setting)));
Chia-I Wu0d711262018-05-21 15:19:35 -07005462 break;
5463 }
5464 return NO_ERROR;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005465 }
Steven Thomas97f1f4c2018-06-01 12:04:16 -07005466 // Is VrFlinger active?
5467 case 1028: {
5468 Mutex::Autolock _l(mStateLock);
Lloyd Pique441d5042018-10-18 16:49:51 -07005469 reply->writeBool(getHwComposer().isUsingVrComposer());
Steven Thomas97f1f4c2018-06-01 12:04:16 -07005470 return NO_ERROR;
5471 }
Nataniel Borges2b796da2019-02-15 13:32:18 -08005472 // Set buffer size for SF tracing (value in KB)
5473 case 1029: {
5474 n = data.readInt32();
5475 if (n <= 0 || n > MAX_TRACING_MEMORY) {
5476 ALOGW("Invalid buffer size: %d KB", n);
5477 reply->writeInt32(BAD_VALUE);
5478 return BAD_VALUE;
5479 }
5480
5481 ALOGD("Updating trace buffer to %d KB", n);
5482 mTracing.setBufferSize(n * 1024);
5483 reply->writeInt32(NO_ERROR);
5484 return NO_ERROR;
5485 }
Peiyong Lin13effd12018-07-24 17:01:47 -07005486 // Is device color managed?
5487 case 1030: {
5488 reply->writeBool(useColorManagement);
5489 return NO_ERROR;
5490 }
Peiyong Lin9d846a52018-11-05 13:18:20 -08005491 // Override default composition data space
5492 // adb shell service call SurfaceFlinger 1031 i32 1 DATASPACE_NUMBER DATASPACE_NUMBER \
5493 // && adb shell stop zygote && adb shell start zygote
5494 // to restore: adb shell service call SurfaceFlinger 1031 i32 0 && \
5495 // adb shell stop zygote && adb shell start zygote
5496 case 1031: {
5497 Mutex::Autolock _l(mStateLock);
5498 n = data.readInt32();
5499 if (n) {
5500 n = data.readInt32();
5501 if (n) {
5502 Dataspace dataspace = static_cast<Dataspace>(n);
5503 if (!validateCompositionDataspace(dataspace)) {
5504 return BAD_VALUE;
5505 }
5506 mDefaultCompositionDataspace = dataspace;
5507 }
5508 n = data.readInt32();
5509 if (n) {
5510 Dataspace dataspace = static_cast<Dataspace>(n);
5511 if (!validateCompositionDataspace(dataspace)) {
5512 return BAD_VALUE;
5513 }
5514 mWideColorGamutCompositionDataspace = dataspace;
5515 }
5516 } else {
5517 // restore composition data space.
5518 mDefaultCompositionDataspace = defaultCompositionDataspace;
5519 mWideColorGamutCompositionDataspace = wideColorGamutCompositionDataspace;
5520 }
5521 return NO_ERROR;
5522 }
Vishnu Nair9245d3b2019-03-22 13:38:56 -07005523 // Set trace flags
5524 case 1033: {
5525 n = data.readUint32();
5526 ALOGD("Updating trace flags to 0x%x", n);
5527 mTracing.setTraceFlags(n);
5528 reply->writeInt32(NO_ERROR);
5529 return NO_ERROR;
5530 }
Ady Abraham03b02dd2019-03-21 15:40:11 -07005531 case 1034: {
5532 // TODO(b/129297325): expose this via developer menu option
5533 n = data.readInt32();
5534 if (n && !mRefreshRateOverlay) {
Ady Abrahamfed164b2019-05-10 17:12:54 -07005535 RefreshRateType type;
5536 {
5537 std::lock_guard<std::mutex> lock(mActiveConfigLock);
5538 type = mDesiredActiveConfig.type;
5539 }
Ady Abraham03b02dd2019-03-21 15:40:11 -07005540 mRefreshRateOverlay = std::make_unique<RefreshRateOverlay>(*this);
Ady Abrahamfed164b2019-05-10 17:12:54 -07005541 mRefreshRateOverlay->changeRefreshRate(type);
Ady Abraham03b02dd2019-03-21 15:40:11 -07005542 } else if (!n) {
5543 mRefreshRateOverlay.reset();
5544 }
5545 return NO_ERROR;
5546 }
Ady Abraham34392f72019-04-10 11:29:27 -07005547 case 1035: {
5548 n = data.readInt32();
5549 mDebugDisplayConfigSetByBackdoor = false;
5550 if (n >= 0) {
5551 const auto displayToken = getInternalDisplayToken();
5552 status_t result = setAllowedDisplayConfigs(displayToken, {n});
5553 if (result != NO_ERROR) {
5554 return result;
5555 }
5556 mDebugDisplayConfigSetByBackdoor = true;
5557 }
5558 return NO_ERROR;
5559 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005560 }
5561 }
5562 return err;
5563}
5564
Steven Thomas6d8110b2017-08-31 18:24:21 -07005565void SurfaceFlinger::repaintEverything() {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07005566 mRepaintEverything = true;
Dan Stozac7a25ad2018-04-12 11:45:09 -07005567 signalTransaction();
Steven Thomas6d8110b2017-08-31 18:24:21 -07005568}
5569
Ana Krulec7d1d6832018-12-27 11:10:09 -08005570void SurfaceFlinger::repaintEverythingForHWC() {
5571 mRepaintEverything = true;
Ady Abraham8532d012019-05-08 14:50:56 -07005572 mEventQueue->invalidate();
Ana Krulec7d1d6832018-12-27 11:10:09 -08005573}
5574
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005575// A simple RAII class to disconnect from an ANativeWindow* when it goes out of scope
5576class WindowDisconnector {
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005577public:
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005578 WindowDisconnector(ANativeWindow* window, int api) : mWindow(window), mApi(api) {}
5579 ~WindowDisconnector() {
5580 native_window_api_disconnect(mWindow, mApi);
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005581 }
5582
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005583private:
5584 ANativeWindow* mWindow;
5585 const int mApi;
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005586};
5587
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005588status_t SurfaceFlinger::captureScreen(const sp<IBinder>& displayToken,
Robert Carr108b2c72019-04-02 16:32:58 -07005589 sp<GraphicBuffer>* outBuffer, bool& outCapturedSecureLayers,
5590 const Dataspace reqDataspace,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005591 const ui::PixelFormat reqPixelFormat, Rect sourceCrop,
chaviw0e3479f2018-09-10 16:49:30 -07005592 uint32_t reqWidth, uint32_t reqHeight,
5593 bool useIdentityTransform,
Robert Carrfa8855f2019-02-19 10:05:00 -08005594 ISurfaceComposer::Rotation rotation,
5595 bool captureSecureLayers) {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005596 ATRACE_CALL();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005597
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005598 if (!displayToken) return BAD_VALUE;
chaviwa76b2712017-09-20 12:02:26 -07005599
Chia-I Wuc80dcbb2018-08-24 15:34:02 -07005600 auto renderAreaRotation = fromSurfaceComposerRotation(rotation);
5601
Chia-I Wu20261cb2018-08-23 12:55:44 -07005602 sp<DisplayDevice> display;
5603 {
5604 Mutex::Autolock _l(mStateLock);
Garfield Tan3b1b8af2018-03-16 17:37:33 -07005605
Chia-I Wu20261cb2018-08-23 12:55:44 -07005606 display = getDisplayDeviceLocked(displayToken);
5607 if (!display) return BAD_VALUE;
5608
Chia-I Wucb023152018-08-28 12:57:23 -07005609 // set the requested width/height to the logical display viewport size
5610 // by default
5611 if (reqWidth == 0 || reqHeight == 0) {
5612 reqWidth = uint32_t(display->getViewport().width());
5613 reqHeight = uint32_t(display->getViewport().height());
Chia-I Wu20261cb2018-08-23 12:55:44 -07005614 }
Yiwei Zhang06a58e22018-08-20 16:42:23 -07005615 }
5616
Peiyong Lin0e003c92018-09-17 11:09:51 -07005617 DisplayRenderArea renderArea(display, sourceCrop, reqWidth, reqHeight, reqDataspace,
Robert Carrfa8855f2019-02-19 10:05:00 -08005618 renderAreaRotation, captureSecureLayers);
chaviwa76b2712017-09-20 12:02:26 -07005619
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08005620 auto traverseLayers = std::bind(&SurfaceFlinger::traverseLayersInDisplay, this, display,
5621 std::placeholders::_1);
Peiyong Lin0e003c92018-09-17 11:09:51 -07005622 return captureScreenCommon(renderArea, traverseLayers, outBuffer, reqPixelFormat,
Robert Carr108b2c72019-04-02 16:32:58 -07005623 useIdentityTransform, outCapturedSecureLayers);
chaviwa76b2712017-09-20 12:02:26 -07005624}
5625
chaviw93df2ea2019-04-30 16:45:12 -07005626static Dataspace pickDataspaceFromColorMode(const ColorMode colorMode) {
5627 switch (colorMode) {
5628 case ColorMode::DISPLAY_P3:
5629 case ColorMode::BT2100_PQ:
5630 case ColorMode::BT2100_HLG:
5631 case ColorMode::DISPLAY_BT2020:
5632 return Dataspace::DISPLAY_P3;
5633 default:
5634 return Dataspace::V0_SRGB;
5635 }
5636}
5637
5638const sp<DisplayDevice> SurfaceFlinger::getDisplayByIdOrLayerStack(uint64_t displayOrLayerStack) {
5639 const sp<IBinder> displayToken = getPhysicalDisplayTokenLocked(DisplayId{displayOrLayerStack});
5640 if (displayToken) {
5641 return getDisplayDeviceLocked(displayToken);
5642 }
5643 // Couldn't find display by displayId. Try to get display by layerStack since virtual displays
5644 // may not have a displayId.
5645 for (const auto& [token, display] : mDisplays) {
5646 if (display->getLayerStack() == displayOrLayerStack) {
5647 return display;
5648 }
5649 }
5650 return nullptr;
5651}
5652
5653status_t SurfaceFlinger::captureScreen(uint64_t displayOrLayerStack, Dataspace* outDataspace,
5654 sp<GraphicBuffer>* outBuffer) {
5655 sp<DisplayDevice> display;
5656 uint32_t width;
5657 uint32_t height;
5658 ui::Transform::orientation_flags captureOrientation;
5659 {
5660 Mutex::Autolock _l(mStateLock);
5661 display = getDisplayByIdOrLayerStack(displayOrLayerStack);
5662 if (!display) {
5663 return BAD_VALUE;
5664 }
5665
5666 width = uint32_t(display->getViewport().width());
5667 height = uint32_t(display->getViewport().height());
5668
5669 captureOrientation = fromSurfaceComposerRotation(
5670 static_cast<ISurfaceComposer::Rotation>(display->getOrientation()));
Alec Mouri21fab752019-06-20 14:12:17 -07005671 if (captureOrientation == ui::Transform::orientation_flags::ROT_90) {
5672 captureOrientation = ui::Transform::orientation_flags::ROT_270;
5673 } else if (captureOrientation == ui::Transform::orientation_flags::ROT_270) {
5674 captureOrientation = ui::Transform::orientation_flags::ROT_90;
5675 }
chaviw93df2ea2019-04-30 16:45:12 -07005676 *outDataspace =
5677 pickDataspaceFromColorMode(display->getCompositionDisplay()->getState().colorMode);
5678 }
5679
5680 DisplayRenderArea renderArea(display, Rect(), width, height, *outDataspace, captureOrientation,
5681 false /* captureSecureLayers */);
5682
5683 auto traverseLayers = std::bind(&SurfaceFlinger::traverseLayersInDisplay, this, display,
5684 std::placeholders::_1);
5685 bool ignored = false;
5686 return captureScreenCommon(renderArea, traverseLayers, outBuffer, ui::PixelFormat::RGBA_8888,
5687 false /* useIdentityTransform */,
5688 ignored /* outCapturedSecureLayers */);
5689}
5690
Robert Carr866455f2019-04-02 16:28:26 -07005691status_t SurfaceFlinger::captureLayers(
5692 const sp<IBinder>& layerHandleBinder, sp<GraphicBuffer>* outBuffer,
5693 const Dataspace reqDataspace, const ui::PixelFormat reqPixelFormat, const Rect& sourceCrop,
5694 const std::unordered_set<sp<IBinder>, ISurfaceComposer::SpHash<IBinder>>& excludeHandles,
5695 float frameScale, bool childrenOnly) {
chaviwa76b2712017-09-20 12:02:26 -07005696 ATRACE_CALL();
5697
5698 class LayerRenderArea : public RenderArea {
5699 public:
Robert Carr578038f2018-03-09 12:25:24 -08005700 LayerRenderArea(SurfaceFlinger* flinger, const sp<Layer>& layer, const Rect crop,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005701 int32_t reqWidth, int32_t reqHeight, Dataspace reqDataSpace,
5702 bool childrenOnly)
5703 : RenderArea(reqWidth, reqHeight, CaptureFill::CLEAR, reqDataSpace),
Robert Carr578038f2018-03-09 12:25:24 -08005704 mLayer(layer),
5705 mCrop(crop),
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005706 mNeedsFiltering(false),
Robert Carr578038f2018-03-09 12:25:24 -08005707 mFlinger(flinger),
5708 mChildrenOnly(childrenOnly) {}
Peiyong Linefefaac2018-08-17 12:27:51 -07005709 const ui::Transform& getTransform() const override { return mTransform; }
Lloyd Pique0449b0f2018-12-20 16:23:45 -08005710 Rect getBounds() const override {
5711 const Layer::State& layerState(mLayer->getDrawingState());
5712 return mLayer->getBufferSize(layerState);
5713 }
Marissa Wall61c58622018-07-18 10:12:20 -07005714 int getHeight() const override {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08005715 return mLayer->getBufferSize(mLayer->getDrawingState()).getHeight();
Marissa Wall61c58622018-07-18 10:12:20 -07005716 }
Vishnu Nair88a11f22018-11-28 18:30:57 -08005717 int getWidth() const override {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08005718 return mLayer->getBufferSize(mLayer->getDrawingState()).getWidth();
Vishnu Nair88a11f22018-11-28 18:30:57 -08005719 }
chaviwa76b2712017-09-20 12:02:26 -07005720 bool isSecure() const override { return false; }
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005721 bool needsFiltering() const override { return mNeedsFiltering; }
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08005722 const sp<const DisplayDevice> getDisplayDevice() const override { return nullptr; }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005723 Rect getSourceCrop() const override {
5724 if (mCrop.isEmpty()) {
5725 return getBounds();
5726 } else {
5727 return mCrop;
5728 }
5729 }
Robert Carr578038f2018-03-09 12:25:24 -08005730 class ReparentForDrawing {
5731 public:
5732 const sp<Layer>& oldParent;
5733 const sp<Layer>& newParent;
5734
Vishnu Nair4351ad52019-02-11 14:13:02 -08005735 ReparentForDrawing(const sp<Layer>& oldParent, const sp<Layer>& newParent,
5736 const Rect& drawingBounds)
Robert Carr578038f2018-03-09 12:25:24 -08005737 : oldParent(oldParent), newParent(newParent) {
Vishnu Nair4351ad52019-02-11 14:13:02 -08005738 // Compute and cache the bounds for the new parent layer.
5739 newParent->computeBounds(drawingBounds.toFloatRect(), ui::Transform());
Robert Carr15eae092018-03-23 13:43:53 -07005740 oldParent->setChildrenDrawingParent(newParent);
Robert Carr578038f2018-03-09 12:25:24 -08005741 }
Vishnu Nairbce6ffd2019-02-14 10:58:59 -08005742 ~ReparentForDrawing() { oldParent->setChildrenDrawingParent(oldParent); }
Robert Carr578038f2018-03-09 12:25:24 -08005743 };
5744
5745 void render(std::function<void()> drawLayers) override {
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005746 const Rect sourceCrop = getSourceCrop();
5747 // no need to check rotation because there is none
5748 mNeedsFiltering = sourceCrop.width() != getReqWidth() ||
5749 sourceCrop.height() != getReqHeight();
5750
Robert Carr578038f2018-03-09 12:25:24 -08005751 if (!mChildrenOnly) {
5752 mTransform = mLayer->getTransform().inverse();
5753 drawLayers();
5754 } else {
5755 Rect bounds = getBounds();
Lloyd Pique90c115d2018-09-18 21:39:42 -07005756 screenshotParentLayer = mFlinger->getFactory().createContainerLayer(
Lloyd Pique42ab75e2018-09-12 20:46:03 -07005757 LayerCreationArgs(mFlinger, nullptr, String8("Screenshot Parent"),
Evan Roskya1f1e152019-01-24 16:17:46 -08005758 bounds.getWidth(), bounds.getHeight(), 0,
5759 LayerMetadata()));
Robert Carr578038f2018-03-09 12:25:24 -08005760
Vishnu Nair4351ad52019-02-11 14:13:02 -08005761 ReparentForDrawing reparent(mLayer, screenshotParentLayer, sourceCrop);
Robert Carr578038f2018-03-09 12:25:24 -08005762 drawLayers();
5763 }
5764 }
chaviwa76b2712017-09-20 12:02:26 -07005765
chaviwa76b2712017-09-20 12:02:26 -07005766 private:
chaviw7206d492017-11-10 16:16:12 -08005767 const sp<Layer> mLayer;
5768 const Rect mCrop;
Robert Carr578038f2018-03-09 12:25:24 -08005769
5770 // In the "childrenOnly" case we reparent the children to a screenshot
5771 // layer which has no properties set and which does not draw.
5772 sp<ContainerLayer> screenshotParentLayer;
Peiyong Linefefaac2018-08-17 12:27:51 -07005773 ui::Transform mTransform;
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005774 bool mNeedsFiltering;
Robert Carr578038f2018-03-09 12:25:24 -08005775
5776 SurfaceFlinger* mFlinger;
5777 const bool mChildrenOnly;
chaviwa76b2712017-09-20 12:02:26 -07005778 };
5779
Robert Carrc0df3122019-04-11 13:18:21 -07005780 int reqWidth = 0;
5781 int reqHeight = 0;
5782 sp<Layer> parent;
chaviw7206d492017-11-10 16:16:12 -08005783 Rect crop(sourceCrop);
Robert Carrc0df3122019-04-11 13:18:21 -07005784 std::unordered_set<sp<Layer>, ISurfaceComposer::SpHash<Layer>> excludeLayers;
chaviw7206d492017-11-10 16:16:12 -08005785
Robert Carrc0df3122019-04-11 13:18:21 -07005786 {
5787 Mutex::Autolock _l(mStateLock);
chaviw7206d492017-11-10 16:16:12 -08005788
Robert Carrc0df3122019-04-11 13:18:21 -07005789 parent = fromHandle(layerHandleBinder);
5790 if (parent == nullptr || parent->isRemovedFromCurrentState()) {
5791 ALOGE("captureLayers called with an invalid or removed parent");
5792 return NAME_NOT_FOUND;
5793 }
5794
5795 const int uid = IPCThreadState::self()->getCallingUid();
5796 const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
5797 if (!forSystem && parent->getCurrentState().flags & layer_state_t::eLayerSecure) {
5798 ALOGW("Attempting to capture secure layer: PERMISSION_DENIED");
5799 return PERMISSION_DENIED;
5800 }
5801
5802 if (sourceCrop.width() <= 0) {
5803 crop.left = 0;
5804 crop.right = parent->getBufferSize(parent->getCurrentState()).getWidth();
5805 }
5806
5807 if (sourceCrop.height() <= 0) {
5808 crop.top = 0;
5809 crop.bottom = parent->getBufferSize(parent->getCurrentState()).getHeight();
5810 }
5811 reqWidth = crop.width() * frameScale;
5812 reqHeight = crop.height() * frameScale;
5813
5814 for (const auto& handle : excludeHandles) {
5815 sp<Layer> excludeLayer = fromHandle(handle);
5816 if (excludeLayer != nullptr) {
5817 excludeLayers.emplace(excludeLayer);
5818 } else {
5819 ALOGW("Invalid layer handle passed as excludeLayer to captureLayers");
5820 return NAME_NOT_FOUND;
5821 }
5822 }
5823 } // mStateLock
chaviw7206d492017-11-10 16:16:12 -08005824
Chia-I Wu20261cb2018-08-23 12:55:44 -07005825 // really small crop or frameScale
5826 if (reqWidth <= 0) {
5827 reqWidth = 1;
5828 }
5829 if (reqHeight <= 0) {
5830 reqHeight = 1;
5831 }
5832
Robert Carr866455f2019-04-02 16:28:26 -07005833 LayerRenderArea renderArea(this, parent, crop, reqWidth, reqHeight, reqDataspace, childrenOnly);
5834 auto traverseLayers = [parent, childrenOnly,
5835 &excludeLayers](const LayerVector::Visitor& visitor) {
chaviwa76b2712017-09-20 12:02:26 -07005836 parent->traverseChildrenInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
5837 if (!layer->isVisible()) {
5838 return;
Robert Carr578038f2018-03-09 12:25:24 -08005839 } else if (childrenOnly && layer == parent.get()) {
5840 return;
chaviwa76b2712017-09-20 12:02:26 -07005841 }
Robert Carr866455f2019-04-02 16:28:26 -07005842
5843 sp<Layer> p = layer;
5844 while (p != nullptr) {
5845 if (excludeLayers.count(p) != 0) {
5846 return;
5847 }
5848 p = p->getParent();
5849 }
5850
chaviwa76b2712017-09-20 12:02:26 -07005851 visitor(layer);
5852 });
5853 };
Robert Carr108b2c72019-04-02 16:32:58 -07005854
5855 bool outCapturedSecureLayers = false;
5856 return captureScreenCommon(renderArea, traverseLayers, outBuffer, reqPixelFormat, false,
5857 outCapturedSecureLayers);
chaviwa76b2712017-09-20 12:02:26 -07005858}
5859
5860status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea,
5861 TraverseLayersFunction traverseLayers,
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005862 sp<GraphicBuffer>* outBuffer,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005863 const ui::PixelFormat reqPixelFormat,
Robert Carr108b2c72019-04-02 16:32:58 -07005864 bool useIdentityTransform,
5865 bool& outCapturedSecureLayers) {
chaviwa76b2712017-09-20 12:02:26 -07005866 ATRACE_CALL();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005867
Peiyong Lin0e003c92018-09-17 11:09:51 -07005868 // TODO(b/116112787) Make buffer usage a parameter.
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005869 const uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
5870 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
Lloyd Pique90c115d2018-09-18 21:39:42 -07005871 *outBuffer =
5872 getFactory().createGraphicBuffer(renderArea.getReqWidth(), renderArea.getReqHeight(),
5873 static_cast<android_pixel_format>(reqPixelFormat), 1,
5874 usage, "screenshot");
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005875
Robert Carr108b2c72019-04-02 16:32:58 -07005876 return captureScreenCommon(renderArea, traverseLayers, *outBuffer, useIdentityTransform,
5877 outCapturedSecureLayers);
Dan Stozaec460082018-12-17 15:35:09 -08005878}
5879
Kevin DuBois7cbcc372019-02-25 14:53:28 -08005880status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea,
5881 TraverseLayersFunction traverseLayers,
5882 const sp<GraphicBuffer>& buffer,
Robert Carr108b2c72019-04-02 16:32:58 -07005883 bool useIdentityTransform,
5884 bool& outCapturedSecureLayers) {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005885 // This mutex protects syncFd and captureResult for communication of the return values from the
5886 // main thread back to this Binder thread
5887 std::mutex captureMutex;
5888 std::condition_variable captureCondition;
5889 std::unique_lock<std::mutex> captureLock(captureMutex);
5890 int syncFd = -1;
5891 std::optional<status_t> captureResult;
5892
Robert Carr03480e22018-01-04 16:02:06 -08005893 const int uid = IPCThreadState::self()->getCallingUid();
5894 const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
5895
Dominik Laskowski8c001672018-05-30 16:52:06 -07005896 sp<LambdaMessage> message = new LambdaMessage([&] {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005897 // If there is a refresh pending, bug out early and tell the binder thread to try again
5898 // after the refresh.
5899 if (mRefreshPending) {
5900 ATRACE_NAME("Skipping screenshot for now");
5901 std::unique_lock<std::mutex> captureLock(captureMutex);
5902 captureResult = std::make_optional<status_t>(EAGAIN);
5903 captureCondition.notify_one();
5904 return;
5905 }
5906
5907 status_t result = NO_ERROR;
5908 int fd = -1;
5909 {
5910 Mutex::Autolock _l(mStateLock);
Dominik Laskowski8c001672018-05-30 16:52:06 -07005911 renderArea.render([&] {
Dan Stozaec460082018-12-17 15:35:09 -08005912 result = captureScreenImplLocked(renderArea, traverseLayers, buffer.get(),
Robert Carr108b2c72019-04-02 16:32:58 -07005913 useIdentityTransform, forSystem, &fd,
5914 outCapturedSecureLayers);
Robert Carr578038f2018-03-09 12:25:24 -08005915 });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005916 }
5917
5918 {
5919 std::unique_lock<std::mutex> captureLock(captureMutex);
5920 syncFd = fd;
5921 captureResult = std::make_optional<status_t>(result);
5922 captureCondition.notify_one();
5923 }
5924 });
5925
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005926 status_t result = postMessageAsync(message);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005927 if (result == NO_ERROR) {
Dominik Laskowski8c001672018-05-30 16:52:06 -07005928 captureCondition.wait(captureLock, [&] { return captureResult; });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005929 while (*captureResult == EAGAIN) {
5930 captureResult.reset();
5931 result = postMessageAsync(message);
5932 if (result != NO_ERROR) {
5933 return result;
5934 }
Dominik Laskowski8c001672018-05-30 16:52:06 -07005935 captureCondition.wait(captureLock, [&] { return captureResult; });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005936 }
5937 result = *captureResult;
5938 }
5939
5940 if (result == NO_ERROR) {
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005941 sync_wait(syncFd, -1);
5942 close(syncFd);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005943 }
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005944
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005945 return result;
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005946}
5947
chaviwa76b2712017-09-20 12:02:26 -07005948void SurfaceFlinger::renderScreenImplLocked(const RenderArea& renderArea,
Chia-I Wu1be50b52018-08-29 10:44:48 -07005949 TraverseLayersFunction traverseLayers,
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005950 ANativeWindowBuffer* buffer, bool useIdentityTransform,
5951 int* outSyncFd) {
Mathias Agopian180f10d2013-04-10 22:55:41 -07005952 ATRACE_CALL();
chaviwa76b2712017-09-20 12:02:26 -07005953
chaviwa76b2712017-09-20 12:02:26 -07005954 const auto reqWidth = renderArea.getReqWidth();
5955 const auto reqHeight = renderArea.getReqHeight();
Chia-I Wuf2aa3112018-08-27 14:54:37 -07005956 const auto rotation = renderArea.getRotationFlags();
Alec Mouriadb75f42019-03-28 21:42:24 -07005957 const auto transform = renderArea.getTransform();
5958 const auto sourceCrop = renderArea.getSourceCrop();
Dan Stozac1879002014-05-22 15:59:05 -07005959
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005960 renderengine::DisplaySettings clientCompositionDisplay;
5961 std::vector<renderengine::LayerSettings> clientCompositionLayers;
Romain Guy88d37dd2017-05-26 17:57:05 -07005962
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005963 // assume that bounds are never offset, and that they are the same as the
5964 // buffer bounds.
5965 clientCompositionDisplay.physicalDisplay = Rect(reqWidth, reqHeight);
Alec Mouriadb75f42019-03-28 21:42:24 -07005966 clientCompositionDisplay.clip = sourceCrop;
Lloyd Pique7e06e7f2019-03-15 18:36:44 -07005967 clientCompositionDisplay.globalTransform = transform.asMatrix4();
Alec Mouriadb75f42019-03-28 21:42:24 -07005968
5969 // Now take into account the rotation flag. We append a transform that
5970 // rotates the layer stack about the origin, then translate by buffer
5971 // boundaries to be in the right quadrant.
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005972 mat4 rotMatrix;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005973 int displacementX = 0;
5974 int displacementY = 0;
5975 float rot90InRadians = 2.0f * static_cast<float>(M_PI) / 4.0f;
5976 switch (rotation) {
5977 case ui::Transform::ROT_90:
5978 rotMatrix = mat4::rotate(rot90InRadians, vec3(0, 0, 1));
Alec Mouriadb75f42019-03-28 21:42:24 -07005979 displacementX = renderArea.getBounds().getHeight();
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005980 break;
5981 case ui::Transform::ROT_180:
5982 rotMatrix = mat4::rotate(rot90InRadians * 2.0f, vec3(0, 0, 1));
Alec Mouriadb75f42019-03-28 21:42:24 -07005983 displacementY = renderArea.getBounds().getWidth();
5984 displacementX = renderArea.getBounds().getHeight();
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005985 break;
5986 case ui::Transform::ROT_270:
5987 rotMatrix = mat4::rotate(rot90InRadians * 3.0f, vec3(0, 0, 1));
Alec Mouriadb75f42019-03-28 21:42:24 -07005988 displacementY = renderArea.getBounds().getWidth();
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005989 break;
5990 default:
5991 break;
5992 }
Alec Mouriadb75f42019-03-28 21:42:24 -07005993
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005994 // We need to transform the clipping window into the right spot.
5995 // First, rotate the clipping rectangle by the rotation hint to get the
5996 // right orientation
5997 const vec4 clipTL = vec4(sourceCrop.left, sourceCrop.top, 0, 1);
5998 const vec4 clipBR = vec4(sourceCrop.right, sourceCrop.bottom, 0, 1);
5999 const vec4 rotClipTL = rotMatrix * clipTL;
6000 const vec4 rotClipBR = rotMatrix * clipBR;
6001 const int newClipLeft = std::min(rotClipTL[0], rotClipBR[0]);
6002 const int newClipTop = std::min(rotClipTL[1], rotClipBR[1]);
6003 const int newClipRight = std::max(rotClipTL[0], rotClipBR[0]);
6004 const int newClipBottom = std::max(rotClipTL[1], rotClipBR[1]);
6005
6006 // Now reposition the clipping rectangle with the displacement vector
6007 // computed above.
6008 const mat4 displacementMat = mat4::translate(vec4(displacementX, displacementY, 0, 1));
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006009 clientCompositionDisplay.clip =
6010 Rect(newClipLeft + displacementX, newClipTop + displacementY,
6011 newClipRight + displacementX, newClipBottom + displacementY);
6012
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006013 mat4 clipTransform = displacementMat * rotMatrix;
Alec Mouriadb75f42019-03-28 21:42:24 -07006014 clientCompositionDisplay.globalTransform =
6015 clipTransform * clientCompositionDisplay.globalTransform;
6016
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006017 clientCompositionDisplay.outputDataspace = renderArea.getReqDataSpace();
6018 clientCompositionDisplay.maxLuminance = DisplayDevice::sDefaultMaxLumiance;
Mathias Agopian180f10d2013-04-10 22:55:41 -07006019
chaviw50da5042018-04-09 13:49:37 -07006020 const float alpha = RenderArea::getCaptureFillValue(renderArea.getCaptureFill());
Mathias Agopian180f10d2013-04-10 22:55:41 -07006021
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006022 renderengine::LayerSettings fillLayer;
6023 fillLayer.source.buffer.buffer = nullptr;
6024 fillLayer.source.solidColor = half3(0.0, 0.0, 0.0);
6025 fillLayer.geometry.boundaries = FloatRect(0.0, 0.0, 1.0, 1.0);
6026 fillLayer.alpha = half(alpha);
6027 clientCompositionLayers.push_back(fillLayer);
6028
6029 Region clearRegion = Region::INVALID_REGION;
chaviwa76b2712017-09-20 12:02:26 -07006030 traverseLayers([&](Layer* layer) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006031 renderengine::LayerSettings layerSettings;
6032 bool prepared = layer->prepareClientLayer(renderArea, useIdentityTransform, clearRegion,
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08006033 false, layerSettings);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006034 if (prepared) {
6035 clientCompositionLayers.push_back(layerSettings);
6036 }
chaviwa76b2712017-09-20 12:02:26 -07006037 });
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006038
6039 clientCompositionDisplay.clearRegion = clearRegion;
Alec Mouri6338c9d2019-02-07 16:57:51 -08006040 // Use an empty fence for the buffer fence, since we just created the buffer so
6041 // there is no need for synchronization with the GPU.
6042 base::unique_fd bufferFence;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006043 base::unique_fd drawFence;
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08006044 getRenderEngine().useProtectedContext(false);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006045 getRenderEngine().drawLayers(clientCompositionDisplay, clientCompositionLayers, buffer,
Alec Mourife0d72b2019-03-21 14:05:56 -07006046 /*useFramebufferCache=*/false, std::move(bufferFence), &drawFence);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006047
6048 *outSyncFd = drawFence.release();
Mathias Agopian180f10d2013-04-10 22:55:41 -07006049}
6050
chaviwa76b2712017-09-20 12:02:26 -07006051status_t SurfaceFlinger::captureScreenImplLocked(const RenderArea& renderArea,
6052 TraverseLayersFunction traverseLayers,
6053 ANativeWindowBuffer* buffer,
Robert Carr108b2c72019-04-02 16:32:58 -07006054 bool useIdentityTransform, bool forSystem,
6055 int* outSyncFd, bool& outCapturedSecureLayers) {
Mathias Agopian2a9fc492013-03-01 13:42:57 -08006056 ATRACE_CALL();
6057
chaviwa76b2712017-09-20 12:02:26 -07006058 traverseLayers([&](Layer* layer) {
Robert Carr108b2c72019-04-02 16:32:58 -07006059 outCapturedSecureLayers =
6060 outCapturedSecureLayers || (layer->isVisible() && layer->isSecure());
chaviwa76b2712017-09-20 12:02:26 -07006061 });
Pablo Ceballosb5b35632016-02-23 11:18:51 -08006062
Robert Carr03480e22018-01-04 16:02:06 -08006063 // We allow the system server to take screenshots of secure layers for
6064 // use in situations like the Screen-rotation animation and place
6065 // the impetus on WindowManager to not persist them.
Robert Carr108b2c72019-04-02 16:32:58 -07006066 if (outCapturedSecureLayers && !forSystem) {
Pablo Ceballosb5b35632016-02-23 11:18:51 -08006067 ALOGW("FB is protected: PERMISSION_DENIED");
6068 return PERMISSION_DENIED;
6069 }
Alec Mourie7d1d4a2019-02-05 01:13:46 +00006070 renderScreenImplLocked(renderArea, traverseLayers, buffer, useIdentityTransform, outSyncFd);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07006071 return NO_ERROR;
Mathias Agopian74c40c02010-09-29 13:02:36 -07006072}
6073
chaviw95ef3c42019-02-14 10:55:09 -08006074void SurfaceFlinger::setInputWindowsFinished() {
6075 Mutex::Autolock _l(mStateLock);
6076
6077 mPendingSyncInputWindows = false;
6078 mTransactionCV.broadcast();
6079}
chaviw5f21a5e2019-02-14 10:00:34 -08006080
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07006081// ---------------------------------------------------------------------------
6082
Dan Stoza412903f2017-04-27 13:42:17 -07006083void SurfaceFlinger::State::traverseInZOrder(const LayerVector::Visitor& visitor) const {
6084 layersSortedByZ.traverseInZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07006085}
6086
Dan Stoza412903f2017-04-27 13:42:17 -07006087void SurfaceFlinger::State::traverseInReverseZOrder(const LayerVector::Visitor& visitor) const {
6088 layersSortedByZ.traverseInReverseZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07006089}
6090
Dominik Laskowskieecd6592018-05-29 10:25:41 -07006091void SurfaceFlinger::traverseLayersInDisplay(const sp<const DisplayDevice>& display,
chaviwa76b2712017-09-20 12:02:26 -07006092 const LayerVector::Visitor& visitor) {
6093 // We loop through the first level of layers without traversing,
chaviw0e3479f2018-09-10 16:49:30 -07006094 // as we need to determine which layers belong to the requested display.
chaviwa76b2712017-09-20 12:02:26 -07006095 for (const auto& layer : mDrawingState.layersSortedByZ) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07006096 if (!layer->belongsToDisplay(display->getLayerStack(), false)) {
chaviwa76b2712017-09-20 12:02:26 -07006097 continue;
6098 }
Chia-I Wuec2d9852017-11-21 09:21:01 -08006099 // relative layers are traversed in Layer::traverseInZOrder
chaviwa76b2712017-09-20 12:02:26 -07006100 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07006101 if (!layer->belongsToDisplay(display->getLayerStack(), false)) {
Adrian Roos8acf5a02018-01-17 21:28:19 +01006102 return;
6103 }
chaviwa76b2712017-09-20 12:02:26 -07006104 if (!layer->isVisible()) {
6105 return;
6106 }
6107 visitor(layer);
6108 });
6109 }
6110}
6111
Dominik Laskowski22488f62019-03-28 09:53:04 -07006112void SurfaceFlinger::setAllowedDisplayConfigsInternal(const sp<DisplayDevice>& display,
6113 const std::vector<int32_t>& allowedConfigs) {
6114 if (!display->isPrimary()) {
Ady Abraham838de062019-02-04 10:24:03 -08006115 return;
6116 }
6117
6118 ALOGV("Updating allowed configs");
Dominik Laskowski22488f62019-03-28 09:53:04 -07006119 mAllowedDisplayConfigs = DisplayConfigs(allowedConfigs.begin(), allowedConfigs.end());
Ady Abraham838de062019-02-04 10:24:03 -08006120
Ady Abrahamde3b67b2019-03-25 16:38:10 -07006121 // Set the highest allowed config by iterating backwards on available refresh rates
Dominik Laskowski22488f62019-03-28 09:53:04 -07006122 const auto& refreshRates = mRefreshRateConfigs.getRefreshRates();
Ady Abrahamde3b67b2019-03-25 16:38:10 -07006123 for (auto iter = refreshRates.crbegin(); iter != refreshRates.crend(); ++iter) {
Dominik Laskowski22488f62019-03-28 09:53:04 -07006124 if (iter->second && isDisplayConfigAllowed(iter->second->configId)) {
Ady Abrahamde3b67b2019-03-25 16:38:10 -07006125 ALOGV("switching to config %d", iter->second->configId);
Dominik Laskowski22488f62019-03-28 09:53:04 -07006126 setDesiredActiveConfig(
6127 {iter->first, iter->second->configId, Scheduler::ConfigEvent::Changed});
Ady Abrahamde3b67b2019-03-25 16:38:10 -07006128 break;
Ady Abraham97d04232019-03-05 19:48:12 -08006129 }
6130 }
Ady Abraham838de062019-02-04 10:24:03 -08006131}
6132
Dominik Laskowski22488f62019-03-28 09:53:04 -07006133status_t SurfaceFlinger::setAllowedDisplayConfigs(const sp<IBinder>& displayToken,
Ady Abraham838de062019-02-04 10:24:03 -08006134 const std::vector<int32_t>& allowedConfigs) {
6135 ATRACE_CALL();
6136
Dominik Laskowski22488f62019-03-28 09:53:04 -07006137 if (!displayToken || allowedConfigs.empty()) {
Ady Abraham838de062019-02-04 10:24:03 -08006138 return BAD_VALUE;
6139 }
6140
Ady Abraham34392f72019-04-10 11:29:27 -07006141 if (mDebugDisplayConfigSetByBackdoor) {
6142 // ignore this request as config is overridden by backdoor
6143 return NO_ERROR;
6144 }
6145
Ady Abraham838de062019-02-04 10:24:03 -08006146 postMessageSync(new LambdaMessage([&]() NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowski22488f62019-03-28 09:53:04 -07006147 const auto display = getDisplayDeviceLocked(displayToken);
6148 if (!display) {
6149 ALOGE("Attempt to set allowed display configs for invalid display token %p",
6150 displayToken.get());
6151 } else if (display->isVirtual()) {
6152 ALOGW("Attempt to set allowed display configs for virtual display");
6153 } else {
6154 setAllowedDisplayConfigsInternal(display, allowedConfigs);
6155 }
Ady Abraham838de062019-02-04 10:24:03 -08006156 }));
Dominik Laskowski22488f62019-03-28 09:53:04 -07006157
Ady Abraham838de062019-02-04 10:24:03 -08006158 return NO_ERROR;
6159}
6160
Dominik Laskowski22488f62019-03-28 09:53:04 -07006161status_t SurfaceFlinger::getAllowedDisplayConfigs(const sp<IBinder>& displayToken,
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08006162 std::vector<int32_t>* outAllowedConfigs) {
6163 ATRACE_CALL();
6164
Dominik Laskowski22488f62019-03-28 09:53:04 -07006165 if (!displayToken || !outAllowedConfigs) {
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08006166 return BAD_VALUE;
6167 }
6168
Dominik Laskowski22488f62019-03-28 09:53:04 -07006169 Mutex::Autolock lock(mStateLock);
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08006170
Dominik Laskowski4f1dd8c2019-04-17 15:54:30 -07006171 const auto display = getDisplayDeviceLocked(displayToken);
6172 if (!display) {
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08006173 return NAME_NOT_FOUND;
6174 }
6175
Dominik Laskowski4f1dd8c2019-04-17 15:54:30 -07006176 if (display->isPrimary()) {
6177 outAllowedConfigs->assign(mAllowedDisplayConfigs.begin(), mAllowedDisplayConfigs.end());
6178 }
6179
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08006180 return NO_ERROR;
6181}
6182
Dominik Laskowski9dab3432019-03-27 13:21:10 -07006183void SurfaceFlinger::SetInputWindowsListener::onSetInputWindowsFinished() {
chaviw291d88a2019-02-14 10:33:58 -08006184 mFlinger->setInputWindowsFinished();
6185}
6186
Robert Carrc0df3122019-04-11 13:18:21 -07006187sp<Layer> SurfaceFlinger::fromHandle(const sp<IBinder>& handle) {
6188 BBinder *b = handle->localBinder();
6189 if (b == nullptr) {
6190 return nullptr;
6191 }
6192 auto it = mLayersByLocalBinderToken.find(b);
6193 if (it != mLayersByLocalBinderToken.end()) {
6194 return it->second.promote();
6195 }
6196 return nullptr;
6197}
6198
Dominik Laskowski9dab3432019-03-27 13:21:10 -07006199} // namespace android
Lloyd Pique074e8122018-07-26 12:57:23 -07006200
Mathias Agopian3f844832013-08-07 21:24:32 -07006201#if defined(__gl_h_)
6202#error "don't include gl/gl.h in this file"
6203#endif
6204
6205#if defined(__gl2_h_)
6206#error "don't include gl2/gl2.h in this file"
Chia-I Wu767fcf72017-11-30 22:07:38 -08006207#endif