blob: 83832b922802398894ffcce81182832866e3c2f8 [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 Piqueab039b52019-02-13 14:22:42 -080041#include <compositionengine/CompositionRefreshArgs.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070042#include <compositionengine/Display.h>
Lloyd Pique3d0c02e2018-10-19 18:38:12 -070043#include <compositionengine/DisplayColorProfile.h>
Lloyd Piquecc01a452018-12-04 17:24:00 -080044#include <compositionengine/OutputLayer.h>
Lloyd Pique31cb2942018-10-19 17:23:03 -070045#include <compositionengine/RenderSurface.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070046#include <compositionengine/impl/OutputCompositionState.h>
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -080047#include <dvr/vr_flinger.h>
Jamie Gennis1a4d8832012-08-02 20:11:05 -070048#include <gui/BufferQueue.h>
Ady Abrahama3b08ef2019-07-15 18:43:10 -070049#include <gui/DebugEGLImageTracker.h>
50
Andy McFadden4803b742012-09-24 19:07:20 -070051#include <gui/GuiConfig.h>
Jamie Gennis1a4d8832012-08-02 20:11:05 -070052#include <gui/IDisplayEventConnection.h>
Alec Mouri0a9c7b82018-11-16 13:05:25 -080053#include <gui/IProducerListener.h>
Kalle Raitaa099a242017-01-11 11:17:29 -080054#include <gui/LayerDebugInfo.h>
Mathias Agopiane3c697f2013-02-14 17:11:02 -080055#include <gui/Surface.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070056#include <input/IInputFlinger.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070057#include <renderengine/RenderEngine.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070058#include <ui/ColorSpace.h>
59#include <ui/DebugUtils.h>
60#include <ui/DisplayInfo.h>
61#include <ui/DisplayStatInfo.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070062#include <ui/GraphicBufferAllocator.h>
63#include <ui/PixelFormat.h>
Andy McFadden4803b742012-09-24 19:07:20 -070064#include <ui/UiConfig.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080065#include <utils/StopWatch.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070066#include <utils/String16.h>
67#include <utils/String8.h>
Yusuke Sato0a688f52015-07-30 23:05:39 -070068#include <utils/Timers.h>
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080069#include <utils/Trace.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070070#include <utils/misc.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080071
Mathias Agopian921e6ac2012-07-23 23:11:29 -070072#include <private/android_filesystem_config.h>
Mathias Agopianca088332013-03-28 17:44:13 -070073#include <private/gui/SyncFeatures.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080074
Robert Carr578038f2018-03-09 12:25:24 -080075#include "BufferLayer.h"
Marissa Wallfd668622018-05-10 10:21:13 -070076#include "BufferQueueLayer.h"
Marissa Wall61c58622018-07-18 10:12:20 -070077#include "BufferStateLayer.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +020078#include "Client.h"
Robert Carr578038f2018-03-09 12:25:24 -080079#include "ColorLayer.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +020080#include "Colorizer.h"
Robert Carr578038f2018-03-09 12:25:24 -080081#include "ContainerLayer.h"
Robert Carr578038f2018-03-09 12:25:24 -080082#include "DisplayDevice.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080083#include "Layer.h"
Robert Carr1f0a16a2016-10-24 16:27:39 -070084#include "LayerVector.h"
Robert Carr1db73f62016-12-21 12:58:51 -080085#include "MonitoredProducer.h"
Lloyd Pique22098362018-09-13 11:46:49 -070086#include "NativeWindowSurface.h"
Ady Abraham03b02dd2019-03-21 15:40:11 -070087#include "RefreshRateOverlay.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070088#include "StartPropertySetThread.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080089#include "SurfaceFlinger.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070090#include "SurfaceInterceptor.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080091
Steven Thomasb02664d2017-07-26 18:48:28 -070092#include "DisplayHardware/ComposerHal.h"
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -070093#include "DisplayHardware/DisplayIdentification.h"
Mathias Agopiana4912602012-07-12 14:25:33 -070094#include "DisplayHardware/FramebufferSurface.h"
Mathias Agopiana350ff92010-08-10 17:14:02 -070095#include "DisplayHardware/HWComposer.h"
Jesse Hall99c7dbb2013-03-14 14:29:29 -070096#include "DisplayHardware/VirtualDisplaySurface.h"
Mathias Agopianff2ed702013-09-01 21:36:12 -070097#include "Effects/Daltonizer.h"
Mikael Pessa90092f42019-08-26 17:22:04 -070098#include "FrameTracer/FrameTracer.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -070099#include "RegionSamplingThread.h"
Ana Krulecfefcb582018-08-07 14:22:37 -0700100#include "Scheduler/DispSync.h"
Ana Krulec241cf832018-08-10 15:03:23 -0700101#include "Scheduler/DispSyncSource.h"
Ana Krulecfefcb582018-08-07 14:22:37 -0700102#include "Scheduler/EventControlThread.h"
103#include "Scheduler/EventThread.h"
Ana Krulec47454452018-08-14 11:04:14 -0700104#include "Scheduler/InjectVSyncSource.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -0700105#include "Scheduler/MessageQueue.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700106#include "Scheduler/PhaseOffsets.h"
Ana Krulec98b5b242018-08-10 15:03:23 -0700107#include "Scheduler/Scheduler.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800108#include "TimeStats/TimeStats.h"
Ana Krulecfefcb582018-08-07 14:22:37 -0700109
Mathias Agopianff2ed702013-09-01 21:36:12 -0700110#include <cutils/compiler.h>
Mathias Agopian875d8e12013-06-07 15:35:48 -0700111
Dominik Laskowskib6e54372019-09-04 14:06:28 -0700112#include "android-base/parseint.h"
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) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800241 case DisplayColorSetting::kManaged:
Chia-I Wu0d711262018-05-21 15:19:35 -0700242 return std::string("Managed");
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800243 case DisplayColorSetting::kUnmanaged:
Chia-I Wu0d711262018-05-21 15:19:35 -0700244 return std::string("Unmanaged");
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800245 case DisplayColorSetting::kEnhanced:
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),
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700257 mInterceptor(mFactory.createSurfaceInterceptor(this)),
Yiwei Zhangf0229a72019-09-09 19:28:02 -0700258 mTimeStats(std::make_shared<impl::TimeStats>()),
Mikael Pessa90092f42019-08-26 17:22:04 -0700259 mFrameTracer(std::make_unique<FrameTracer>()),
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700260 mEventQueue(mFactory.createMessageQueue()),
Dominik Laskowskieddeda12019-07-19 11:54:13 -0700261 mCompositionEngine(mFactory.createCompositionEngine()),
262 mPhaseOffsets(mFactory.createPhaseOffsets()) {}
Lloyd Piqueac648ee2018-01-17 13:42:24 -0800263
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700264SurfaceFlinger::SurfaceFlinger(Factory& factory) : SurfaceFlinger(factory, SkipInitialization) {
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800265 ALOGI("SurfaceFlinger is starting");
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800266
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900267 hasSyncFramework = running_without_sync_framework(true);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800268
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900269 dispSyncPresentTimeOffset = present_time_offset_from_vsync_ns(0);
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700270
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900271 useHwcForRgbToYuv = force_hwc_copy_for_virtual_displays(false);
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700272
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900273 maxVirtualDisplaySize = max_virtual_display_dimension(0);
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800274
Steven Thomas050b2c82017-03-06 11:45:16 -0800275 // Vr flinger is only enabled on Daydream ready devices.
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900276 useVrFlinger = use_vr_flinger(false);
Steven Thomas050b2c82017-03-06 11:45:16 -0800277
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900278 maxFrameBufferAcquiredBuffers = max_frame_buffer_acquired_buffers(2);
Fabien Sanglard1971b632017-03-10 14:50:03 -0800279
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900280 hasWideColorDisplay = has_wide_color_display(false);
Peiyong Lin0256f722018-08-31 15:45:10 -0700281
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900282 useColorManagement = use_color_management(false);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600283
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900284 mDefaultCompositionDataspace =
285 static_cast<ui::Dataspace>(default_composition_dataspace(Dataspace::V0_SRGB));
Peiyong Lin8cabfc32019-06-14 14:25:43 -0700286 mWideColorGamutCompositionDataspace = static_cast<ui::Dataspace>(wcg_composition_dataspace(
287 hasWideColorDisplay ? Dataspace::DISPLAY_P3 : Dataspace::V0_SRGB));
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900288 defaultCompositionDataspace = mDefaultCompositionDataspace;
289 wideColorGamutCompositionDataspace = mWideColorGamutCompositionDataspace;
290 defaultCompositionPixelFormat = static_cast<ui::PixelFormat>(
291 default_composition_pixel_format(ui::PixelFormat::RGBA_8888));
292 wideColorGamutCompositionPixelFormat =
293 static_cast<ui::PixelFormat>(wcg_composition_pixel_format(ui::PixelFormat::RGBA_8888));
Peiyong Linb3839ad2018-09-05 15:37:19 -0700294
Yichi Chenda901bf2019-06-28 14:58:27 +0800295 mColorSpaceAgnosticDataspace =
296 static_cast<ui::Dataspace>(color_space_agnostic_dataspace(Dataspace::UNKNOWN));
297
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900298 useContextPriority = use_context_priority(true);
Iris Chang7501ed62018-04-30 14:45:42 +0800299
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900300 auto tmpPrimaryDisplayOrientation = primary_display_orientation(
301 SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_0);
302 switch (tmpPrimaryDisplayOrientation) {
303 case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_90:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700304 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientation90;
Iris Chang7501ed62018-04-30 14:45:42 +0800305 break;
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900306 case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_180:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700307 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientation180;
Iris Chang7501ed62018-04-30 14:45:42 +0800308 break;
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900309 case SurfaceFlingerProperties::primary_display_orientation_values::ORIENTATION_270:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700310 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientation270;
Iris Chang7501ed62018-04-30 14:45:42 +0800311 break;
312 default:
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700313 SurfaceFlinger::primaryDisplayOrientation = DisplayState::eOrientationDefault;
Iris Chang7501ed62018-04-30 14:45:42 +0800314 break;
315 }
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700316 ALOGV("Primary Display Orientation is set to %2d.", SurfaceFlinger::primaryDisplayOrientation);
Iris Chang7501ed62018-04-30 14:45:42 +0800317
Sundong Ahn85131bd2019-02-18 15:51:53 +0900318 mInternalDisplayPrimaries = sysprop::getDisplayNativePrimaries();
Daniel Solomon42d04562019-01-20 21:03:19 -0800319
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800320 // debugging stuff...
321 char value[PROPERTY_VALUE_MAX];
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700322
Mathias Agopianb4b17302013-03-20 18:36:41 -0700323 property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");
Mathias Agopian50210b92013-03-21 21:13:21 -0700324 mGpuToCpuSupported = !atoi(value);
Mathias Agopianb4b17302013-03-20 18:36:41 -0700325
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800326 property_get("debug.sf.showupdates", value, "0");
327 mDebugRegion = atoi(value);
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700328
Mathias Agopianc1d359d2012-08-04 20:09:03 -0700329 ALOGI_IF(mDebugRegion, "showupdates enabled");
Orion Hodson34397da2019-02-04 09:36:10 +0000330
331 // DDMS debugging deprecated (b/120782499)
332 property_get("debug.sf.ddms", value, "0");
333 int debugDdms = atoi(value);
334 ALOGI_IF(debugDdms, "DDMS debugging not supported");
Dan Stozac5da2712016-07-20 15:38:12 -0700335
336 property_get("debug.sf.disable_backpressure", value, "0");
337 mPropagateBackpressure = !atoi(value);
338 ALOGI_IF(!mPropagateBackpressure, "Disabling backpressure propagation");
Dan Stoza8cf150a2016-08-02 10:27:31 -0700339
Ady Abrahamadb9a992019-09-19 21:21:55 +0000340 property_get("debug.sf.enable_gl_backpressure", value, "0");
341 mPropagateBackpressureClientComposition = atoi(value);
342 ALOGI_IF(mPropagateBackpressureClientComposition,
343 "Enabling backpressure propagation for Client Composition");
344
Fabien Sanglard642b23d2017-02-09 12:29:39 -0800345 property_get("debug.sf.enable_hwc_vds", value, "0");
346 mUseHwcVirtualDisplays = atoi(value);
Chia-I Wu11d10612018-06-21 15:41:13 +0800347 ALOGI_IF(mUseHwcVirtualDisplays, "Enabling HWC virtual displays");
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800348
Yiwei Zhangb770ed32018-12-17 17:44:28 -0800349 property_get("ro.sf.disable_triple_buffer", value, "0");
Fabien Sanglardc65dafa2017-02-07 14:06:39 -0800350 mLayerTripleBufferingDisabled = atoi(value);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800351 ALOGI_IF(mLayerTripleBufferingDisabled, "Disabling Triple Buffering");
Romain Guy3054f002017-06-05 18:38:53 -0700352
Yiwei Zhang243b3782018-05-15 17:40:04 -0700353 const size_t defaultListSize = MAX_LAYERS;
Dan Stoza0a0158c2018-03-16 13:38:54 -0700354 auto listSize = property_get_int32("debug.sf.max_igbp_list_size", int32_t(defaultListSize));
355 mMaxGraphicBufferProducerListSize = (listSize > 0) ? size_t(listSize) : defaultListSize;
356
Ana Krulece5a06e02019-03-06 17:09:03 -0800357 mUseSmart90ForVideo = use_smart_90_for_video(false);
Ana Krulecba13ab32019-02-20 14:14:12 -0800358 property_get("debug.sf.use_smart_90_for_video", value, "0");
Ana Krulece5a06e02019-03-06 17:09:03 -0800359
360 int int_value = atoi(value);
361 if (int_value) {
362 mUseSmart90ForVideo = true;
363 }
Ana Krulecba13ab32019-02-20 14:14:12 -0800364
Dan Stozaec460082018-12-17 15:35:09 -0800365 property_get("debug.sf.luma_sampling", value, "1");
366 mLumaSampling = atoi(value);
367
Romain Guy11d63f42017-07-20 12:47:14 -0700368 // We should be reading 'persist.sys.sf.color_saturation' here
369 // but since /data may be encrypted, we need to wait until after vold
370 // comes online to attempt to read the property. The property is
371 // instead read after the boot animation
Kalle Raitaa099a242017-01-11 11:17:29 -0800372
373 if (useTrebleTestingOverride()) {
374 // Without the override SurfaceFlinger cannot connect to HIDL
375 // services that are not listed in the manifests. Considered
376 // deriving the setting from the set service name, but it
377 // would be brittle if the name that's not 'default' is used
378 // for production purposes later on.
379 setenv("TREBLE_TESTING_OVERRIDE", "true", true);
380 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800381}
382
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800383void SurfaceFlinger::onFirstRef()
384{
Lloyd Pique3fcdef12018-01-22 17:14:00 -0800385 mEventQueue->init(this);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800386}
387
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700388SurfaceFlinger::~SurfaceFlinger() = default;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800389
Dan Stozac7014012014-02-14 15:03:43 -0800390void SurfaceFlinger::binderDied(const wp<IBinder>& /* who */)
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800391{
392 // the window manager died on us. prepare its eulogy.
393
Andy McFadden13a082e2012-08-24 10:16:42 -0700394 // restore initial conditions (default device unblank, etc)
395 initializeDisplays();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800396
397 // restart the boot-animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700398 startBootAnim();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800399}
400
Robert Carr1db73f62016-12-21 12:58:51 -0800401static sp<ISurfaceComposerClient> initClient(const sp<Client>& client) {
Mathias Agopian96f08192010-06-02 23:28:45 -0700402 status_t err = client->initCheck();
403 if (err == NO_ERROR) {
Robert Carr1db73f62016-12-21 12:58:51 -0800404 return client;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800405 }
Robert Carr1db73f62016-12-21 12:58:51 -0800406 return nullptr;
407}
408
409sp<ISurfaceComposerClient> SurfaceFlinger::createConnection() {
410 return initClient(new Client(this));
411}
412
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700413sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName,
414 bool secure)
Mathias Agopiane57f2922012-08-09 16:29:12 -0700415{
416 class DisplayToken : public BBinder {
417 sp<SurfaceFlinger> flinger;
418 virtual ~DisplayToken() {
419 // no more references, this display must be terminated
420 Mutex::Autolock _l(flinger->mStateLock);
421 flinger->mCurrentState.displays.removeItem(this);
422 flinger->setTransactionFlags(eDisplayTransactionNeeded);
423 }
424 public:
Chih-Hung Hsiehc4067912016-05-03 14:03:27 -0700425 explicit DisplayToken(const sp<SurfaceFlinger>& flinger)
Mathias Agopiane57f2922012-08-09 16:29:12 -0700426 : flinger(flinger) {
427 }
428 };
429
430 sp<BBinder> token = new DisplayToken(this);
431
432 Mutex::Autolock _l(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700433 // Display ID is assigned when virtual display is allocated by HWC.
434 DisplayDeviceState state;
435 state.isSecure = secure;
436 state.displayName = displayName;
437 mCurrentState.displays.add(token, state);
438 mInterceptor->saveDisplayCreation(state);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700439 return token;
440}
441
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700442void SurfaceFlinger::destroyDisplay(const sp<IBinder>& displayToken) {
Jesse Hall6c913be2013-08-08 12:15:49 -0700443 Mutex::Autolock _l(mStateLock);
444
Dominik Laskowski075d3172018-05-24 15:50:06 -0700445 ssize_t index = mCurrentState.displays.indexOfKey(displayToken);
446 if (index < 0) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700447 ALOGE("destroyDisplay: Invalid display token %p", displayToken.get());
Jesse Hall6c913be2013-08-08 12:15:49 -0700448 return;
449 }
450
Dominik Laskowski075d3172018-05-24 15:50:06 -0700451 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
452 if (!state.isVirtual()) {
Jesse Hall6c913be2013-08-08 12:15:49 -0700453 ALOGE("destroyDisplay called for non-virtual display");
454 return;
455 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700456 mInterceptor->saveDisplayDeletion(state.sequenceId);
457 mCurrentState.displays.removeItemsAt(index);
Jesse Hall6c913be2013-08-08 12:15:49 -0700458 setTransactionFlags(eDisplayTransactionNeeded);
459}
460
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800461std::vector<PhysicalDisplayId> SurfaceFlinger::getPhysicalDisplayIds() const {
462 Mutex::Autolock lock(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700463
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800464 const auto internalDisplayId = getInternalDisplayIdLocked();
465 if (!internalDisplayId) {
466 return {};
Dominik Laskowski075d3172018-05-24 15:50:06 -0700467 }
468
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800469 std::vector<PhysicalDisplayId> displayIds;
470 displayIds.reserve(mPhysicalDisplayTokens.size());
471 displayIds.push_back(internalDisplayId->value);
472
473 for (const auto& [id, token] : mPhysicalDisplayTokens) {
474 if (id != *internalDisplayId) {
475 displayIds.push_back(id.value);
476 }
Mathias Agopiane57f2922012-08-09 16:29:12 -0700477 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700478
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800479 return displayIds;
480}
481
482sp<IBinder> SurfaceFlinger::getPhysicalDisplayToken(PhysicalDisplayId displayId) const {
483 Mutex::Autolock lock(mStateLock);
484 return getPhysicalDisplayTokenLocked(DisplayId{displayId});
Mathias Agopiane57f2922012-08-09 16:29:12 -0700485}
486
Ady Abraham37965d42018-11-01 13:43:32 -0700487status_t SurfaceFlinger::getColorManagement(bool* outGetColorManagement) const {
488 if (!outGetColorManagement) {
489 return BAD_VALUE;
490 }
491 *outGetColorManagement = useColorManagement;
492 return NO_ERROR;
Ady Abraham2a6ab2a2018-10-26 14:25:30 -0700493}
494
Lloyd Pique441d5042018-10-18 16:49:51 -0700495HWComposer& SurfaceFlinger::getHwComposer() const {
496 return mCompositionEngine->getHwComposer();
497}
498
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700499renderengine::RenderEngine& SurfaceFlinger::getRenderEngine() const {
500 return mCompositionEngine->getRenderEngine();
501}
502
Lloyd Pique70d91362018-10-18 16:02:55 -0700503compositionengine::CompositionEngine& SurfaceFlinger::getCompositionEngine() const {
504 return *mCompositionEngine.get();
505}
506
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800507void SurfaceFlinger::bootFinished()
508{
Wei Wangf9b05ee2017-07-19 20:59:39 -0700509 if (mStartPropertySetThread->join() != NO_ERROR) {
510 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800511 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800512 const nsecs_t now = systemTime();
513 const nsecs_t duration = now - mBootTime;
Steve Blocka19954a2012-01-04 20:05:49 +0000514 ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700515
Mikael Pessa90092f42019-08-26 17:22:04 -0700516 mFrameTracer->initialize();
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700517
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700518 // wait patiently for the window manager death
519 const String16 name("window");
Steven Morelanda904bb92019-07-02 17:37:23 -0700520 mWindowManager = defaultServiceManager()->getService(name);
521 if (mWindowManager != 0) {
522 mWindowManager->linkToDeath(static_cast<IBinder::DeathRecipient*>(this));
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700523 }
Robert Carr720e5062018-07-30 17:45:14 -0700524 sp<IBinder> input(defaultServiceManager()->getService(
525 String16("inputflinger")));
526 if (input == nullptr) {
527 ALOGE("Failed to link to input service");
528 } else {
529 mInputFlinger = interface_cast<IInputFlinger>(input);
530 }
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700531
Steven Thomas050b2c82017-03-06 11:45:16 -0800532 if (mVrFlinger) {
533 mVrFlinger->OnBootFinished();
534 }
535
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700536 // stop boot animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700537 // formerly we would just kill the process, but we now ask it to exit so it
538 // can choose where to stop the animation.
539 property_set("service.bootanim.exit", "1");
Yusuke Sato0a688f52015-07-30 23:05:39 -0700540
541 const int LOGTAG_SF_STOP_BOOTANIM = 60110;
542 LOG_EVENT_LONG(LOGTAG_SF_STOP_BOOTANIM,
543 ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
Romain Guy11d63f42017-07-20 12:47:14 -0700544
Ana Krulecbd6654b2019-02-15 15:18:15 -0800545 postMessageAsync(new LambdaMessage([this]() NO_THREAD_SAFETY_ANALYSIS {
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800546 readPersistentProperties();
547 mBootStage = BootStage::FINISHED;
Ana Krulecbd6654b2019-02-15 15:18:15 -0800548
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700549 if (mRefreshRateConfigs->refreshRateSwitchingSupported()) {
550 // set the refresh rate according to the policy
551 const auto& performanceRefreshRate =
552 mRefreshRateConfigs->getRefreshRateFromType(RefreshRateType::PERFORMANCE);
Ady Abraham97d04232019-03-05 19:48:12 -0800553
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700554 if (isDisplayConfigAllowed(performanceRefreshRate.configId)) {
555 setRefreshRateTo(RefreshRateType::PERFORMANCE, Scheduler::ConfigEvent::None);
556 } else {
557 setRefreshRateTo(RefreshRateType::DEFAULT, Scheduler::ConfigEvent::None);
558 }
Ana Krulecbd6654b2019-02-15 15:18:15 -0800559 }
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800560 }));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800561}
562
Dan Stoza436ccf32018-06-21 12:10:12 -0700563uint32_t SurfaceFlinger::getNewTexture() {
564 {
565 std::lock_guard lock(mTexturePoolMutex);
566 if (!mTexturePool.empty()) {
567 uint32_t name = mTexturePool.back();
568 mTexturePool.pop_back();
569 ATRACE_INT("TexturePoolSize", mTexturePool.size());
570 return name;
571 }
572
573 // The pool was too small, so increase it for the future
574 ++mTexturePoolSize;
575 }
576
577 // The pool was empty, so we need to get a new texture name directly using a
578 // blocking call to the main thread
579 uint32_t name = 0;
580 postMessageSync(new LambdaMessage([&]() { getRenderEngine().genTextures(1, &name); }));
581 return name;
582}
583
Mathias Agopian3f844832013-08-07 21:24:32 -0700584void SurfaceFlinger::deleteTextureAsync(uint32_t texture) {
Dan Stoza67765d82019-05-07 14:58:27 -0700585 std::lock_guard lock(mTexturePoolMutex);
586 // We don't change the pool size, so the fix-up logic in postComposition will decide whether
587 // to actually delete this or not based on mTexturePoolSize
588 mTexturePool.push_back(texture);
589 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700590}
591
Wei Wangf9b05ee2017-07-19 20:59:39 -0700592// Do not call property_set on main thread which will be blocked by init
593// Use StartPropertySetThread instead.
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700594void SurfaceFlinger::init() {
Mathias Agopiana4912602012-07-12 14:25:33 -0700595 ALOGI( "SurfaceFlinger's main thread ready to run. "
596 "Initializing graphics H/W...");
Dominik Laskowskieddeda12019-07-19 11:54:13 -0700597 ALOGI("Phase offset: %" PRId64 " ns", mPhaseOffsets->getCurrentAppOffset());
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900598
Steven Thomasb02664d2017-07-26 18:48:28 -0700599 Mutex::Autolock _l(mStateLock);
Kevin DuBois413287f2019-02-25 08:46:47 -0800600
Steven Thomasb02664d2017-07-26 18:48:28 -0700601 // Get a RenderEngine for the given display / config (can't fail)
Peiyong Lin13effd12018-07-24 17:01:47 -0700602 int32_t renderEngineFeature = 0;
Peiyong Lin833074a2018-08-28 11:53:54 -0700603 renderEngineFeature |= (useColorManagement ?
604 renderengine::RenderEngine::USE_COLOR_MANAGEMENT : 0);
Peiyong Linb3839ad2018-09-05 15:37:19 -0700605 renderEngineFeature |= (useContextPriority ?
606 renderengine::RenderEngine::USE_HIGH_PRIORITY_CONTEXT : 0);
Peiyong Lin6a043d52019-04-01 17:18:21 -0700607 renderEngineFeature |=
608 (enable_protected_contents(false) ? renderengine::RenderEngine::ENABLE_PROTECTED_CONTEXT
609 : 0);
Peiyong Lin0256f722018-08-31 15:45:10 -0700610
611 // TODO(b/77156734): We need to stop casting and use HAL types when possible.
Alec Mourida4cf3b2019-02-12 15:33:01 -0800612 // Sending maxFrameBufferAcquiredBuffers as the cache size is tightly tuned to single-display.
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700613 mCompositionEngine->setRenderEngine(
Peiyong Linc6780972018-10-28 15:24:08 -0700614 renderengine::RenderEngine::create(static_cast<int32_t>(defaultCompositionPixelFormat),
Alec Mourida4cf3b2019-02-12 15:33:01 -0800615 renderEngineFeature, maxFrameBufferAcquiredBuffers));
Steven Thomasb02664d2017-07-26 18:48:28 -0700616
617 LOG_ALWAYS_FATAL_IF(mVrFlingerRequestsDisplay,
618 "Starting with vr flinger active is not currently supported.");
Lloyd Pique441d5042018-10-18 16:49:51 -0700619 mCompositionEngine->setHwComposer(getFactory().createHWComposer(getBE().mHwcServiceName));
620 mCompositionEngine->getHwComposer().registerCallback(this, getBE().mComposerSequenceId);
Lloyd Piqueba04e622017-12-14 17:11:26 -0800621 // Process any initial hotplug and resulting display changes.
622 processDisplayHotplugEventsLocked();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700623 const auto display = getDefaultDisplayDeviceLocked();
624 LOG_ALWAYS_FATAL_IF(!display, "Missing internal display after registering composer callback.");
Dominik Laskowski075d3172018-05-24 15:50:06 -0700625 LOG_ALWAYS_FATAL_IF(!getHwComposer().isConnected(*display->getId()),
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700626 "Internal display is disconnected.");
Jesse Hall692c7232012-11-08 15:41:56 -0800627
Steven Thomas050b2c82017-03-06 11:45:16 -0800628 if (useVrFlinger) {
Dominik Laskowski8c001672018-05-30 16:52:06 -0700629 auto vrFlingerRequestDisplayCallback = [this](bool requestDisplay) {
Steven Thomasbe6cbae2017-09-28 15:30:23 -0700630 // This callback is called from the vr flinger dispatch thread. We
631 // need to call signalTransaction(), which requires holding
632 // mStateLock when we're not on the main thread. Acquiring
633 // mStateLock from the vr flinger dispatch thread might trigger a
634 // deadlock in surface flinger (see b/66916578), so post a message
635 // to be handled on the main thread instead.
Dominik Laskowski8c001672018-05-30 16:52:06 -0700636 postMessageAsync(new LambdaMessage([=] {
Steven Thomasbe6cbae2017-09-28 15:30:23 -0700637 ALOGI("VR request display mode: requestDisplay=%d", requestDisplay);
638 mVrFlingerRequestsDisplay = requestDisplay;
639 signalTransaction();
Dominik Laskowski8c001672018-05-30 16:52:06 -0700640 }));
Steven Thomas050b2c82017-03-06 11:45:16 -0800641 };
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700642 mVrFlinger = dvr::VrFlinger::Create(getHwComposer().getComposer(),
643 getHwComposer()
Dominik Laskowski075d3172018-05-24 15:50:06 -0700644 .fromPhysicalDisplayId(*display->getId())
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700645 .value_or(0),
646 vrFlingerRequestDisplayCallback);
Steven Thomas050b2c82017-03-06 11:45:16 -0800647 if (!mVrFlinger) {
648 ALOGE("Failed to start vrflinger");
649 }
650 }
651
Mathias Agopian92a979a2012-08-02 18:32:23 -0700652 // initialize our drawing state
653 mDrawingState = mCurrentState;
Mathias Agopian86303202012-07-24 22:46:10 -0700654
Andy McFadden13a082e2012-08-24 10:16:42 -0700655 // set initial conditions (e.g. unblank default device)
656 initializeDisplays();
657
Steven Thomas137d4bc2019-07-25 16:55:14 -0700658 char primeShaderCache[PROPERTY_VALUE_MAX];
659 property_get("service.sf.prime_shader_cache", primeShaderCache, "1");
660 if (atoi(primeShaderCache)) {
661 getRenderEngine().primeCache();
662 }
Dan Stoza4e637772016-07-28 13:31:51 -0700663
Wei Wangf9b05ee2017-07-19 20:59:39 -0700664 // Inform native graphics APIs whether the present timestamp is supported:
Lloyd Pique90c115d2018-09-18 21:39:42 -0700665
666 const bool presentFenceReliable =
667 !getHwComposer().hasCapability(HWC2::Capability::PresentFenceIsNotReliable);
668 mStartPropertySetThread = getFactory().createStartPropertySetThread(presentFenceReliable);
Wei Wangf9b05ee2017-07-19 20:59:39 -0700669
670 if (mStartPropertySetThread->Start() != NO_ERROR) {
671 ALOGE("Run StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800672 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800673
Dan Stoza9e56aa02015-11-02 13:00:03 -0800674 ALOGV("Done initializing");
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700675}
676
Romain Guy11d63f42017-07-20 12:47:14 -0700677void SurfaceFlinger::readPersistentProperties() {
Chia-I Wu28f320b2018-05-03 11:02:56 -0700678 Mutex::Autolock _l(mStateLock);
679
Romain Guy11d63f42017-07-20 12:47:14 -0700680 char value[PROPERTY_VALUE_MAX];
681
682 property_get("persist.sys.sf.color_saturation", value, "1.0");
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800683 mGlobalSaturationFactor = atof(value);
Chia-I Wu28f320b2018-05-03 11:02:56 -0700684 updateColorMatrixLocked();
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800685 ALOGV("Saturation is set to %.2f", mGlobalSaturationFactor);
Romain Guy54f154a2017-10-24 21:40:32 +0100686
687 property_get("persist.sys.sf.native_mode", value, "0");
Chia-I Wu0d711262018-05-21 15:19:35 -0700688 mDisplayColorSetting = static_cast<DisplayColorSetting>(atoi(value));
Peiyong Lina3ea5592019-02-10 14:45:00 -0800689
690 property_get("persist.sys.sf.color_mode", value, "0");
691 mForceColorMode = static_cast<ColorMode>(atoi(value));
Romain Guy11d63f42017-07-20 12:47:14 -0700692}
693
Mathias Agopiana67e4182012-06-19 17:26:12 -0700694void SurfaceFlinger::startBootAnim() {
Wei Wangb254fa32017-01-31 17:43:23 -0800695 // Start boot animation service by setting a property mailbox
696 // if property setting thread is already running, Start() will be just a NOP
Wei Wangf9b05ee2017-07-19 20:59:39 -0700697 mStartPropertySetThread->Start();
Wei Wangb254fa32017-01-31 17:43:23 -0800698 // Wait until property was set
Wei Wangf9b05ee2017-07-19 20:59:39 -0700699 if (mStartPropertySetThread->join() != NO_ERROR) {
700 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800701 }
Mathias Agopiana67e4182012-06-19 17:26:12 -0700702}
703
Mathias Agopian875d8e12013-06-07 15:35:48 -0700704size_t SurfaceFlinger::getMaxTextureSize() const {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700705 return getRenderEngine().getMaxTextureSize();
Mathias Agopiana4912602012-07-12 14:25:33 -0700706}
707
Mathias Agopian875d8e12013-06-07 15:35:48 -0700708size_t SurfaceFlinger::getMaxViewportDims() const {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700709 return getRenderEngine().getMaxViewportDims();
Mathias Agopiana4912602012-07-12 14:25:33 -0700710}
711
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800712// ----------------------------------------------------------------------------
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800713
Jamie Gennis582270d2011-08-17 18:19:00 -0700714bool SurfaceFlinger::authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800715 const sp<IGraphicBufferProducer>& bufferProducer) const {
Jamie Gennis134f0422011-03-08 12:18:54 -0800716 Mutex::Autolock _l(mStateLock);
Robert Carr0d480722017-01-10 16:42:54 -0800717 return authenticateSurfaceTextureLocked(bufferProducer);
718}
719
720bool SurfaceFlinger::authenticateSurfaceTextureLocked(
721 const sp<IGraphicBufferProducer>& bufferProducer) const {
Marco Nelissen097ca272014-11-14 08:01:01 -0800722 sp<IBinder> surfaceTextureBinder(IInterface::asBinder(bufferProducer));
Dan Stoza101d8dc2018-02-27 15:42:25 -0800723 return mGraphicBufferProducerList.count(surfaceTextureBinder.get()) > 0;
Jamie Gennis134f0422011-03-08 12:18:54 -0800724}
725
Brian Anderson6b376712017-04-04 10:51:39 -0700726status_t SurfaceFlinger::getSupportedFrameTimestamps(
727 std::vector<FrameEvent>* outSupported) const {
728 *outSupported = {
729 FrameEvent::REQUESTED_PRESENT,
730 FrameEvent::ACQUIRE,
731 FrameEvent::LATCH,
732 FrameEvent::FIRST_REFRESH_START,
733 FrameEvent::LAST_REFRESH_START,
734 FrameEvent::GPU_COMPOSITION_DONE,
735 FrameEvent::DEQUEUE_READY,
736 FrameEvent::RELEASE,
737 };
Steven Thomas6d8110b2017-08-31 18:24:21 -0700738 ConditionalLock _l(mStateLock,
739 std::this_thread::get_id() != mMainThreadId);
Brian Anderson6b376712017-04-04 10:51:39 -0700740 if (!getHwComposer().hasCapability(
741 HWC2::Capability::PresentFenceIsNotReliable)) {
742 outSupported->push_back(FrameEvent::DISPLAY_PRESENT);
743 }
744 return NO_ERROR;
745}
746
Dominik Laskowski22488f62019-03-28 09:53:04 -0700747status_t SurfaceFlinger::getDisplayConfigs(const sp<IBinder>& displayToken,
748 Vector<DisplayInfo>* configs) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700749 if (!displayToken || !configs) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700750 return BAD_VALUE;
751 }
752
Dominik Laskowski22488f62019-03-28 09:53:04 -0700753 Mutex::Autolock lock(mStateLock);
754
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800755 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700756 if (!displayId) {
757 return NAME_NOT_FOUND;
Mathias Agopianc666cae2012-07-25 18:56:13 -0700758 }
Mathias Agopian8b736f12012-08-13 17:54:26 -0700759
Mathias Agopian8b736f12012-08-13 17:54:26 -0700760 // TODO: Not sure if display density should handled by SF any longer
761 class Density {
Hernan Liatis57568932018-08-16 17:07:08 -0700762 static float getDensityFromProperty(char const* propName) {
Mathias Agopian8b736f12012-08-13 17:54:26 -0700763 char property[PROPERTY_VALUE_MAX];
Hernan Liatis57568932018-08-16 17:07:08 -0700764 float density = 0.0f;
Peiyong Lin566a3b42018-01-09 18:22:43 -0800765 if (property_get(propName, property, nullptr) > 0) {
Hernan Liatis57568932018-08-16 17:07:08 -0700766 density = strtof(property, nullptr);
Mathias Agopian8b736f12012-08-13 17:54:26 -0700767 }
768 return density;
769 }
770 public:
Hernan Liatis57568932018-08-16 17:07:08 -0700771 static float getEmuDensity() {
Mathias Agopian8b736f12012-08-13 17:54:26 -0700772 return getDensityFromProperty("qemu.sf.lcd_density"); }
Hernan Liatis57568932018-08-16 17:07:08 -0700773 static float getBuildDensity() {
Mathias Agopian8b736f12012-08-13 17:54:26 -0700774 return getDensityFromProperty("ro.sf.lcd_density"); }
775 };
Mathias Agopian1604f772012-09-18 21:54:42 -0700776
Dan Stoza7f7da322014-05-02 15:26:25 -0700777 configs->clear();
Mathias Agopian1604f772012-09-18 21:54:42 -0700778
Dominik Laskowski075d3172018-05-24 15:50:06 -0700779 for (const auto& hwConfig : getHwComposer().getConfigs(*displayId)) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700780 DisplayInfo info = DisplayInfo();
781
Dan Stoza9e56aa02015-11-02 13:00:03 -0800782 float xdpi = hwConfig->getDpiX();
783 float ydpi = hwConfig->getDpiY();
Dan Stoza7f7da322014-05-02 15:26:25 -0700784
Yiwei Zhang27de5df2018-08-23 17:04:51 -0700785 info.w = hwConfig->getWidth();
786 info.h = hwConfig->getHeight();
787 // Default display viewport to display width and height
788 info.viewportW = info.w;
789 info.viewportH = info.h;
790
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800791 if (displayId == getInternalDisplayIdLocked()) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700792 // The density of the device is provided by a build property
793 float density = Density::getBuildDensity() / 160.0f;
794 if (density == 0) {
795 // the build doesn't provide a density -- this is wrong!
796 // use xdpi instead
797 ALOGE("ro.sf.lcd_density must be defined as a build property");
798 density = xdpi / 160.0f;
799 }
800 if (Density::getEmuDensity()) {
801 // if "qemu.sf.lcd_density" is specified, it overrides everything
802 xdpi = ydpi = density = Density::getEmuDensity();
803 density /= 160.0f;
804 }
805 info.density = density;
806
807 // TODO: this needs to go away (currently needed only by webkit)
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700808 const auto display = getDefaultDisplayDeviceLocked();
809 info.orientation = display ? display->getOrientation() : 0;
Yiwei Zhang27de5df2018-08-23 17:04:51 -0700810
811 // This is for screenrecord
812 const Rect viewport = display->getViewport();
813 if (viewport.isValid()) {
814 info.viewportW = uint32_t(viewport.getWidth());
815 info.viewportH = uint32_t(viewport.getHeight());
816 }
Dan Stoza7f7da322014-05-02 15:26:25 -0700817 } else {
818 // TODO: where should this value come from?
819 static const int TV_DENSITY = 213;
820 info.density = TV_DENSITY / 160.0f;
821 info.orientation = 0;
822 }
823
Dan Stoza7f7da322014-05-02 15:26:25 -0700824 info.xdpi = xdpi;
825 info.ydpi = ydpi;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800826 info.fps = 1e9 / hwConfig->getVsyncPeriod();
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700827 const auto refreshRateType =
828 mRefreshRateConfigs->getRefreshRateTypeFromHwcConfigId(hwConfig->getId());
Ady Abraham796beb02019-04-11 15:23:07 -0700829 const auto offset = mPhaseOffsets->getOffsetsForRefreshRate(refreshRateType);
830 info.appVsyncOffset = offset.late.app;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800831
Andy McFadden91b2ca82014-06-13 14:04:23 -0700832 // This is how far in advance a buffer must be queued for
833 // presentation at a given time. If you want a buffer to appear
834 // on the screen at time N, you must submit the buffer before
835 // (N - presentationDeadline).
836 //
837 // Normally it's one full refresh period (to give SF a chance to
838 // latch the buffer), but this can be reduced by configuring a
839 // DispSync offset. Any additional delays introduced by the hardware
840 // composer or panel must be accounted for here.
841 //
842 // We add an additional 1ms to allow for processing time and
843 // differences between the ideal and actual refresh rate.
Ady Abraham796beb02019-04-11 15:23:07 -0700844 info.presentationDeadline = hwConfig->getVsyncPeriod() - offset.late.sf + 1000000;
Dan Stoza7f7da322014-05-02 15:26:25 -0700845
846 // All non-virtual displays are currently considered secure.
847 info.secure = true;
848
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800849 if (displayId == getInternalDisplayIdLocked() &&
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700850 primaryDisplayOrientation & DisplayState::eOrientationSwapMask) {
Iris Chang7501ed62018-04-30 14:45:42 +0800851 std::swap(info.w, info.h);
852 }
853
Michael Wright28f24d02016-07-12 13:30:53 -0700854 configs->push_back(info);
Mathias Agopian8b736f12012-08-13 17:54:26 -0700855 }
856
Dan Stoza7f7da322014-05-02 15:26:25 -0700857 return NO_ERROR;
858}
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700859
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700860status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>&, DisplayStatInfo* stats) {
861 if (!stats) {
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700862 return BAD_VALUE;
863 }
864
Ana Krulecc2870422019-01-29 19:00:58 -0800865 mScheduler->getDisplayStatInfo(stats);
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700866 return NO_ERROR;
867}
868
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700869int SurfaceFlinger::getActiveConfig(const sp<IBinder>& displayToken) {
870 const auto display = getDisplayDevice(displayToken);
871 if (!display) {
872 ALOGE("getActiveConfig: Invalid display token %p", displayToken.get());
Jinguang Dong9f8b9ae2016-11-29 13:55:57 +0800873 return BAD_VALUE;
874 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700875
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700876 return display->getActiveConfig();
Dan Stoza7f7da322014-05-02 15:26:25 -0700877}
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700878
Ady Abraham03b02dd2019-03-21 15:40:11 -0700879void SurfaceFlinger::setDesiredActiveConfig(const ActiveConfigInfo& info) {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800880 ATRACE_CALL();
Ana Krulec7d1d6832018-12-27 11:10:09 -0800881
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800882 // Don't check against the current mode yet. Worst case we set the desired
Ady Abraham9360a222019-02-27 17:05:30 -0800883 // config twice. However event generation config might have changed so we need to update it
884 // accordingly
Ady Abrahamb838aed2019-02-12 15:30:16 -0800885 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Ady Abraham03b02dd2019-03-21 15:40:11 -0700886 const Scheduler::ConfigEvent prevConfig = mDesiredActiveConfig.event;
887 mDesiredActiveConfig = info;
888 mDesiredActiveConfig.event = mDesiredActiveConfig.event | prevConfig;
Ady Abrahamb838aed2019-02-12 15:30:16 -0800889
890 if (!mDesiredActiveConfigChanged) {
Ady Abrahamb838aed2019-02-12 15:30:16 -0800891 // This will trigger HWC refresh without resetting the idle timer.
892 repaintEverythingForHWC();
Alec Mouri754c98a2019-03-18 18:53:42 -0700893 // Start receiving vsync samples now, so that we can detect a period
894 // switch.
895 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
Ady Abraham53852a52019-05-28 18:07:44 -0700896 // As we called to set period, we will call to onRefreshRateChangeCompleted once
897 // DispSync model is locked.
Dominik Laskowskieddeda12019-07-19 11:54:13 -0700898 mVSyncModulator->onRefreshRateChangeInitiated();
Alec Mouri754c98a2019-03-18 18:53:42 -0700899 mPhaseOffsets->setRefreshRateType(info.type);
Dominik Laskowskieddeda12019-07-19 11:54:13 -0700900 mVSyncModulator->setPhaseOffsets(mPhaseOffsets->getCurrentOffsets());
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800901 }
Ady Abrahamb838aed2019-02-12 15:30:16 -0800902 mDesiredActiveConfigChanged = true;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700903
904 if (mRefreshRateOverlay) {
905 mRefreshRateOverlay->changeRefreshRate(mDesiredActiveConfig.type);
906 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800907}
908
909status_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& displayToken, int mode) {
910 ATRACE_CALL();
Ady Abraham838de062019-02-04 10:24:03 -0800911
912 std::vector<int32_t> allowedConfig;
913 allowedConfig.push_back(mode);
914
915 return setAllowedDisplayConfigs(displayToken, allowedConfig);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800916}
917
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800918void SurfaceFlinger::setActiveConfigInternal() {
919 ATRACE_CALL();
920
Dominik Laskowski22488f62019-03-28 09:53:04 -0700921 const auto display = getDefaultDisplayDeviceLocked();
922 if (!display) {
923 return;
924 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800925
Dominik Laskowski22488f62019-03-28 09:53:04 -0700926 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700927 mRefreshRateConfigs->setCurrentConfig(mUpcomingActiveConfig.configId);
928 mRefreshRateStats->setConfigMode(mUpcomingActiveConfig.configId);
Dominik Laskowski22488f62019-03-28 09:53:04 -0700929
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800930 display->setActiveConfig(mUpcomingActiveConfig.configId);
931
Alec Mouri754c98a2019-03-18 18:53:42 -0700932 mPhaseOffsets->setRefreshRateType(mUpcomingActiveConfig.type);
Dominik Laskowskieddeda12019-07-19 11:54:13 -0700933 mVSyncModulator->setPhaseOffsets(mPhaseOffsets->getCurrentOffsets());
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800934 ATRACE_INT("ActiveConfigMode", mUpcomingActiveConfig.configId);
Dominik Laskowski22488f62019-03-28 09:53:04 -0700935
Ana Krulec8d3e4f32019-03-05 10:40:33 -0800936 if (mUpcomingActiveConfig.event != Scheduler::ConfigEvent::None) {
Ady Abraham447052e2019-02-13 16:07:27 -0800937 mScheduler->onConfigChanged(mAppConnectionHandle, display->getId()->value,
938 mUpcomingActiveConfig.configId);
939 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800940}
941
Ady Abraham53852a52019-05-28 18:07:44 -0700942void SurfaceFlinger::desiredActiveConfigChangeDone() {
943 std::lock_guard<std::mutex> lock(mActiveConfigLock);
944 mDesiredActiveConfig.event = Scheduler::ConfigEvent::None;
945 mDesiredActiveConfigChanged = false;
Ady Abraham53852a52019-05-28 18:07:44 -0700946
947 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
948 mPhaseOffsets->setRefreshRateType(mUpcomingActiveConfig.type);
Dominik Laskowskieddeda12019-07-19 11:54:13 -0700949 mVSyncModulator->setPhaseOffsets(mPhaseOffsets->getCurrentOffsets());
Ady Abraham53852a52019-05-28 18:07:44 -0700950}
951
Dominik Laskowski22488f62019-03-28 09:53:04 -0700952bool SurfaceFlinger::performSetActiveConfig() {
Alec Mourife3dc942019-02-12 14:19:18 -0800953 ATRACE_CALL();
Ady Abrahamb838aed2019-02-12 15:30:16 -0800954 if (mCheckPendingFence) {
Ady Abrahambe0f9482019-04-24 15:41:53 -0700955 if (previousFrameMissed()) {
Ady Abrahamb838aed2019-02-12 15:30:16 -0800956 // fence has not signaled yet. wait for the next invalidate
Ady Abraham8532d012019-05-08 14:50:56 -0700957 mEventQueue->invalidate();
Ady Abrahamb838aed2019-02-12 15:30:16 -0800958 return true;
959 }
960
961 // We received the present fence from the HWC, so we assume it successfully updated
962 // the config, hence we update SF.
963 mCheckPendingFence = false;
964 setActiveConfigInternal();
965 }
966
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800967 // Store the local variable to release the lock.
968 ActiveConfigInfo desiredActiveConfig;
969 {
970 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Ady Abrahamb838aed2019-02-12 15:30:16 -0800971 if (!mDesiredActiveConfigChanged) {
972 return false;
973 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800974 desiredActiveConfig = mDesiredActiveConfig;
975 }
976
Dominik Laskowski22488f62019-03-28 09:53:04 -0700977 const auto display = getDefaultDisplayDeviceLocked();
Ady Abrahamb838aed2019-02-12 15:30:16 -0800978 if (!display || display->getActiveConfig() == desiredActiveConfig.configId) {
979 // display is not valid or we are already in the requested mode
980 // on both cases there is nothing left to do
Ady Abraham53852a52019-05-28 18:07:44 -0700981 desiredActiveConfigChangeDone();
Ady Abrahamb838aed2019-02-12 15:30:16 -0800982 return false;
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800983 }
Ady Abrahamb838aed2019-02-12 15:30:16 -0800984
Ady Abraham838de062019-02-04 10:24:03 -0800985 // Desired active config was set, it is different than the config currently in use, however
986 // allowed configs might have change by the time we process the refresh.
987 // Make sure the desired config is still allowed
Dominik Laskowski22488f62019-03-28 09:53:04 -0700988 if (!isDisplayConfigAllowed(desiredActiveConfig.configId)) {
Ady Abraham53852a52019-05-28 18:07:44 -0700989 desiredActiveConfigChangeDone();
Ady Abraham838de062019-02-04 10:24:03 -0800990 return false;
991 }
Alec Mouri7f015182019-07-11 13:56:22 -0700992
Ady Abrahamb838aed2019-02-12 15:30:16 -0800993 mUpcomingActiveConfig = desiredActiveConfig;
994 const auto displayId = display->getId();
995 LOG_ALWAYS_FATAL_IF(!displayId);
996
997 ATRACE_INT("ActiveConfigModeHWC", mUpcomingActiveConfig.configId);
998 getHwComposer().setActiveConfig(*displayId, mUpcomingActiveConfig.configId);
999
1000 // we need to submit an empty frame to HWC to start the process
Ady Abrahamb838aed2019-02-12 15:30:16 -08001001 mCheckPendingFence = true;
Ady Abraham8532d012019-05-08 14:50:56 -07001002 mEventQueue->invalidate();
Ady Abrahamb838aed2019-02-12 15:30:16 -08001003 return false;
Mathias Agopianc666cae2012-07-25 18:56:13 -07001004}
Dominik Laskowski075d3172018-05-24 15:50:06 -07001005
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001006status_t SurfaceFlinger::getDisplayColorModes(const sp<IBinder>& displayToken,
1007 Vector<ColorMode>* outColorModes) {
1008 if (!displayToken || !outColorModes) {
Michael Wright28f24d02016-07-12 13:30:53 -07001009 return BAD_VALUE;
1010 }
1011
Peiyong Lina52f0292018-03-14 17:26:31 -07001012 std::vector<ColorMode> modes;
Peiyong Linff84a152019-05-17 18:36:19 -07001013 bool isInternalDisplay = false;
Steven Thomas6d8110b2017-08-31 18:24:21 -07001014 {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001015 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
1016
1017 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1018 if (!displayId) {
1019 return NAME_NOT_FOUND;
1020 }
1021
Dominik Laskowski075d3172018-05-24 15:50:06 -07001022 modes = getHwComposer().getColorModes(*displayId);
Peiyong Linff84a152019-05-17 18:36:19 -07001023 isInternalDisplay = displayId == getInternalDisplayIdLocked();
Steven Thomas6d8110b2017-08-31 18:24:21 -07001024 }
Michael Wright28f24d02016-07-12 13:30:53 -07001025 outColorModes->clear();
Peiyong Linff84a152019-05-17 18:36:19 -07001026
1027 // If it's built-in display and the configuration claims it's not wide color capable,
1028 // filter out all wide color modes. The typical reason why this happens is that the
1029 // hardware is not good enough to support GPU composition of wide color, and thus the
1030 // OEMs choose to disable this capability.
1031 if (isInternalDisplay && !hasWideColorDisplay) {
1032 std::remove_copy_if(modes.cbegin(), modes.cend(), std::back_inserter(*outColorModes),
1033 isWideColorMode);
1034 } else {
1035 std::copy(modes.cbegin(), modes.cend(), std::back_inserter(*outColorModes));
1036 }
Michael Wright28f24d02016-07-12 13:30:53 -07001037
1038 return NO_ERROR;
1039}
1040
Daniel Solomon42d04562019-01-20 21:03:19 -08001041status_t SurfaceFlinger::getDisplayNativePrimaries(const sp<IBinder>& displayToken,
1042 ui::DisplayPrimaries &primaries) {
1043 if (!displayToken) {
1044 return BAD_VALUE;
1045 }
1046
1047 // Currently we only support this API for a single internal display.
1048 if (getInternalDisplayToken() != displayToken) {
1049 return BAD_VALUE;
1050 }
1051
1052 memcpy(&primaries, &mInternalDisplayPrimaries, sizeof(ui::DisplayPrimaries));
1053 return NO_ERROR;
1054}
1055
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001056ColorMode SurfaceFlinger::getActiveColorMode(const sp<IBinder>& displayToken) {
1057 if (const auto display = getDisplayDevice(displayToken)) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07001058 return display->getCompositionDisplay()->getState().colorMode;
Michael Wright28f24d02016-07-12 13:30:53 -07001059 }
Peiyong Lina52f0292018-03-14 17:26:31 -07001060 return static_cast<ColorMode>(BAD_VALUE);
Michael Wright28f24d02016-07-12 13:30:53 -07001061}
1062
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001063status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& displayToken, ColorMode mode) {
Dominik Laskowski8c001672018-05-30 16:52:06 -07001064 postMessageSync(new LambdaMessage([&] {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001065 Vector<ColorMode> modes;
1066 getDisplayColorModes(displayToken, &modes);
1067 bool exists = std::find(std::begin(modes), std::end(modes), mode) != std::end(modes);
1068 if (mode < ColorMode::NATIVE || !exists) {
1069 ALOGE("Attempt to set invalid active color mode %s (%d) for display token %p",
1070 decodeColorMode(mode).c_str(), mode, displayToken.get());
1071 return;
Michael Wright28f24d02016-07-12 13:30:53 -07001072 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001073 const auto display = getDisplayDevice(displayToken);
1074 if (!display) {
1075 ALOGE("Attempt to set active color mode %s (%d) for invalid display token %p",
1076 decodeColorMode(mode).c_str(), mode, displayToken.get());
1077 } else if (display->isVirtual()) {
1078 ALOGW("Attempt to set active color mode %s (%d) for virtual display",
1079 decodeColorMode(mode).c_str(), mode);
1080 } else {
Lloyd Pique6a3b4462019-03-07 20:58:12 -08001081 display->getCompositionDisplay()->setColorProfile(
1082 compositionengine::Output::ColorProfile{mode, Dataspace::UNKNOWN,
1083 RenderIntent::COLORIMETRIC,
1084 Dataspace::UNKNOWN});
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001085 }
1086 }));
1087
Michael Wright28f24d02016-07-12 13:30:53 -07001088 return NO_ERROR;
1089}
Mathias Agopianc666cae2012-07-25 18:56:13 -07001090
Svetoslavd85084b2014-03-20 10:28:31 -07001091status_t SurfaceFlinger::clearAnimationFrameStats() {
1092 Mutex::Autolock _l(mStateLock);
1093 mAnimFrameTracker.clearStats();
1094 return NO_ERROR;
1095}
1096
1097status_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const {
1098 Mutex::Autolock _l(mStateLock);
1099 mAnimFrameTracker.getStats(outStats);
1100 return NO_ERROR;
1101}
1102
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001103status_t SurfaceFlinger::getHdrCapabilities(const sp<IBinder>& displayToken,
1104 HdrCapabilities* outCapabilities) const {
Dan Stozac4f471e2016-03-24 09:31:08 -07001105 Mutex::Autolock _l(mStateLock);
1106
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001107 const auto display = getDisplayDeviceLocked(displayToken);
1108 if (!display) {
1109 ALOGE("getHdrCapabilities: Invalid display token %p", displayToken.get());
Dan Stozac4f471e2016-03-24 09:31:08 -07001110 return BAD_VALUE;
1111 }
1112
Peiyong Linfb069302018-04-25 14:34:31 -07001113 // At this point the DisplayDeivce should already be set up,
1114 // meaning the luminance information is already queried from
1115 // hardware composer and stored properly.
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001116 const HdrCapabilities& capabilities = display->getHdrCapabilities();
Peiyong Linfb069302018-04-25 14:34:31 -07001117 *outCapabilities = HdrCapabilities(capabilities.getSupportedHdrTypes(),
1118 capabilities.getDesiredMaxLuminance(),
1119 capabilities.getDesiredMaxAverageLuminance(),
1120 capabilities.getDesiredMinLuminance());
Dan Stozac4f471e2016-03-24 09:31:08 -07001121
1122 return NO_ERROR;
1123}
1124
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001125status_t SurfaceFlinger::getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
1126 ui::PixelFormat* outFormat,
1127 ui::Dataspace* outDataspace,
1128 uint8_t* outComponentMask) const {
1129 if (!outFormat || !outDataspace || !outComponentMask) {
1130 return BAD_VALUE;
1131 }
Kevin DuBois74e53772018-11-19 10:52:38 -08001132 const auto display = getDisplayDevice(displayToken);
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001133 if (!display || !display->getId()) {
1134 ALOGE("getDisplayedContentSamplingAttributes: Bad display token: %p", display.get());
1135 return BAD_VALUE;
1136 }
1137 return getHwComposer().getDisplayedContentSamplingAttributes(*display->getId(), outFormat,
1138 outDataspace, outComponentMask);
1139}
1140
Kevin DuBois74e53772018-11-19 10:52:38 -08001141status_t SurfaceFlinger::setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken,
1142 bool enable, uint8_t componentMask,
1143 uint64_t maxFrames) const {
1144 const auto display = getDisplayDevice(displayToken);
1145 if (!display || !display->getId()) {
1146 ALOGE("setDisplayContentSamplingEnabled: Bad display token: %p", display.get());
1147 return BAD_VALUE;
1148 }
1149
1150 return getHwComposer().setDisplayContentSamplingEnabled(*display->getId(), enable,
1151 componentMask, maxFrames);
1152}
1153
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001154status_t SurfaceFlinger::getDisplayedContentSample(const sp<IBinder>& displayToken,
1155 uint64_t maxFrames, uint64_t timestamp,
1156 DisplayedFrameStats* outStats) const {
1157 const auto display = getDisplayDevice(displayToken);
1158 if (!display || !display->getId()) {
1159 ALOGE("getDisplayContentSample: Bad display token: %p", displayToken.get());
1160 return BAD_VALUE;
1161 }
1162
1163 return getHwComposer().getDisplayedContentSample(*display->getId(), maxFrames, timestamp,
1164 outStats);
1165}
1166
Peiyong Lin3c2791e2019-01-14 17:05:18 -08001167status_t SurfaceFlinger::getProtectedContentSupport(bool* outSupported) const {
1168 if (!outSupported) {
1169 return BAD_VALUE;
1170 }
1171 *outSupported = getRenderEngine().supportsProtectedContent();
1172 return NO_ERROR;
1173}
1174
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001175status_t SurfaceFlinger::isWideColorDisplay(const sp<IBinder>& displayToken,
1176 bool* outIsWideColorDisplay) const {
1177 if (!displayToken || !outIsWideColorDisplay) {
1178 return BAD_VALUE;
1179 }
1180 Mutex::Autolock _l(mStateLock);
1181 const auto display = getDisplayDeviceLocked(displayToken);
1182 if (!display) {
1183 return BAD_VALUE;
1184 }
Peiyong Linff84a152019-05-17 18:36:19 -07001185
1186 // Use hasWideColorDisplay to override built-in display.
1187 const auto displayId = display->getId();
1188 if (displayId && displayId == getInternalDisplayIdLocked()) {
1189 *outIsWideColorDisplay = hasWideColorDisplay;
1190 return NO_ERROR;
1191 }
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001192 *outIsWideColorDisplay = display->hasWideColorGamut();
1193 return NO_ERROR;
1194}
1195
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001196status_t SurfaceFlinger::enableVSyncInjections(bool enable) {
Dominik Laskowski8c001672018-05-30 16:52:06 -07001197 postMessageSync(new LambdaMessage([&] {
Chia-I Wu90f669f2017-10-05 14:24:41 -07001198 Mutex::Autolock _l(mStateLock);
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001199
Chia-I Wu90f669f2017-10-05 14:24:41 -07001200 if (mInjectVSyncs == enable) {
1201 return;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001202 }
Chia-I Wu90f669f2017-10-05 14:24:41 -07001203
Ady Abraham46e2f3e2019-03-18 16:40:15 -07001204 // TODO(b/128863962): Part of the Injector should be refactored, so that it
Ana Krulec98b5b242018-08-10 15:03:23 -07001205 // can be passed to Scheduler.
Chia-I Wu90f669f2017-10-05 14:24:41 -07001206 if (enable) {
1207 ALOGV("VSync Injections enabled");
1208 if (mVSyncInjector.get() == nullptr) {
Lloyd Piquee83f9312018-02-01 12:53:17 -08001209 mVSyncInjector = std::make_unique<InjectVSyncSource>();
Lloyd Pique24b0a482018-03-09 18:52:26 -08001210 mInjectorEventThread = std::make_unique<
Dominik Laskowskif654d572018-12-20 11:03:06 -08001211 impl::EventThread>(mVSyncInjector.get(),
Lloyd Pique24b0a482018-03-09 18:52:26 -08001212 impl::EventThread::InterceptVSyncsCallback(),
1213 "injEventThread");
Chia-I Wu90f669f2017-10-05 14:24:41 -07001214 }
Steven Thomas2bbaabe2019-08-28 16:08:35 -07001215 mEventQueue->setEventThread(mInjectorEventThread.get(), [&] { mScheduler->resync(); });
Chia-I Wu90f669f2017-10-05 14:24:41 -07001216 } else {
1217 ALOGV("VSync Injections disabled");
Ana Krulecc2870422019-01-29 19:00:58 -08001218 mEventQueue->setEventThread(mScheduler->getEventThread(mSfConnectionHandle),
Steven Thomas2bbaabe2019-08-28 16:08:35 -07001219 [&] { mScheduler->resync(); });
Chia-I Wu90f669f2017-10-05 14:24:41 -07001220 }
1221
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001222 mInjectVSyncs = enable;
Dominik Laskowski8c001672018-05-30 16:52:06 -07001223 }));
1224
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001225 return NO_ERROR;
1226}
1227
1228status_t SurfaceFlinger::injectVSync(nsecs_t when) {
Chia-I Wu90f669f2017-10-05 14:24:41 -07001229 Mutex::Autolock _l(mStateLock);
1230
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001231 if (!mInjectVSyncs) {
1232 ALOGE("VSync Injections not enabled");
1233 return BAD_VALUE;
1234 }
1235 if (mInjectVSyncs && mInjectorEventThread.get() != nullptr) {
1236 ALOGV("Injecting VSync inside SurfaceFlinger");
1237 mVSyncInjector->onInjectSyncEvent(when);
1238 }
1239 return NO_ERROR;
1240}
1241
Lloyd Pique755e3192018-01-31 16:46:15 -08001242status_t SurfaceFlinger::getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const
1243 NO_THREAD_SAFETY_ANALYSIS {
Kalle Raitaa099a242017-01-11 11:17:29 -08001244 // Try to acquire a lock for 1s, fail gracefully
1245 const status_t err = mStateLock.timedLock(s2ns(1));
1246 const bool locked = (err == NO_ERROR);
1247 if (!locked) {
1248 ALOGE("LayerDebugInfo: SurfaceFlinger unresponsive (%s [%d]) - exit", strerror(-err), err);
1249 return TIMED_OUT;
1250 }
1251
1252 outLayers->clear();
1253 mCurrentState.traverseInZOrder([&](Layer* layer) {
1254 outLayers->push_back(layer->getLayerDebugInfo());
1255 });
1256
1257 mStateLock.unlock();
1258 return NO_ERROR;
1259}
1260
Peiyong Linc6780972018-10-28 15:24:08 -07001261status_t SurfaceFlinger::getCompositionPreference(
1262 Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
1263 Dataspace* outWideColorGamutDataspace,
1264 ui::PixelFormat* outWideColorGamutPixelFormat) const {
Peiyong Lin9d846a52018-11-05 13:18:20 -08001265 *outDataspace = mDefaultCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001266 *outPixelFormat = defaultCompositionPixelFormat;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001267 *outWideColorGamutDataspace = mWideColorGamutCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001268 *outWideColorGamutPixelFormat = wideColorGamutCompositionPixelFormat;
Peiyong Lin0256f722018-08-31 15:45:10 -07001269 return NO_ERROR;
1270}
1271
Dan Stozaec460082018-12-17 15:35:09 -08001272status_t SurfaceFlinger::addRegionSamplingListener(const Rect& samplingArea,
1273 const sp<IBinder>& stopLayerHandle,
1274 const sp<IRegionSamplingListener>& listener) {
tangrobinaf45f012019-02-26 18:10:10 +08001275 if (!listener || samplingArea == Rect::INVALID_RECT) {
Dan Stozaec460082018-12-17 15:35:09 -08001276 return BAD_VALUE;
1277 }
1278 mRegionSamplingThread->addListener(samplingArea, stopLayerHandle, listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001279 return NO_ERROR;
1280}
1281
Dan Stozaec460082018-12-17 15:35:09 -08001282status_t SurfaceFlinger::removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) {
tangrobinaf45f012019-02-26 18:10:10 +08001283 if (!listener) {
1284 return BAD_VALUE;
1285 }
Dan Stozaec460082018-12-17 15:35:09 -08001286 mRegionSamplingThread->removeListener(listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001287 return NO_ERROR;
1288}
Dan Gittik57e63c52019-01-18 16:37:54 +00001289
1290status_t SurfaceFlinger::getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
1291 bool* outSupport) const {
1292 if (!displayToken || !outSupport) {
1293 return BAD_VALUE;
1294 }
1295 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1296 if (!displayId) {
1297 return NAME_NOT_FOUND;
1298 }
1299 *outSupport =
1300 getHwComposer().hasDisplayCapability(displayId, HWC2::DisplayCapability::Brightness);
1301 return NO_ERROR;
1302}
1303
1304status_t SurfaceFlinger::setDisplayBrightness(const sp<IBinder>& displayToken,
1305 float brightness) const {
1306 if (!displayToken) {
1307 return BAD_VALUE;
1308 }
1309 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1310 if (!displayId) {
1311 return NAME_NOT_FOUND;
1312 }
1313 return getHwComposer().setDisplayBrightness(*displayId, brightness);
1314}
1315
Ady Abraham8532d012019-05-08 14:50:56 -07001316status_t SurfaceFlinger::notifyPowerHint(int32_t hintId) {
1317 PowerHint powerHint = static_cast<PowerHint>(hintId);
1318
1319 if (powerHint == PowerHint::INTERACTION) {
1320 mScheduler->notifyTouchEvent();
1321 }
1322
1323 return NO_ERROR;
1324}
1325
Mathias Agopiand0566bc2011-11-17 17:49:17 -08001326// ----------------------------------------------------------------------------
1327
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -07001328sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection(
Ady Abraham0f4a1b12019-06-04 16:04:04 -07001329 ISurfaceComposer::VsyncSource vsyncSource, ISurfaceComposer::ConfigChanged configChanged) {
Ana Krulecc2870422019-01-29 19:00:58 -08001330 const auto& handle =
1331 vsyncSource == eVsyncSourceSurfaceFlinger ? mSfConnectionHandle : mAppConnectionHandle;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001332
Steven Thomas2bbaabe2019-08-28 16:08:35 -07001333 return mScheduler->createDisplayEventConnection(handle, configChanged);
Mathias Agopianbb641242010-05-18 17:06:55 -07001334}
1335
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001336// ----------------------------------------------------------------------------
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001337
1338void SurfaceFlinger::waitForEvent() {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001339 mEventQueue->waitMessage();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001340}
1341
1342void SurfaceFlinger::signalTransaction() {
Ady Abraham8532d012019-05-08 14:50:56 -07001343 mScheduler->resetIdleTimer();
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001344 mEventQueue->invalidate();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001345}
1346
1347void SurfaceFlinger::signalLayerUpdate() {
Ady Abraham8532d012019-05-08 14:50:56 -07001348 mScheduler->resetIdleTimer();
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001349 mEventQueue->invalidate();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001350}
1351
1352void SurfaceFlinger::signalRefresh() {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07001353 mRefreshPending = true;
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001354 mEventQueue->refresh();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001355}
1356
1357status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,
Dan Stozac7014012014-02-14 15:03:43 -08001358 nsecs_t reltime, uint32_t /* flags */) {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001359 return mEventQueue->postMessage(msg, reltime);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001360}
1361
1362status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
Dan Stozac7014012014-02-14 15:03:43 -08001363 nsecs_t reltime, uint32_t /* flags */) {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001364 status_t res = mEventQueue->postMessage(msg, reltime);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001365 if (res == NO_ERROR) {
1366 msg->wait();
1367 }
1368 return res;
1369}
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001370
Mathias Agopian4f4f0942013-08-19 17:26:18 -07001371void SurfaceFlinger::run() {
Mathias Agopian4f4f0942013-08-19 17:26:18 -07001372 do {
1373 waitForEvent();
1374 } while (true);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001375}
1376
Dominik Laskowski83b88212018-12-11 13:34:06 -08001377nsecs_t SurfaceFlinger::getVsyncPeriod() const {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001378 const auto displayId = getInternalDisplayIdLocked();
Dominik Laskowski83b88212018-12-11 13:34:06 -08001379 if (!displayId || !getHwComposer().isConnected(*displayId)) {
1380 return 0;
1381 }
1382
1383 const auto config = getHwComposer().getActiveConfig(*displayId);
1384 return config ? config->getVsyncPeriod() : 0;
1385}
1386
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001387void SurfaceFlinger::onVsyncReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId,
1388 int64_t timestamp) {
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001389 ATRACE_NAME("SF onVsync");
1390
Steven Thomas3cfac282017-02-06 12:29:30 -08001391 Mutex::Autolock lock(mStateLock);
Steven Thomasb02664d2017-07-26 18:48:28 -07001392 // Ignore any vsyncs from a previous hardware composer.
David Sodman105b7dc2017-11-04 20:28:14 -07001393 if (sequenceId != getBE().mComposerSequenceId) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001394 return;
1395 }
1396
Dominik Laskowski075d3172018-05-24 15:50:06 -07001397 if (!getHwComposer().onVsync(hwcDisplayId, timestamp)) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001398 return;
1399 }
1400
Dominik Laskowski075d3172018-05-24 15:50:06 -07001401 if (hwcDisplayId != getHwComposer().getInternalHwcDisplayId()) {
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001402 // For now, we don't do anything with external display vsyncs.
1403 return;
1404 }
1405
Alec Mourif8e689c2019-05-20 18:32:22 -07001406 bool periodFlushed = false;
1407 mScheduler->addResyncSample(timestamp, &periodFlushed);
1408 if (periodFlushed) {
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001409 mVSyncModulator->onRefreshRateChangeCompleted();
Alec Mouri754c98a2019-03-18 18:53:42 -07001410 }
Mathias Agopian148994e2012-09-19 17:31:36 -07001411}
1412
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001413void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
David Sodman99974d22017-11-28 12:04:33 -08001414 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
1415 *compositorTiming = getBE().mCompositorTiming;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001416}
1417
Ady Abraham261614e2019-07-10 17:53:12 -07001418bool SurfaceFlinger::isDisplayConfigAllowed(int32_t configId) const {
Dominik Laskowski22488f62019-03-28 09:53:04 -07001419 return mAllowedDisplayConfigs.empty() || mAllowedDisplayConfigs.count(configId);
Ady Abraham838de062019-02-04 10:24:03 -08001420}
1421
Ana Krulec8d3e4f32019-03-05 10:40:33 -08001422void SurfaceFlinger::setRefreshRateTo(RefreshRateType refreshRate, Scheduler::ConfigEvent event) {
Dominik Laskowski22488f62019-03-28 09:53:04 -07001423 const auto display = getDefaultDisplayDeviceLocked();
1424 if (!display || mBootStage != BootStage::FINISHED) {
Ana Krulec7d1d6832018-12-27 11:10:09 -08001425 return;
1426 }
Alec Mouri1c9e82b2019-03-07 12:24:05 -08001427 ATRACE_CALL();
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001428
Ana Krulec7d1d6832018-12-27 11:10:09 -08001429 // Don't do any updating if the current fps is the same as the new one.
Steven Thomas2bbaabe2019-08-28 16:08:35 -07001430 const auto& refreshRateConfig = mRefreshRateConfigs->getRefreshRateFromType(refreshRate);
1431 const int desiredConfigId = refreshRateConfig.configId;
Alec Mouri0a1cc962019-03-14 12:33:02 -07001432
Dominik Laskowski22488f62019-03-28 09:53:04 -07001433 if (!isDisplayConfigAllowed(desiredConfigId)) {
Ady Abraham1902d072019-03-01 17:18:59 -08001434 ALOGV("Skipping config %d as it is not part of allowed configs", desiredConfigId);
1435 return;
1436 }
1437
Dominik Laskowski22488f62019-03-28 09:53:04 -07001438 setDesiredActiveConfig({refreshRate, desiredConfigId, event});
Ana Krulec7d1d6832018-12-27 11:10:09 -08001439}
1440
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001441void SurfaceFlinger::onHotplugReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId,
Lloyd Pique715a2c12017-12-14 17:18:08 -08001442 HWC2::Connection connection) {
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001443 ALOGV("%s(%d, %" PRIu64 ", %s)", __FUNCTION__, sequenceId, hwcDisplayId,
Lloyd Pique715a2c12017-12-14 17:18:08 -08001444 connection == HWC2::Connection::Connected ? "connected" : "disconnected");
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001445
Lloyd Piqueba04e622017-12-14 17:11:26 -08001446 // Ignore events that do not have the right sequenceId.
1447 if (sequenceId != getBE().mComposerSequenceId) {
1448 return;
1449 }
1450
Steven Thomasb02664d2017-07-26 18:48:28 -07001451 // Only lock if we're not on the main thread. This function is normally
1452 // called on a hwbinder thread, but for the primary display it's called on
1453 // the main thread with the state lock already held, so don't attempt to
1454 // acquire it here.
Lloyd Piqueba04e622017-12-14 17:11:26 -08001455 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
Steven Thomasb02664d2017-07-26 18:48:28 -07001456
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001457 mPendingHotplugEvents.emplace_back(HotplugEvent{hwcDisplayId, connection});
Mathias Agopian9e2463e2012-09-21 18:26:16 -07001458
Jiwen 'Steve' Caiccfd6822018-02-21 16:15:58 -08001459 if (std::this_thread::get_id() == mMainThreadId) {
1460 // Process all pending hot plug events immediately if we are on the main thread.
1461 processDisplayHotplugEventsLocked();
1462 }
1463
Lloyd Piqueba04e622017-12-14 17:11:26 -08001464 setTransactionFlags(eDisplayTransactionNeeded);
Mathias Agopian86303202012-07-24 22:46:10 -07001465}
1466
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001467void SurfaceFlinger::onRefreshReceived(int sequenceId, hwc2_display_t /*hwcDisplayId*/) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001468 Mutex::Autolock lock(mStateLock);
David Sodman105b7dc2017-11-04 20:28:14 -07001469 if (sequenceId != getBE().mComposerSequenceId) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001470 return;
Steven Thomas3cfac282017-02-06 12:29:30 -08001471 }
Ana Krulec7d1d6832018-12-27 11:10:09 -08001472 repaintEverythingForHWC();
Steven Thomas3cfac282017-02-06 12:29:30 -08001473}
1474
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001475void SurfaceFlinger::setPrimaryVsyncEnabled(bool enabled) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001476 ATRACE_CALL();
Ady Abraham9ba25122019-06-03 17:10:55 -07001477
1478 // Enable / Disable HWVsync from the main thread to avoid race conditions with
1479 // display power state.
1480 postMessageAsync(new LambdaMessage(
1481 [=]() NO_THREAD_SAFETY_ANALYSIS { setPrimaryVsyncEnabledInternal(enabled); }));
1482}
1483
1484void SurfaceFlinger::setPrimaryVsyncEnabledInternal(bool enabled) {
1485 ATRACE_CALL();
1486
Ady Abraham27c70212019-06-11 10:52:26 -07001487 mHWCVsyncPendingState = enabled ? HWC2::Vsync::Enable : HWC2::Vsync::Disable;
1488
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001489 if (const auto displayId = getInternalDisplayIdLocked()) {
Ady Abraham9ba25122019-06-03 17:10:55 -07001490 sp<DisplayDevice> display = getDefaultDisplayDeviceLocked();
1491 if (display && display->isPoweredOn()) {
Ady Abraham27c70212019-06-11 10:52:26 -07001492 setVsyncEnabledInHWC(*displayId, mHWCVsyncPendingState);
Ady Abraham9ba25122019-06-03 17:10:55 -07001493 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07001494 }
Mathias Agopian86303202012-07-24 22:46:10 -07001495}
1496
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001497// Note: it is assumed the caller holds |mStateLock| when this is called
Steven Thomasb02664d2017-07-26 18:48:28 -07001498void SurfaceFlinger::resetDisplayState() {
Ana Krulecc2870422019-01-29 19:00:58 -08001499 mScheduler->disableHardwareVsync(true);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001500 // Clear the drawing state so that the logic inside of
1501 // handleTransactionLocked will fire. It will determine the delta between
1502 // mCurrentState and mDrawingState and re-apply all changes when we make the
1503 // transition.
1504 mDrawingState.displays.clear();
1505 mDisplays.clear();
1506}
1507
Steven Thomas050b2c82017-03-06 11:45:16 -08001508void SurfaceFlinger::updateVrFlinger() {
Alec Mourife3dc942019-02-12 14:19:18 -08001509 ATRACE_CALL();
Steven Thomas050b2c82017-03-06 11:45:16 -08001510 if (!mVrFlinger)
1511 return;
1512 bool vrFlingerRequestsDisplay = mVrFlingerRequestsDisplay;
Lloyd Pique441d5042018-10-18 16:49:51 -07001513 if (vrFlingerRequestsDisplay == getHwComposer().isUsingVrComposer()) {
Mark Urbanus209beca2017-02-23 11:16:04 -08001514 return;
1515 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001516
Lloyd Pique441d5042018-10-18 16:49:51 -07001517 if (vrFlingerRequestsDisplay && !getHwComposer().getComposer()->isRemote()) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001518 ALOGE("Vr flinger is only supported for remote hardware composer"
1519 " service connections. Ignoring request to transition to vr"
1520 " flinger.");
1521 mVrFlingerRequestsDisplay = false;
1522 return;
Mark Urbanus209beca2017-02-23 11:16:04 -08001523 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001524
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001525 Mutex::Autolock _l(mStateLock);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001526
Steven Thomas0123ac62018-07-12 11:32:34 -07001527 sp<DisplayDevice> display = getDefaultDisplayDeviceLocked();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07001528 LOG_ALWAYS_FATAL_IF(!display);
Lloyd Pique07e33212018-12-18 16:33:37 -08001529
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07001530 const int currentDisplayPowerMode = display->getPowerMode();
Lloyd Pique07e33212018-12-18 16:33:37 -08001531
1532 // Clear out all the output layers from the composition engine for all
1533 // displays before destroying the hardware composer interface. This ensures
1534 // any HWC layers are destroyed through that interface before it becomes
1535 // invalid.
1536 for (const auto& [token, displayDevice] : mDisplays) {
1537 displayDevice->getCompositionDisplay()->setOutputLayersOrderedByZ(
1538 compositionengine::Output::OutputLayers());
1539 }
1540
Steven Thomas0123ac62018-07-12 11:32:34 -07001541 // This DisplayDevice will no longer be relevant once resetDisplayState() is
1542 // called below. Clear the reference now so we don't accidentally use it
1543 // later.
1544 display.clear();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001545
Steven Thomasb02664d2017-07-26 18:48:28 -07001546 if (!vrFlingerRequestsDisplay) {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001547 mVrFlinger->SeizeDisplayOwnership();
Steven Thomasb02664d2017-07-26 18:48:28 -07001548 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001549
Steven Thomasb02664d2017-07-26 18:48:28 -07001550 resetDisplayState();
Lloyd Pique441d5042018-10-18 16:49:51 -07001551 // Delete the current instance before creating the new one
1552 mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
1553 mCompositionEngine->setHwComposer(getFactory().createHWComposer(
1554 vrFlingerRequestsDisplay ? "vr" : getBE().mHwcServiceName));
1555 getHwComposer().registerCallback(this, ++getBE().mComposerSequenceId);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001556
Lloyd Pique441d5042018-10-18 16:49:51 -07001557 LOG_ALWAYS_FATAL_IF(!getHwComposer().getComposer()->isRemote(),
David Sodman105b7dc2017-11-04 20:28:14 -07001558 "Switched to non-remote hardware composer");
Steven Thomasb02664d2017-07-26 18:48:28 -07001559
1560 if (vrFlingerRequestsDisplay) {
1561 mVrFlinger->GrantDisplayOwnership();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001562 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001563
1564 mVisibleRegionsDirty = true;
1565 invalidateHwcGeometry();
1566
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001567 // Re-enable default display.
Steven Thomas0123ac62018-07-12 11:32:34 -07001568 display = getDefaultDisplayDeviceLocked();
1569 LOG_ALWAYS_FATAL_IF(!display);
Dominik Laskowskie9774092018-12-11 10:04:24 -08001570 setPowerModeInternal(display, currentDisplayPowerMode);
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001571
Steven Thomasb02664d2017-07-26 18:48:28 -07001572 // Reset the timing values to account for the period of the swapped in HWC
Dominik Laskowski83b88212018-12-11 13:34:06 -08001573 const nsecs_t vsyncPeriod = getVsyncPeriod();
1574 mAnimFrameTracker.setDisplayRefreshPeriod(vsyncPeriod);
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001575
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001576 // The present fences returned from vr_hwc are not an accurate
1577 // representation of vsync times.
Ana Krulecc2870422019-01-29 19:00:58 -08001578 mScheduler->setIgnorePresentFences(getHwComposer().isUsingVrComposer() || !hasSyncFramework);
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001579
Steven Thomasb02664d2017-07-26 18:48:28 -07001580 // Use phase of 0 since phase is not known.
1581 // Use latency of 0, which will snap to the ideal latency.
Dominik Laskowski83b88212018-12-11 13:34:06 -08001582 DisplayStatInfo stats{0 /* vsyncTime */, vsyncPeriod};
Ana Krulece588e312018-09-18 12:32:24 -07001583 setCompositorTimingSnapped(stats, 0);
Stephen Kiazyk82386cd2017-04-14 13:43:29 -07001584
Ana Krulecc2870422019-01-29 19:00:58 -08001585 mScheduler->resyncToHardwareVsync(false, vsyncPeriod);
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001586
Lloyd Piquef1c675b2018-09-12 20:45:39 -07001587 mRepaintEverything = true;
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001588 setTransactionFlags(eDisplayTransactionNeeded);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001589}
1590
Ady Abraham11579302019-09-19 12:35:58 -07001591bool SurfaceFlinger::previousFrameMissed(int graceTimeMs) NO_THREAD_SAFETY_ANALYSIS {
1592 ATRACE_CALL();
Ady Abrahambe0f9482019-04-24 15:41:53 -07001593 // We are storing the last 2 present fences. If sf's phase offset is to be
1594 // woken up before the actual vsync but targeting the next vsync, we need to check
1595 // fence N-2
1596 const sp<Fence>& fence =
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001597 mVSyncModulator->getOffsets().sf < mPhaseOffsets->getOffsetThresholdForNextVsync()
Ady Abrahambe0f9482019-04-24 15:41:53 -07001598 ? mPreviousPresentFences[0]
1599 : mPreviousPresentFences[1];
1600
Ady Abraham11579302019-09-19 12:35:58 -07001601 if (fence == Fence::NO_FENCE) {
1602 return false;
1603 }
1604
1605 if (graceTimeMs > 0 && fence->getStatus() == Fence::Status::Unsignaled) {
1606 fence->wait(graceTimeMs);
1607 }
1608
1609 return (fence->getStatus() == Fence::Status::Unsignaled);
Ady Abrahambe0f9482019-04-24 15:41:53 -07001610}
1611
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07001612void SurfaceFlinger::populateExpectedPresentTime() {
Alec Mouriaa614192019-06-06 13:28:34 -07001613 DisplayStatInfo stats;
1614 mScheduler->getDisplayStatInfo(&stats);
Ady Abraham8fe11022019-06-12 17:11:12 -07001615 const nsecs_t presentTime = mScheduler->getDispSyncExpectedPresentTime();
Alec Mouriaa614192019-06-06 13:28:34 -07001616 // Inflate the expected present time if we're targetting the next vsync.
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001617 mExpectedPresentTime.store(mVSyncModulator->getOffsets().sf <
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07001618 mPhaseOffsets->getOffsetThresholdForNextVsync()
1619 ? presentTime
1620 : presentTime + stats.vsyncPeriod);
Alec Mouriaa614192019-06-06 13:28:34 -07001621}
1622
Dominik Laskowski22488f62019-03-28 09:53:04 -07001623void SurfaceFlinger::onMessageReceived(int32_t what) NO_THREAD_SAFETY_ANALYSIS {
Jamie Gennis1c8e95c2012-02-23 19:27:23 -08001624 ATRACE_CALL();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001625 switch (what) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08001626 case MessageQueue::INVALIDATE: {
Ady Abraham7c03ce62019-07-19 10:59:45 -07001627 // calculate the expected present time once and use the cached
1628 // value throughout this frame to make sure all layers are
1629 // seeing this same value.
1630 populateExpectedPresentTime();
1631
Ady Abraham11579302019-09-19 12:35:58 -07001632 // When Backpressure propagation is enabled we want to give a small grace period
1633 // for the present fence to fire instead of just giving up on this frame to handle cases
1634 // where present fence is just about to get signaled.
1635 const int graceTimeForPresentFenceMs =
1636 (mPropagateBackpressure &&
1637 (mPropagateBackpressureClientComposition || !mHadClientComposition))
1638 ? 1
1639 : 0;
1640 const TracedOrdinal<bool> frameMissed = {"FrameMissed",
1641 previousFrameMissed(
1642 graceTimeForPresentFenceMs)};
Ady Abraham50204dd2019-07-19 15:47:11 -07001643 const TracedOrdinal<bool> hwcFrameMissed = {"HwcFrameMissed",
1644 mHadDeviceComposition && frameMissed};
1645 const TracedOrdinal<bool> gpuFrameMissed = {"GpuFrameMissed",
1646 mHadClientComposition && frameMissed};
1647
Alec Mouricc0fc602019-02-26 21:45:19 -08001648 if (frameMissed) {
1649 mFrameMissedCount++;
1650 mTimeStats->incrementMissedFrames();
1651 }
1652
Alec Mouri40189b02019-03-05 15:07:54 -08001653 if (hwcFrameMissed) {
1654 mHwcFrameMissedCount++;
1655 }
1656
1657 if (gpuFrameMissed) {
1658 mGpuFrameMissedCount++;
1659 }
1660
Ana Krulecfefd6ae2019-02-13 17:53:08 -08001661 if (mUseSmart90ForVideo) {
1662 // This call is made each time SF wakes up and creates a new frame. It is part
1663 // of video detection feature.
Ady Abraham09bd3922019-04-08 10:44:56 -07001664 mScheduler->updateFpsBasedOnContent();
Ana Krulecfefd6ae2019-02-13 17:53:08 -08001665 }
1666
Ady Abrahamb838aed2019-02-12 15:30:16 -08001667 if (performSetActiveConfig()) {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001668 break;
1669 }
1670
Ady Abrahamadb9a992019-09-19 21:21:55 +00001671 if (frameMissed && mPropagateBackpressure) {
1672 if ((hwcFrameMissed && !gpuFrameMissed) ||
1673 mPropagateBackpressureClientComposition) {
Yiwei Zhang621f9d42018-05-07 10:40:55 -07001674 signalLayerUpdate();
1675 break;
1676 }
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07001677 }
Dan Stoza50182882016-07-08 12:02:20 -07001678
Steven Thomas050b2c82017-03-06 11:45:16 -08001679 // Now that we're going to make it to the handleMessageTransaction()
1680 // call below it's safe to call updateVrFlinger(), which will
1681 // potentially trigger a display handoff.
1682 updateVrFlinger();
1683
Dan Stoza6b9454d2014-11-07 16:00:59 -08001684 bool refreshNeeded = handleMessageTransaction();
1685 refreshNeeded |= handleMessageInvalidate();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001686
1687 updateCursorAsync();
1688 updateInputFlinger();
1689
Dan Stoza58784442014-12-02 16:58:17 -08001690 refreshNeeded |= mRepaintEverything;
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08001691 if (refreshNeeded && CC_LIKELY(mBootStage != BootStage::BOOTLOADER)) {
Dan Stoza58784442014-12-02 16:58:17 -08001692 // Signal a refresh if a transaction modified the window state,
1693 // a new buffer was latched, or if HWC has requested a full
1694 // repaint
Dan Stoza6b9454d2014-11-07 16:00:59 -08001695 signalRefresh();
1696 }
1697 break;
1698 }
1699 case MessageQueue::REFRESH: {
1700 handleMessageRefresh();
1701 break;
1702 }
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001703 }
1704}
1705
Dan Stoza6b9454d2014-11-07 16:00:59 -08001706bool SurfaceFlinger::handleMessageTransaction() {
Alec Mourife3dc942019-02-12 14:19:18 -08001707 ATRACE_CALL();
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08001708 uint32_t transactionFlags = peekTransactionFlags();
Marissa Wall713b63f2018-10-17 15:42:43 -07001709
Marissa Walle6e3c0d2019-03-29 10:28:30 -07001710 bool flushedATransaction = flushTransactionQueues();
1711
1712 bool runHandleTransaction = transactionFlags &&
1713 ((transactionFlags != eTransactionFlushNeeded) || flushedATransaction);
1714
1715 if (runHandleTransaction) {
1716 handleTransaction(eTransactionMask);
1717 } else {
1718 getTransactionFlags(eTransactionFlushNeeded);
Marissa Wall713b63f2018-10-17 15:42:43 -07001719 }
1720
Marissa Walle6e3c0d2019-03-29 10:28:30 -07001721 if (transactionFlushNeeded()) {
1722 setTransactionFlags(eTransactionFlushNeeded);
Mathias Agopian4fec8732012-06-29 14:12:52 -07001723 }
Marissa Wall713b63f2018-10-17 15:42:43 -07001724
Marissa Walle6e3c0d2019-03-29 10:28:30 -07001725 return runHandleTransaction;
Mathias Agopian4fec8732012-06-29 14:12:52 -07001726}
1727
Mathias Agopian4fec8732012-06-29 14:12:52 -07001728void SurfaceFlinger::handleMessageRefresh() {
Mathias Agopiancd60f992012-08-16 16:28:27 -07001729 ATRACE_CALL();
Dan Stoza14cd37c2015-07-09 12:43:33 -07001730
Dan Stoza2b6d38e2017-06-01 16:40:30 -07001731 mRefreshPending = false;
1732
Lloyd Piqueab039b52019-02-13 14:22:42 -08001733 compositionengine::CompositionRefreshArgs refreshArgs;
Lloyd Piquec29e4c62019-03-07 21:48:19 -08001734 refreshArgs.outputs.reserve(mDisplays.size());
Lloyd Piqueab039b52019-02-13 14:22:42 -08001735 for (const auto& [_, display] : mDisplays) {
1736 refreshArgs.outputs.push_back(display->getCompositionDisplay());
1737 }
1738 mDrawingState.traverseInZOrder([&refreshArgs](Layer* layer) {
1739 auto compositionLayer = layer->getCompositionLayer();
1740 if (compositionLayer) refreshArgs.layers.push_back(compositionLayer);
1741 });
Lloyd Piquec29e4c62019-03-07 21:48:19 -08001742 refreshArgs.layersWithQueuedFrames.reserve(mLayersWithQueuedFrames.size());
1743 for (sp<Layer> layer : mLayersWithQueuedFrames) {
1744 auto compositionLayer = layer->getCompositionLayer();
1745 if (compositionLayer) refreshArgs.layersWithQueuedFrames.push_back(compositionLayer.get());
1746 }
1747
Lloyd Piquef8cf14d2019-02-28 16:03:12 -08001748 refreshArgs.repaintEverything = mRepaintEverything.exchange(false);
Lloyd Pique6a3b4462019-03-07 20:58:12 -08001749 refreshArgs.outputColorSetting = useColorManagement
1750 ? mDisplayColorSetting
1751 : compositionengine::OutputColorSetting::kUnmanaged;
1752 refreshArgs.colorSpaceAgnosticDataspace = mColorSpaceAgnosticDataspace;
1753 refreshArgs.forceOutputColorMode = mForceColorMode;
Lloyd Piquec29e4c62019-03-07 21:48:19 -08001754
1755 refreshArgs.updatingOutputGeometryThisFrame = mVisibleRegionsDirty;
1756 refreshArgs.updatingGeometryThisFrame = mGeometryInvalid || mVisibleRegionsDirty;
Lloyd Pique3eb1b212019-03-07 21:15:40 -08001757
1758 if (CC_UNLIKELY(mDrawingState.colorMatrixChanged)) {
1759 refreshArgs.colorTransformMatrix = mDrawingState.colorMatrix;
1760 mDrawingState.colorMatrixChanged = false;
1761 }
1762
1763 refreshArgs.devOptForceClientComposition = mDebugDisableHWC || mDebugRegion;
1764
Lloyd Piquef8cf14d2019-02-28 16:03:12 -08001765 if (mDebugRegion != 0) {
1766 refreshArgs.devOptFlashDirtyRegionsDelay =
1767 std::chrono::milliseconds(mDebugRegion > 1 ? mDebugRegion : 0);
1768 }
Lloyd Piqueab039b52019-02-13 14:22:42 -08001769
Lloyd Pique3eb1b212019-03-07 21:15:40 -08001770 mGeometryInvalid = false;
1771
Lloyd Piquec29e4c62019-03-07 21:48:19 -08001772 mCompositionEngine->present(refreshArgs);
1773
David Sodmanfa9b2af2017-12-24 13:28:59 -08001774 postFrame();
David Sodman2b406362017-12-15 13:33:47 -08001775 postComposition();
Dan Stoza05dacfb2016-07-01 13:33:38 -07001776
Lloyd Pique66d68602019-02-13 14:23:31 -08001777 mHadClientComposition =
1778 std::any_of(mDisplays.cbegin(), mDisplays.cend(), [](const auto& tokenDisplayPair) {
1779 auto& displayDevice = tokenDisplayPair.second;
1780 return displayDevice->getCompositionDisplay()->getState().usesClientComposition;
1781 });
1782 mHadDeviceComposition =
1783 std::any_of(mDisplays.cbegin(), mDisplays.cend(), [](const auto& tokenDisplayPair) {
1784 auto& displayDevice = tokenDisplayPair.second;
1785 return displayDevice->getCompositionDisplay()->getState().usesDeviceComposition;
1786 });
David Sodmanfa9b2af2017-12-24 13:28:59 -08001787
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001788 mVSyncModulator->onRefreshed(mHadClientComposition);
Dan Stoza14cd37c2015-07-09 12:43:33 -07001789
David Sodman7e4ae112018-02-09 15:02:28 -08001790 mLayersWithQueuedFrames.clear();
Vishnu Nairdf529052019-06-07 14:53:14 -07001791 if (mVisibleRegionsDirty) {
1792 mVisibleRegionsDirty = false;
1793 if (mTracingEnabled) {
1794 mTracing.notify("visibleRegionsDirty");
1795 }
1796 }
Lloyd Piqueab039b52019-02-13 14:22:42 -08001797
1798 if (mCompositionEngine->needsAnotherUpdate()) {
1799 signalLayerUpdate();
1800 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07001801}
Mathias Agopian4fec8732012-06-29 14:12:52 -07001802
David Sodmanfa9b2af2017-12-24 13:28:59 -08001803
1804bool SurfaceFlinger::handleMessageInvalidate() {
1805 ATRACE_CALL();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001806 bool refreshNeeded = handlePageFlip();
1807
Vishnu Nair4351ad52019-02-11 14:13:02 -08001808 if (mVisibleRegionsDirty) {
1809 computeLayerBounds();
1810 }
1811
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001812 for (auto& layer : mLayersPendingRefresh) {
1813 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08001814 visibleReg.set(layer->getScreenBounds());
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001815 invalidateLayerStack(layer, visibleReg);
1816 }
1817 mLayersPendingRefresh.clear();
1818 return refreshNeeded;
Mathias Agopian4fec8732012-06-29 14:12:52 -07001819}
1820
Ana Krulece588e312018-09-18 12:32:24 -07001821void SurfaceFlinger::updateCompositorTiming(const DisplayStatInfo& stats, nsecs_t compositeTime,
1822 std::shared_ptr<FenceTime>& presentFenceTime) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001823 // Update queue of past composite+present times and determine the
1824 // most recently known composite to present latency.
David Sodman99974d22017-11-28 12:04:33 -08001825 getBE().mCompositePresentTimes.push({compositeTime, presentFenceTime});
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001826 nsecs_t compositeToPresentLatency = -1;
David Sodman99974d22017-11-28 12:04:33 -08001827 while (!getBE().mCompositePresentTimes.empty()) {
1828 SurfaceFlingerBE::CompositePresentTime& cpt = getBE().mCompositePresentTimes.front();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001829 // Cached values should have been updated before calling this method,
1830 // which helps avoid duplicate syscalls.
1831 nsecs_t displayTime = cpt.display->getCachedSignalTime();
1832 if (displayTime == Fence::SIGNAL_TIME_PENDING) {
1833 break;
1834 }
1835 compositeToPresentLatency = displayTime - cpt.composite;
David Sodman99974d22017-11-28 12:04:33 -08001836 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001837 }
1838
1839 // Don't let mCompositePresentTimes grow unbounded, just in case.
David Sodman99974d22017-11-28 12:04:33 -08001840 while (getBE().mCompositePresentTimes.size() > 16) {
1841 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001842 }
1843
Ana Krulece588e312018-09-18 12:32:24 -07001844 setCompositorTimingSnapped(stats, compositeToPresentLatency);
Brian Andersond0010582017-03-07 13:20:31 -08001845}
1846
Ana Krulece588e312018-09-18 12:32:24 -07001847void SurfaceFlinger::setCompositorTimingSnapped(const DisplayStatInfo& stats,
1848 nsecs_t compositeToPresentLatency) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001849 // Integer division and modulo round toward 0 not -inf, so we need to
1850 // treat negative and positive offsets differently.
Ana Krulec757f63a2019-01-25 10:46:18 -08001851 nsecs_t idealLatency = (mPhaseOffsets->getCurrentSfOffset() > 0)
1852 ? (stats.vsyncPeriod - (mPhaseOffsets->getCurrentSfOffset() % stats.vsyncPeriod))
1853 : ((-mPhaseOffsets->getCurrentSfOffset()) % stats.vsyncPeriod);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001854
Ana Krulec757f63a2019-01-25 10:46:18 -08001855 // Just in case mPhaseOffsets->getCurrentSfOffset() == -vsyncInterval.
Brian Andersond0010582017-03-07 13:20:31 -08001856 if (idealLatency <= 0) {
Ana Krulece588e312018-09-18 12:32:24 -07001857 idealLatency = stats.vsyncPeriod;
Brian Andersond0010582017-03-07 13:20:31 -08001858 }
1859
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001860 // Snap the latency to a value that removes scheduling jitter from the
1861 // composition and present times, which often have >1ms of jitter.
1862 // Reducing jitter is important if an app attempts to extrapolate
1863 // something (such as user input) to an accurate diasplay time.
Ana Krulec757f63a2019-01-25 10:46:18 -08001864 // Snapping also allows an app to precisely calculate mPhaseOffsets->getCurrentSfOffset()
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001865 // with (presentLatency % interval).
Ana Krulece588e312018-09-18 12:32:24 -07001866 nsecs_t bias = stats.vsyncPeriod / 2;
1867 int64_t extraVsyncs = (compositeToPresentLatency - idealLatency + bias) / stats.vsyncPeriod;
1868 nsecs_t snappedCompositeToPresentLatency =
1869 (extraVsyncs > 0) ? idealLatency + (extraVsyncs * stats.vsyncPeriod) : idealLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001870
David Sodman99974d22017-11-28 12:04:33 -08001871 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
Ana Krulece588e312018-09-18 12:32:24 -07001872 getBE().mCompositorTiming.deadline = stats.vsyncTime - idealLatency;
1873 getBE().mCompositorTiming.interval = stats.vsyncPeriod;
David Sodman99974d22017-11-28 12:04:33 -08001874 getBE().mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001875}
1876
David Sodman2b406362017-12-15 13:33:47 -08001877void SurfaceFlinger::postComposition()
Mathias Agopiancd60f992012-08-16 16:28:27 -07001878{
Dan Stoza9e56aa02015-11-02 13:00:03 -08001879 ATRACE_CALL();
1880 ALOGV("postComposition");
1881
Brian Anderson3546a3f2016-07-14 11:51:14 -07001882 // Release any buffers which were replaced this frame
Brian Andersonf6386862016-10-31 16:34:13 -07001883 nsecs_t dequeueReadyTime = systemTime();
Brian Anderson3546a3f2016-07-14 11:51:14 -07001884 for (auto& layer : mLayersWithQueuedFrames) {
Brian Andersonf6386862016-10-31 16:34:13 -07001885 layer->releasePendingBuffer(dequeueReadyTime);
Brian Anderson3546a3f2016-07-14 11:51:14 -07001886 }
1887
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001888 // |mStateLock| not needed as we are on the main thread
Lloyd Pique32cbe282018-10-19 13:09:22 -07001889 const auto displayDevice = getDefaultDisplayDeviceLocked();
Brian Anderson3d4039d2016-09-23 16:31:30 -07001890
David Sodman73beded2017-11-15 11:56:06 -08001891 getBE().mGlCompositionDoneTimeline.updateSignalTimes();
Brian Anderson3d4039d2016-09-23 16:31:30 -07001892 std::shared_ptr<FenceTime> glCompositionDoneFenceTime;
Lloyd Pique66d68602019-02-13 14:23:31 -08001893 if (displayDevice && displayDevice->getCompositionDisplay()->getState().usesClientComposition) {
Brian Anderson3d4039d2016-09-23 16:31:30 -07001894 glCompositionDoneFenceTime =
Lloyd Pique31cb2942018-10-19 17:23:03 -07001895 std::make_shared<FenceTime>(displayDevice->getCompositionDisplay()
1896 ->getRenderSurface()
1897 ->getClientTargetAcquireFence());
David Sodman73beded2017-11-15 11:56:06 -08001898 getBE().mGlCompositionDoneTimeline.push(glCompositionDoneFenceTime);
Brian Anderson3d4039d2016-09-23 16:31:30 -07001899 } else {
1900 glCompositionDoneFenceTime = FenceTime::NO_FENCE;
1901 }
Brian Anderson3d4039d2016-09-23 16:31:30 -07001902
David Sodman73beded2017-11-15 11:56:06 -08001903 getBE().mDisplayTimeline.updateSignalTimes();
Ady Abrahambe0f9482019-04-24 15:41:53 -07001904 mPreviousPresentFences[1] = mPreviousPresentFences[0];
1905 mPreviousPresentFences[0] = displayDevice
1906 ? getHwComposer().getPresentFence(*displayDevice->getId())
1907 : Fence::NO_FENCE;
1908 auto presentFenceTime = std::make_shared<FenceTime>(mPreviousPresentFences[0]);
David Sodman73beded2017-11-15 11:56:06 -08001909 getBE().mDisplayTimeline.push(presentFenceTime);
Brian Anderson3d4039d2016-09-23 16:31:30 -07001910
Ana Krulece588e312018-09-18 12:32:24 -07001911 DisplayStatInfo stats;
Ana Krulecc2870422019-01-29 19:00:58 -08001912 mScheduler->getDisplayStatInfo(&stats);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001913
Lloyd Piqueab039b52019-02-13 14:22:42 -08001914 // We use the CompositionEngine::getLastFrameRefreshTimestamp() which might
1915 // be sampled a little later than when we started doing work for this frame,
1916 // but that should be okay since updateCompositorTiming has snapping logic.
1917 updateCompositorTiming(stats, mCompositionEngine->getLastFrameRefreshTimestamp(),
1918 presentFenceTime);
Brian Andersond0010582017-03-07 13:20:31 -08001919 CompositorTiming compositorTiming;
1920 {
David Sodman99974d22017-11-28 12:04:33 -08001921 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
1922 compositorTiming = getBE().mCompositorTiming;
Brian Andersond0010582017-03-07 13:20:31 -08001923 }
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001924
Robert Carr2047fae2016-11-28 14:09:09 -08001925 mDrawingState.traverseInZOrder([&](Layer* layer) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07001926 bool frameLatched =
1927 layer->onPostComposition(displayDevice->getId(), glCompositionDoneFenceTime,
1928 presentFenceTime, compositorTiming);
Dan Stozae77c7662016-05-13 11:37:28 -07001929 if (frameLatched) {
Robert Carr2047fae2016-11-28 14:09:09 -08001930 recordBufferingStats(layer->getName().string(),
1931 layer->getOccupancyHistory(false));
Dan Stozae77c7662016-05-13 11:37:28 -07001932 }
Robert Carr2047fae2016-11-28 14:09:09 -08001933 });
Jamie Gennis4b0eba92013-02-05 13:30:24 -08001934
Brian Andersonfbc80ae2017-05-26 16:23:54 -07001935 if (presentFenceTime->isValid()) {
Ana Krulecc2870422019-01-29 19:00:58 -08001936 mScheduler->addPresentFence(presentFenceTime);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001937 }
1938
Fabien Sanglardcbf153b2017-03-10 17:57:12 -08001939 if (!hasSyncFramework) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07001940 if (displayDevice && getHwComposer().isConnected(*displayDevice->getId()) &&
1941 displayDevice->isPoweredOn()) {
Ana Krulecc2870422019-01-29 19:00:58 -08001942 mScheduler->enableHardwareVsync();
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001943 }
1944 }
1945
Jamie Gennis4b0eba92013-02-05 13:30:24 -08001946 if (mAnimCompositionPending) {
1947 mAnimCompositionPending = false;
1948
Brian Anderson4e606e32017-03-16 15:34:57 -07001949 if (presentFenceTime->isValid()) {
Brian Anderson3d4039d2016-09-23 16:31:30 -07001950 mAnimFrameTracker.setActualPresentFence(
Brian Anderson4e606e32017-03-16 15:34:57 -07001951 std::move(presentFenceTime));
Lloyd Pique32cbe282018-10-19 13:09:22 -07001952 } else if (displayDevice && getHwComposer().isConnected(*displayDevice->getId())) {
Jamie Gennis4b0eba92013-02-05 13:30:24 -08001953 // The HWC doesn't support present fences, so use the refresh
1954 // timestamp instead.
Lloyd Pique32cbe282018-10-19 13:09:22 -07001955 const nsecs_t presentTime =
1956 getHwComposer().getRefreshTimestamp(*displayDevice->getId());
Jamie Gennis4b0eba92013-02-05 13:30:24 -08001957 mAnimFrameTracker.setActualPresentTime(presentTime);
1958 }
1959 mAnimFrameTracker.advanceFrame();
1960 }
Dan Stozab90cf072015-03-05 11:05:59 -08001961
Yiwei Zhang7e666a52018-11-15 13:33:42 -08001962 mTimeStats->incrementTotalFrames();
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07001963 if (mHadClientComposition) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08001964 mTimeStats->incrementClientCompositionFrames();
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07001965 }
1966
Yiwei Zhang7e666a52018-11-15 13:33:42 -08001967 mTimeStats->setPresentFenceGlobal(presentFenceTime);
Yiwei Zhangce6ebc02018-10-20 12:42:38 -07001968
Lloyd Pique32cbe282018-10-19 13:09:22 -07001969 if (displayDevice && getHwComposer().isConnected(*displayDevice->getId()) &&
1970 !displayDevice->isPoweredOn()) {
Dan Stozab90cf072015-03-05 11:05:59 -08001971 return;
1972 }
1973
1974 nsecs_t currentTime = systemTime();
1975 if (mHasPoweredOff) {
1976 mHasPoweredOff = false;
1977 } else {
David Sodman4a36e932017-11-07 14:29:47 -08001978 nsecs_t elapsedTime = currentTime - getBE().mLastSwapTime;
Ana Krulece588e312018-09-18 12:32:24 -07001979 size_t numPeriods = static_cast<size_t>(elapsedTime / stats.vsyncPeriod);
David Sodman4a36e932017-11-07 14:29:47 -08001980 if (numPeriods < SurfaceFlingerBE::NUM_BUCKETS - 1) {
1981 getBE().mFrameBuckets[numPeriods] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08001982 } else {
David Sodman4a36e932017-11-07 14:29:47 -08001983 getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08001984 }
David Sodman4a36e932017-11-07 14:29:47 -08001985 getBE().mTotalTime += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08001986 }
David Sodman4a36e932017-11-07 14:29:47 -08001987 getBE().mLastSwapTime = currentTime;
Dan Stoza436ccf32018-06-21 12:10:12 -07001988
1989 {
1990 std::lock_guard lock(mTexturePoolMutex);
Dan Stoza67765d82019-05-07 14:58:27 -07001991 if (mTexturePool.size() < mTexturePoolSize) {
1992 const size_t refillCount = mTexturePoolSize - mTexturePool.size();
Dan Stoza436ccf32018-06-21 12:10:12 -07001993 const size_t offset = mTexturePool.size();
1994 mTexturePool.resize(mTexturePoolSize);
1995 getRenderEngine().genTextures(refillCount, mTexturePool.data() + offset);
1996 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Dan Stoza67765d82019-05-07 14:58:27 -07001997 } else if (mTexturePool.size() > mTexturePoolSize) {
1998 const size_t deleteCount = mTexturePool.size() - mTexturePoolSize;
1999 const size_t offset = mTexturePoolSize;
2000 getRenderEngine().deleteTextures(deleteCount, mTexturePool.data() + offset);
2001 mTexturePool.resize(mTexturePoolSize);
2002 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Dan Stoza436ccf32018-06-21 12:10:12 -07002003 }
2004 }
Marissa Walle2ffb422018-10-12 11:33:52 -07002005
Ady Abrahambe0f9482019-04-24 15:41:53 -07002006 mTransactionCompletedThread.addPresentFence(mPreviousPresentFences[0]);
Marissa Wallefb71af2019-06-27 14:45:53 -07002007 mTransactionCompletedThread.sendCallbacks();
Ady Abraham8164d482019-01-11 14:47:59 -08002008
Kevin DuBois413287f2019-02-25 08:46:47 -08002009 if (mLumaSampling && mRegionSamplingThread) {
2010 mRegionSamplingThread->notifyNewContent();
Dan Stozaec460082018-12-17 15:35:09 -08002011 }
Dan Stoza45de5ba2019-04-25 14:12:09 -07002012
2013 // Even though ATRACE_INT64 already checks if tracing is enabled, it doesn't prevent the
2014 // side-effect of getTotalSize(), so we check that again here
2015 if (ATRACE_ENABLED()) {
2016 ATRACE_INT64("Total Buffer Size", GraphicBufferAllocator::get().getTotalSize());
2017 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07002018}
2019
Vishnu Nair4351ad52019-02-11 14:13:02 -08002020void SurfaceFlinger::computeLayerBounds() {
2021 for (const auto& pair : mDisplays) {
2022 const auto& displayDevice = pair.second;
2023 const auto display = displayDevice->getCompositionDisplay();
2024 for (const auto& layer : mDrawingState.layersSortedByZ) {
2025 // only consider the layers on the given layer stack
2026 if (!display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
Vishnu Nair01ace762019-02-12 14:25:24 -08002027 continue;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002028 }
2029
2030 layer->computeBounds(displayDevice->getViewport().toFloatRect(), ui::Transform());
2031 }
2032 }
2033}
2034
David Sodmanfa9b2af2017-12-24 13:28:59 -08002035void SurfaceFlinger::postFrame()
2036{
2037 // |mStateLock| not needed as we are on the main thread
Dominik Laskowski075d3172018-05-24 15:50:06 -07002038 const auto display = getDefaultDisplayDeviceLocked();
2039 if (display && getHwComposer().isConnected(*display->getId())) {
2040 uint32_t flipCount = display->getPageFlipCount();
David Sodmanfa9b2af2017-12-24 13:28:59 -08002041 if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
2042 logFrameStats();
2043 }
2044 }
2045}
2046
Mathias Agopian87baae12012-07-31 12:38:26 -07002047void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002048{
Mathias Agopian841cde52012-03-01 15:44:37 -08002049 ATRACE_CALL();
2050
Mathias Agopian7cc6df52013-06-05 14:30:54 -07002051 // here we keep a copy of the drawing state (that is the state that's
2052 // going to be overwritten by handleTransactionLocked()) outside of
2053 // mStateLock so that the side-effects of the State assignment
2054 // don't happen with mStateLock held (which can cause deadlocks).
2055 State drawingState(mDrawingState);
2056
Mathias Agopianca4d3602011-05-19 15:38:14 -07002057 Mutex::Autolock _l(mStateLock);
Dominik Laskowski9dab3432019-03-27 13:21:10 -07002058 mDebugInTransaction = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002059
Mathias Agopianca4d3602011-05-19 15:38:14 -07002060 // Here we're guaranteed that some transaction flags are set
2061 // so we can call handleTransactionLocked() unconditionally.
2062 // We call getTransactionFlags(), which will also clear the flags,
2063 // with mStateLock held to guarantee that mCurrentState won't change
2064 // until the transaction is committed.
Mathias Agopian4da75192010-08-10 17:19:56 -07002065
Dominik Laskowskieddeda12019-07-19 11:54:13 -07002066 mVSyncModulator->onTransactionHandled();
Mathias Agopiane57f2922012-08-09 16:29:12 -07002067 transactionFlags = getTransactionFlags(eTransactionMask);
Mathias Agopian87baae12012-07-31 12:38:26 -07002068 handleTransactionLocked(transactionFlags);
Mathias Agopiandea20b12011-05-03 17:04:02 -07002069
Mathias Agopianca4d3602011-05-19 15:38:14 -07002070 mDebugInTransaction = 0;
2071 invalidateHwcGeometry();
2072 // here the transaction has been committed
Mathias Agopian3d579642009-06-04 18:46:21 -07002073}
2074
Lloyd Piqueba04e622017-12-14 17:11:26 -08002075void SurfaceFlinger::processDisplayHotplugEventsLocked() {
2076 for (const auto& event : mPendingHotplugEvents) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002077 const std::optional<DisplayIdentificationInfo> info =
2078 getHwComposer().onHotplug(event.hwcDisplayId, event.connection);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002079
Dominik Laskowski075d3172018-05-24 15:50:06 -07002080 if (!info) {
Lloyd Piqueba04e622017-12-14 17:11:26 -08002081 continue;
2082 }
2083
Lloyd Piqueba04e622017-12-14 17:11:26 -08002084 if (event.connection == HWC2::Connection::Connected) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002085 if (!mPhysicalDisplayTokens.count(info->id)) {
Dominik Laskowski34157762018-10-31 13:07:19 -07002086 ALOGV("Creating display %s", to_string(info->id).c_str());
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002087 if (event.hwcDisplayId == getHwComposer().getInternalHwcDisplayId()) {
2088 initScheduler(info->id);
2089 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07002090 mPhysicalDisplayTokens[info->id] = new BBinder();
2091 DisplayDeviceState state;
2092 state.displayId = info->id;
2093 state.isSecure = true; // All physical displays are currently considered secure.
2094 state.displayName = info->name;
2095 mCurrentState.displays.add(mPhysicalDisplayTokens[info->id], state);
2096 mInterceptor->saveDisplayCreation(state);
Steven Thomaseb6d2052018-03-20 15:40:48 -07002097 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08002098 } else {
Dominik Laskowski34157762018-10-31 13:07:19 -07002099 ALOGV("Removing display %s", to_string(info->id).c_str());
Lloyd Piqueba04e622017-12-14 17:11:26 -08002100
Dominik Laskowski075d3172018-05-24 15:50:06 -07002101 ssize_t index = mCurrentState.displays.indexOfKey(mPhysicalDisplayTokens[info->id]);
2102 if (index >= 0) {
2103 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
2104 mInterceptor->saveDisplayDeletion(state.sequenceId);
2105 mCurrentState.displays.removeItemsAt(index);
Lloyd Piquefcd86612017-12-14 17:15:36 -08002106 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07002107 mPhysicalDisplayTokens.erase(info->id);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002108 }
2109
2110 processDisplayChangesLocked();
2111 }
2112
2113 mPendingHotplugEvents.clear();
2114}
2115
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002116void SurfaceFlinger::dispatchDisplayHotplugEvent(PhysicalDisplayId displayId, bool connected) {
Dominik Laskowski98041832019-08-01 18:35:59 -07002117 mScheduler->onHotplugReceived(mAppConnectionHandle, displayId, connected);
2118 mScheduler->onHotplugReceived(mSfConnectionHandle, displayId, connected);
Dominik Laskowski1eba0202019-01-24 09:14:40 -08002119}
2120
Lloyd Pique99d3da52018-01-22 17:48:03 -08002121sp<DisplayDevice> SurfaceFlinger::setupNewDisplayDeviceInternal(
Dominik Laskowski075d3172018-05-24 15:50:06 -07002122 const wp<IBinder>& displayToken, const std::optional<DisplayId>& displayId,
Lloyd Pique542307f2018-10-19 13:24:08 -07002123 const DisplayDeviceState& state, const sp<compositionengine::DisplaySurface>& dispSurface,
Dominik Laskowski075d3172018-05-24 15:50:06 -07002124 const sp<IGraphicBufferProducer>& producer) {
2125 DisplayDeviceCreationArgs creationArgs(this, displayToken, displayId);
Dominik Laskowskie9774092018-12-11 10:04:24 -08002126 creationArgs.sequenceId = state.sequenceId;
Dominik Laskowski075d3172018-05-24 15:50:06 -07002127 creationArgs.isVirtual = state.isVirtual();
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002128 creationArgs.isSecure = state.isSecure;
2129 creationArgs.displaySurface = dispSurface;
2130 creationArgs.hasWideColorGamut = false;
2131 creationArgs.supportedPerFrameMetadata = 0;
Lloyd Pique688abd42019-02-15 15:42:24 -08002132 creationArgs.powerAdvisor = displayId ? &mPowerAdvisor : nullptr;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002133
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002134 const bool isInternalDisplay = displayId && displayId == getInternalDisplayIdLocked();
Dominik Laskowski075d3172018-05-24 15:50:06 -07002135 creationArgs.isPrimary = isInternalDisplay;
2136
2137 if (useColorManagement && displayId) {
2138 std::vector<ColorMode> modes = getHwComposer().getColorModes(*displayId);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002139 for (ColorMode colorMode : modes) {
Peiyong Linfca547f2018-07-09 13:03:33 -07002140 if (isWideColorMode(colorMode)) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002141 creationArgs.hasWideColorGamut = true;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002142 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002143
Dominik Laskowski7e045462018-05-30 13:02:02 -07002144 std::vector<RenderIntent> renderIntents =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002145 getHwComposer().getRenderIntents(*displayId, colorMode);
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002146 creationArgs.hwcColorModes.emplace(colorMode, renderIntents);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002147 }
tangrobin6753a022018-08-10 10:58:54 +08002148 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002149
Dominik Laskowski075d3172018-05-24 15:50:06 -07002150 if (displayId) {
2151 getHwComposer().getHdrCapabilities(*displayId, &creationArgs.hdrCapabilities);
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002152 creationArgs.supportedPerFrameMetadata =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002153 getHwComposer().getSupportedPerFrameMetadata(*displayId);
Chia-I Wu0f509fb2018-06-21 15:52:50 +08002154 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002155
Lloyd Pique90c115d2018-09-18 21:39:42 -07002156 auto nativeWindowSurface = getFactory().createNativeWindowSurface(producer);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002157 auto nativeWindow = nativeWindowSurface->getNativeWindow();
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002158 creationArgs.nativeWindow = nativeWindow;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002159
Lloyd Pique99d3da52018-01-22 17:48:03 -08002160 // Make sure that composition can never be stalled by a virtual display
2161 // consumer that isn't processing buffers fast enough. We have to do this
Alec Mouri0a9c7b82018-11-16 13:05:25 -08002162 // here, in case the display is composed entirely by HWC.
Dominik Laskowski281644e2018-04-19 15:47:35 -07002163 if (state.isVirtual()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002164 nativeWindow->setSwapInterval(nativeWindow.get(), 0);
2165 }
2166
Dominik Laskowski075d3172018-05-24 15:50:06 -07002167 creationArgs.displayInstallOrientation =
2168 isInternalDisplay ? primaryDisplayOrientation : DisplayState::eOrientationDefault;
Chia-I Wua02871c2018-08-27 14:38:23 -07002169
Lloyd Pique99d3da52018-01-22 17:48:03 -08002170 // virtual displays are always considered enabled
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002171 creationArgs.initialPowerMode = state.isVirtual() ? HWC_POWER_MODE_NORMAL : HWC_POWER_MODE_OFF;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002172
Lloyd Pique90c115d2018-09-18 21:39:42 -07002173 sp<DisplayDevice> display = getFactory().createDisplayDevice(std::move(creationArgs));
Lloyd Pique99d3da52018-01-22 17:48:03 -08002174
2175 if (maxFrameBufferAcquiredBuffers >= 3) {
2176 nativeWindowSurface->preallocateBuffers();
2177 }
2178
2179 ColorMode defaultColorMode = ColorMode::NATIVE;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002180 Dataspace defaultDataSpace = Dataspace::UNKNOWN;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002181 if (display->hasWideColorGamut()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002182 defaultColorMode = ColorMode::SRGB;
Peiyong Lin14724e62018-12-05 07:27:30 -08002183 defaultDataSpace = Dataspace::V0_SRGB;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002184 }
Lloyd Pique6a3b4462019-03-07 20:58:12 -08002185 display->getCompositionDisplay()->setColorProfile(
2186 compositionengine::Output::ColorProfile{defaultColorMode, defaultDataSpace,
2187 RenderIntent::COLORIMETRIC,
2188 Dataspace::UNKNOWN});
Dominik Laskowski075d3172018-05-24 15:50:06 -07002189 if (!state.isVirtual()) {
2190 LOG_ALWAYS_FATAL_IF(!displayId);
2191 display->setActiveConfig(getHwComposer().getActiveConfigIndex(*displayId));
Lloyd Pique3c085a02018-05-09 19:38:32 -07002192 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07002193
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002194 display->setLayerStack(state.layerStack);
2195 display->setProjection(state.orientation, state.viewport, state.frame);
2196 display->setDisplayName(state.displayName);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002197
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002198 return display;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002199}
2200
Lloyd Pique347200f2017-12-14 17:00:15 -08002201void SurfaceFlinger::processDisplayChangesLocked() {
2202 // here we take advantage of Vector's copy-on-write semantics to
2203 // improve performance by skipping the transaction entirely when
2204 // know that the lists are identical
2205 const KeyedVector<wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
2206 const KeyedVector<wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
2207 if (!curr.isIdenticalTo(draw)) {
2208 mVisibleRegionsDirty = true;
2209 const size_t cc = curr.size();
2210 size_t dc = draw.size();
2211
2212 // find the displays that were removed
2213 // (ie: in drawing state but not in current state)
2214 // also handle displays that changed
2215 // (ie: displays that are in both lists)
2216 for (size_t i = 0; i < dc;) {
2217 const ssize_t j = curr.indexOfKey(draw.keyAt(i));
2218 if (j < 0) {
2219 // in drawing state but not in current state
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002220 if (const auto display = getDisplayDeviceLocked(draw.keyAt(i))) {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002221 // Save display ID before disconnecting.
2222 const auto displayId = display->getId();
Lloyd Pique45a165a2018-10-19 11:54:47 -07002223 display->disconnect();
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002224
2225 if (!display->isVirtual()) {
2226 LOG_ALWAYS_FATAL_IF(!displayId);
2227 dispatchDisplayHotplugEvent(displayId->value, false);
2228 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002229 }
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002230
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002231 mDisplays.erase(draw.keyAt(i));
Lloyd Pique347200f2017-12-14 17:00:15 -08002232 } else {
2233 // this display is in both lists. see if something changed.
2234 const DisplayDeviceState& state(curr[j]);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002235 const wp<IBinder>& displayToken = curr.keyAt(j);
Lloyd Pique347200f2017-12-14 17:00:15 -08002236 const sp<IBinder> state_binder = IInterface::asBinder(state.surface);
2237 const sp<IBinder> draw_binder = IInterface::asBinder(draw[i].surface);
2238 if (state_binder != draw_binder) {
2239 // changing the surface is like destroying and
2240 // recreating the DisplayDevice, so we just remove it
2241 // from the drawing state, so that it get re-added
2242 // below.
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002243 if (const auto display = getDisplayDeviceLocked(displayToken)) {
Lloyd Pique45a165a2018-10-19 11:54:47 -07002244 display->disconnect();
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002245 }
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002246 mDisplays.erase(displayToken);
Lloyd Pique347200f2017-12-14 17:00:15 -08002247 mDrawingState.displays.removeItemsAt(i);
2248 dc--;
2249 // at this point we must loop to the next item
2250 continue;
2251 }
2252
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002253 if (const auto display = getDisplayDeviceLocked(displayToken)) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002254 if (state.layerStack != draw[i].layerStack) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002255 display->setLayerStack(state.layerStack);
Lloyd Pique347200f2017-12-14 17:00:15 -08002256 }
2257 if ((state.orientation != draw[i].orientation) ||
2258 (state.viewport != draw[i].viewport) || (state.frame != draw[i].frame)) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002259 display->setProjection(state.orientation, state.viewport, state.frame);
Lloyd Pique347200f2017-12-14 17:00:15 -08002260 }
2261 if (state.width != draw[i].width || state.height != draw[i].height) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002262 display->setDisplaySize(state.width, state.height);
Lloyd Pique347200f2017-12-14 17:00:15 -08002263 }
2264 }
2265 }
2266 ++i;
2267 }
2268
2269 // find displays that were added
2270 // (ie: in current state but not in drawing state)
2271 for (size_t i = 0; i < cc; i++) {
2272 if (draw.indexOfKey(curr.keyAt(i)) < 0) {
2273 const DisplayDeviceState& state(curr[i]);
2274
Lloyd Pique542307f2018-10-19 13:24:08 -07002275 sp<compositionengine::DisplaySurface> dispSurface;
Lloyd Pique347200f2017-12-14 17:00:15 -08002276 sp<IGraphicBufferProducer> producer;
2277 sp<IGraphicBufferProducer> bqProducer;
2278 sp<IGraphicBufferConsumer> bqConsumer;
Lloyd Pique90c115d2018-09-18 21:39:42 -07002279 getFactory().createBufferQueue(&bqProducer, &bqConsumer, false);
Lloyd Pique347200f2017-12-14 17:00:15 -08002280
Dominik Laskowski075d3172018-05-24 15:50:06 -07002281 std::optional<DisplayId> displayId;
Dominik Laskowski663bd282018-04-19 15:26:54 -07002282 if (state.isVirtual()) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002283 // Virtual displays without a surface are dormant:
2284 // they have external state (layer stack, projection,
2285 // etc.) but no internal state (i.e. a DisplayDevice).
2286 if (state.surface != nullptr) {
2287 // Allow VR composer to use virtual displays.
Dominik Laskowski075d3172018-05-24 15:50:06 -07002288 if (mUseHwcVirtualDisplays || getHwComposer().isUsingVrComposer()) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002289 int width = 0;
2290 int status = state.surface->query(NATIVE_WINDOW_WIDTH, &width);
2291 ALOGE_IF(status != NO_ERROR, "Unable to query width (%d)", status);
2292 int height = 0;
2293 status = state.surface->query(NATIVE_WINDOW_HEIGHT, &height);
2294 ALOGE_IF(status != NO_ERROR, "Unable to query height (%d)", status);
2295 int intFormat = 0;
2296 status = state.surface->query(NATIVE_WINDOW_FORMAT, &intFormat);
2297 ALOGE_IF(status != NO_ERROR, "Unable to query format (%d)", status);
Peiyong Lin34beb7a2018-03-28 11:57:12 -07002298 auto format = static_cast<ui::PixelFormat>(intFormat);
Lloyd Pique347200f2017-12-14 17:00:15 -08002299
Dominik Laskowski075d3172018-05-24 15:50:06 -07002300 displayId =
2301 getHwComposer().allocateVirtualDisplay(width, height, &format);
Lloyd Pique347200f2017-12-14 17:00:15 -08002302 }
2303
2304 // TODO: Plumb requested format back up to consumer
2305
2306 sp<VirtualDisplaySurface> vds =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002307 new VirtualDisplaySurface(getHwComposer(), displayId, state.surface,
Lloyd Pique347200f2017-12-14 17:00:15 -08002308 bqProducer, bqConsumer,
2309 state.displayName);
2310
2311 dispSurface = vds;
2312 producer = vds;
2313 }
2314 } else {
2315 ALOGE_IF(state.surface != nullptr,
2316 "adding a supported display, but rendering "
2317 "surface is provided (%p), ignoring it",
2318 state.surface.get());
2319
Dominik Laskowski075d3172018-05-24 15:50:06 -07002320 displayId = state.displayId;
2321 LOG_ALWAYS_FATAL_IF(!displayId);
2322 dispSurface = new FramebufferSurface(getHwComposer(), *displayId, bqConsumer);
Lloyd Pique347200f2017-12-14 17:00:15 -08002323 producer = bqProducer;
2324 }
2325
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002326 const wp<IBinder>& displayToken = curr.keyAt(i);
Lloyd Pique347200f2017-12-14 17:00:15 -08002327 if (dispSurface != nullptr) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002328 mDisplays.emplace(displayToken,
Dominik Laskowski7e045462018-05-30 13:02:02 -07002329 setupNewDisplayDeviceInternal(displayToken, displayId, state,
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002330 dispSurface, producer));
Dominik Laskowski663bd282018-04-19 15:26:54 -07002331 if (!state.isVirtual()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002332 LOG_ALWAYS_FATAL_IF(!displayId);
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002333 dispatchDisplayHotplugEvent(displayId->value, true);
Lloyd Pique347200f2017-12-14 17:00:15 -08002334 }
2335 }
2336 }
2337 }
2338 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08002339
2340 mDrawingState.displays = mCurrentState.displays;
Lloyd Pique347200f2017-12-14 17:00:15 -08002341}
2342
Mathias Agopian87baae12012-07-31 12:38:26 -07002343void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
Mathias Agopian3d579642009-06-04 18:46:21 -07002344{
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07002345 const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
2346
Dan Stoza7dde5992015-05-22 09:51:44 -07002347 // Notify all layers of available frames
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07002348 mCurrentState.traverseInZOrder([expectedPresentTime](Layer* layer) {
2349 layer->notifyAvailableFrames(expectedPresentTime);
Robert Carr2047fae2016-11-28 14:09:09 -08002350 });
Dan Stoza7dde5992015-05-22 09:51:44 -07002351
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002352 /*
2353 * Traversal of the children
2354 * (perform the transaction for each of them if needed)
2355 */
2356
Marissa Wall06255332019-03-27 13:48:27 -07002357 if ((transactionFlags & eTraversalNeeded) || mTraversalNeededMainThread) {
Robert Carr2047fae2016-11-28 14:09:09 -08002358 mCurrentState.traverseInZOrder([&](Layer* layer) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002359 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
Robert Carr2047fae2016-11-28 14:09:09 -08002360 if (!trFlags) return;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002361
2362 const uint32_t flags = layer->doTransaction(0);
2363 if (flags & Layer::eVisibleRegion)
2364 mVisibleRegionsDirty = true;
Robert Carr720e5062018-07-30 17:45:14 -07002365
2366 if (flags & Layer::eInputInfoChanged) {
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002367 mInputInfoChanged = true;
Robert Carr720e5062018-07-30 17:45:14 -07002368 }
Robert Carr2047fae2016-11-28 14:09:09 -08002369 });
Marissa Wall06255332019-03-27 13:48:27 -07002370 mTraversalNeededMainThread = false;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002371 }
2372
2373 /*
Mathias Agopian3559b072012-08-15 13:46:03 -07002374 * Perform display own transactions if needed
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002375 */
2376
Mathias Agopiane57f2922012-08-09 16:29:12 -07002377 if (transactionFlags & eDisplayTransactionNeeded) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002378 processDisplayChangesLocked();
Lloyd Piqueba04e622017-12-14 17:11:26 -08002379 processDisplayHotplugEventsLocked();
Mathias Agopian3559b072012-08-15 13:46:03 -07002380 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002381
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002382 if (transactionFlags & (eDisplayLayerStackChanged|eDisplayTransactionNeeded)) {
Mathias Agopian84300952012-11-21 16:02:13 -08002383 // The transform hint might have changed for some layers
2384 // (either because a display has changed, or because a layer
2385 // as changed).
2386 //
2387 // Walk through all the layers in currentLayers,
2388 // and update their transform hint.
2389 //
2390 // If a layer is visible only on a single display, then that
2391 // display is used to calculate the hint, otherwise we use the
2392 // default display.
2393 //
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002394 // NOTE: we do this here, rather than when presenting the display so that
Mathias Agopian84300952012-11-21 16:02:13 -08002395 // the hint is set before we acquire a buffer from the surface texture.
2396 //
2397 // NOTE: layer transactions have taken place already, so we use their
2398 // drawing state. However, SurfaceFlinger's own transaction has not
2399 // happened yet, so we must use the current state layer list
2400 // (soon to become the drawing state list).
2401 //
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002402 sp<const DisplayDevice> hintDisplay;
Mathias Agopian84300952012-11-21 16:02:13 -08002403 uint32_t currentlayerStack = 0;
Robert Carr2047fae2016-11-28 14:09:09 -08002404 bool first = true;
2405 mCurrentState.traverseInZOrder([&](Layer* layer) {
Mathias Agopian84300952012-11-21 16:02:13 -08002406 // NOTE: we rely on the fact that layers are sorted by
2407 // layerStack first (so we don't have to traverse the list
2408 // of displays for every layer).
Robert Carr1f0a16a2016-10-24 16:27:39 -07002409 uint32_t layerStack = layer->getLayerStack();
Robert Carr2047fae2016-11-28 14:09:09 -08002410 if (first || currentlayerStack != layerStack) {
Mathias Agopian84300952012-11-21 16:02:13 -08002411 currentlayerStack = layerStack;
2412 // figure out if this layerstack is mirrored
2413 // (more than one display) if so, pick the default display,
2414 // if not, pick the only display it's on.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002415 hintDisplay = nullptr;
2416 for (const auto& [token, display] : mDisplays) {
Lloyd Piqueef36b002019-01-23 17:52:04 -08002417 if (display->getCompositionDisplay()
2418 ->belongsInOutput(layer->getLayerStack(),
2419 layer->getPrimaryDisplayOnly())) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002420 if (hintDisplay) {
2421 hintDisplay = nullptr;
Mathias Agopian84300952012-11-21 16:02:13 -08002422 break;
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002423 } else {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002424 hintDisplay = display;
Mathias Agopian84300952012-11-21 16:02:13 -08002425 }
2426 }
2427 }
2428 }
Chet Haase91d25932013-04-11 15:24:55 -07002429
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002430 if (!hintDisplay) {
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002431 // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
2432 // redraw after transform hint changes. See bug 8508397.
Robert Carr56a0b9a2017-12-04 16:06:13 -08002433
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002434 // could be null when this layer is using a layerStack
2435 // that is not visible on any display. Also can occur at
2436 // screen off/on times.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002437 hintDisplay = getDefaultDisplayDeviceLocked();
Mathias Agopian84300952012-11-21 16:02:13 -08002438 }
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002439
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002440 // could be null if there is no display available at all to get
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002441 // the transform hint from.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002442 if (hintDisplay) {
2443 layer->updateTransformHint(hintDisplay);
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08002444 }
Robert Carr2047fae2016-11-28 14:09:09 -08002445
2446 first = false;
2447 });
Mathias Agopian84300952012-11-21 16:02:13 -08002448 }
2449
2450
Mathias Agopian3559b072012-08-15 13:46:03 -07002451 /*
2452 * Perform our own transaction if needed
2453 */
Robert Carr1f0a16a2016-10-24 16:27:39 -07002454
2455 if (mLayersAdded) {
2456 mLayersAdded = false;
2457 // Layers have been added.
Mathias Agopian3559b072012-08-15 13:46:03 -07002458 mVisibleRegionsDirty = true;
2459 }
2460
2461 // some layers might have been removed, so
2462 // we need to update the regions they're exposing.
2463 if (mLayersRemoved) {
2464 mLayersRemoved = false;
2465 mVisibleRegionsDirty = true;
Robert Carr2047fae2016-11-28 14:09:09 -08002466 mDrawingState.traverseInZOrder([&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07002467 if (mLayersPendingRemoval.indexOf(layer) >= 0) {
Mathias Agopian3559b072012-08-15 13:46:03 -07002468 // this layer is not visible anymore
Robert Carr1f0a16a2016-10-24 16:27:39 -07002469 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002470 visibleReg.set(layer->getScreenBounds());
Chia-I Wuab0c3192017-08-01 11:29:00 -07002471 invalidateLayerStack(layer, visibleReg);
Mathias Agopian0aa758d2009-04-22 15:23:34 -07002472 }
Robert Carr2047fae2016-11-28 14:09:09 -08002473 });
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002474 }
2475
Vishnu Nairec0ab382019-02-13 15:32:56 -08002476 commitInputWindowCommands();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002477 commitTransaction();
Riley Andrews03414a12014-07-01 14:22:59 -07002478}
2479
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002480void SurfaceFlinger::updateInputFlinger() {
Robert Carr720e5062018-07-30 17:45:14 -07002481 ATRACE_CALL();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002482 if (!mInputFlinger) {
Vishnu Nairde19f852018-12-18 16:11:53 -08002483 return;
2484 }
2485
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002486 if (mVisibleRegionsDirty || mInputInfoChanged) {
2487 mInputInfoChanged = false;
2488 updateInputWindowInfo();
chaviw95ef3c42019-02-14 10:55:09 -08002489 } else if (mInputWindowCommands.syncInputWindows) {
2490 // If the caller requested to sync input windows, but there are no
2491 // changes to input windows, notify immediately.
2492 setInputWindowsFinished();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002493 }
2494
2495 executeInputWindowCommands();
2496}
2497
2498void SurfaceFlinger::updateInputWindowInfo() {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002499 std::vector<InputWindowInfo> inputHandles;
Robert Carr720e5062018-07-30 17:45:14 -07002500
2501 mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
2502 if (layer->hasInput()) {
Vishnu Nair51625fa2018-12-06 13:54:33 -08002503 // When calculating the screen bounds we ignore the transparent region since it may
2504 // result in an unwanted offset.
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002505 inputHandles.push_back(layer->fillInputInfo());
Robert Carr720e5062018-07-30 17:45:14 -07002506 }
2507 });
chaviw291d88a2019-02-14 10:33:58 -08002508
2509 mInputFlinger->setInputWindows(inputHandles,
2510 mInputWindowCommands.syncInputWindows ? mSetInputWindowsListener
2511 : nullptr);
Robert Carr720e5062018-07-30 17:45:14 -07002512}
2513
Vishnu Nairec0ab382019-02-13 15:32:56 -08002514void SurfaceFlinger::commitInputWindowCommands() {
chaviw4fe36852019-04-15 16:25:49 -07002515 mInputWindowCommands = mPendingInputWindowCommands;
Vishnu Nairec0ab382019-02-13 15:32:56 -08002516 mPendingInputWindowCommands.clear();
2517}
2518
chaviwfbe5d9c2018-12-26 12:23:37 -08002519void SurfaceFlinger::executeInputWindowCommands() {
chaviwfbe5d9c2018-12-26 12:23:37 -08002520 for (const auto& transferTouchFocusCommand : mInputWindowCommands.transferTouchFocusCommands) {
2521 if (transferTouchFocusCommand.fromToken != nullptr &&
2522 transferTouchFocusCommand.toToken != nullptr &&
2523 transferTouchFocusCommand.fromToken != transferTouchFocusCommand.toToken) {
2524 mInputFlinger->transferTouchFocus(transferTouchFocusCommand.fromToken,
2525 transferTouchFocusCommand.toToken);
2526 }
2527 }
2528
2529 mInputWindowCommands.clear();
2530}
2531
Riley Andrews03414a12014-07-01 14:22:59 -07002532void SurfaceFlinger::updateCursorAsync()
2533{
Lloyd Piquec7b0c752019-03-07 20:59:59 -08002534 compositionengine::CompositionRefreshArgs refreshArgs;
2535 for (const auto& [_, display] : mDisplays) {
2536 if (display->getId()) {
2537 refreshArgs.outputs.push_back(display->getCompositionDisplay());
Riley Andrews03414a12014-07-01 14:22:59 -07002538 }
2539 }
Lloyd Piquec7b0c752019-03-07 20:59:59 -08002540
2541 mCompositionEngine->updateCursorAsync(refreshArgs);
Mathias Agopian4fec8732012-06-29 14:12:52 -07002542}
2543
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002544void SurfaceFlinger::initScheduler(DisplayId primaryDisplayId) {
2545 if (mScheduler) {
2546 // In practice it's not allowed to hotplug in/out the primary display once it's been
2547 // connected during startup, but some tests do it, so just warn and return.
2548 ALOGW("Can't re-init scheduler");
2549 return;
2550 }
2551
2552 int currentConfig = getHwComposer().getActiveConfigIndex(primaryDisplayId);
2553 mRefreshRateConfigs =
2554 std::make_unique<scheduler::RefreshRateConfigs>(refresh_rate_switching(false),
2555 getHwComposer().getConfigs(
2556 primaryDisplayId),
2557 currentConfig);
2558 mRefreshRateStats =
2559 std::make_unique<scheduler::RefreshRateStats>(*mRefreshRateConfigs, *mTimeStats,
2560 currentConfig, HWC_POWER_MODE_OFF);
2561 mRefreshRateStats->setConfigMode(currentConfig);
2562
2563 // start the EventThread
2564 mScheduler =
2565 getFactory().createScheduler([this](bool enabled) { setPrimaryVsyncEnabled(enabled); },
2566 *mRefreshRateConfigs);
2567 mAppConnectionHandle =
2568 mScheduler->createConnection("app", mPhaseOffsets->getCurrentAppOffset(),
2569 mPhaseOffsets->getOffsetThresholdForNextVsync(),
2570 impl::EventThread::InterceptVSyncsCallback());
2571 mSfConnectionHandle =
2572 mScheduler->createConnection("sf", mPhaseOffsets->getCurrentSfOffset(),
2573 mPhaseOffsets->getOffsetThresholdForNextVsync(),
2574 [this](nsecs_t timestamp) {
2575 mInterceptor->saveVSyncEvent(timestamp);
2576 });
2577
2578 mEventQueue->setEventConnection(mScheduler->getEventConnection(mSfConnectionHandle));
2579 mVSyncModulator.emplace(*mScheduler, mAppConnectionHandle, mSfConnectionHandle,
2580 mPhaseOffsets->getCurrentOffsets());
2581
2582 mRegionSamplingThread =
2583 new RegionSamplingThread(*this, *mScheduler,
2584 RegionSamplingThread::EnvironmentTimingTunables());
2585
2586 mScheduler->setChangeRefreshRateCallback(
2587 [this](RefreshRateType type, Scheduler::ConfigEvent event) {
2588 Mutex::Autolock lock(mStateLock);
2589 setRefreshRateTo(type, event);
2590 });
2591}
2592
Mathias Agopian4fec8732012-06-29 14:12:52 -07002593void SurfaceFlinger::commitTransaction()
2594{
Nataniel Borges2b796da2019-02-15 13:32:18 -08002595 withTracingLock([&]() {
Vishnu Nair0f085c62019-08-30 08:49:12 -07002596 if (!mLayersPendingRemoval.isEmpty()) {
2597 // Notify removed layers now that they can't be drawn from
2598 for (const auto& l : mLayersPendingRemoval) {
2599 recordBufferingStats(l->getName().string(), l->getOccupancyHistory(true));
2600
2601 // Ensure any buffers set to display on any children are released.
2602 if (l->isRemovedFromCurrentState()) {
2603 l->latchAndReleaseBuffer();
2604 }
2605
2606 // If the layer has been removed and has no parent, then it will not be reachable
2607 // when traversing layers on screen. Add the layer to the offscreenLayers set to
2608 // ensure we can copy its current to drawing state.
2609 if (!l->getParent()) {
2610 mOffscreenLayers.emplace(l.get());
2611 }
2612 }
2613 mLayersPendingRemoval.clear();
2614 }
2615
2616 // If this transaction is part of a window animation then the next frame
2617 // we composite should be considered an animation as well.
2618 mAnimCompositionPending = mAnimTransactionPending;
2619
Nataniel Borges2b796da2019-02-15 13:32:18 -08002620 mDrawingState = mCurrentState;
2621 // clear the "changed" flags in current state
2622 mCurrentState.colorMatrixChanged = false;
Chia-I Wu28f320b2018-05-03 11:02:56 -07002623
chaviw74d90ad2019-04-26 14:45:26 -07002624 mDrawingState.traverseInZOrder([&](Layer* layer) {
2625 layer->commitChildList();
2626
2627 // If the layer can be reached when traversing mDrawingState, then the layer is no
2628 // longer offscreen. Remove the layer from the offscreenLayer set.
2629 if (mOffscreenLayers.count(layer)) {
2630 mOffscreenLayers.erase(layer);
2631 }
2632 });
2633
2634 commitOffscreenLayers();
Robert Carr1f0a16a2016-10-24 16:27:39 -07002635 });
Nataniel Borges2b796da2019-02-15 13:32:18 -08002636
Jamie Gennis2d5e2302012-10-15 18:24:43 -07002637 mTransactionPending = false;
2638 mAnimTransactionPending = false;
Mathias Agopian4fec8732012-06-29 14:12:52 -07002639 mTransactionCV.broadcast();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002640}
2641
Nataniel Borges2b796da2019-02-15 13:32:18 -08002642void SurfaceFlinger::withTracingLock(std::function<void()> lockedOperation) {
2643 if (mTracingEnabledChanged) {
2644 mTracingEnabled = mTracing.isEnabled();
2645 mTracingEnabledChanged = false;
2646 }
2647
2648 // Synchronize with Tracing thread
2649 std::unique_lock<std::mutex> lock;
2650 if (mTracingEnabled) {
2651 lock = std::unique_lock<std::mutex>(mDrawingStateLock);
2652 }
2653
2654 lockedOperation();
2655
2656 // Synchronize with Tracing thread
2657 if (mTracingEnabled) {
2658 lock.unlock();
2659 }
2660}
2661
chaviw74d90ad2019-04-26 14:45:26 -07002662void SurfaceFlinger::commitOffscreenLayers() {
2663 for (Layer* offscreenLayer : mOffscreenLayers) {
2664 offscreenLayer->traverseInZOrder(LayerVector::StateSet::Drawing, [](Layer* layer) {
2665 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
2666 if (!trFlags) return;
2667
2668 layer->doTransaction(0);
2669 layer->commitChildList();
2670 });
2671 }
2672}
2673
Chia-I Wuab0c3192017-08-01 11:29:00 -07002674void SurfaceFlinger::invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07002675 for (const auto& [token, displayDevice] : mDisplays) {
2676 auto display = displayDevice->getCompositionDisplay();
Lloyd Piqueef36b002019-01-23 17:52:04 -08002677 if (display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07002678 display->editState().dirtyRegion.orSelf(dirty);
Mathias Agopian92a979a2012-08-02 18:32:23 -07002679 }
2680 }
Mathias Agopian87baae12012-07-31 12:38:26 -07002681}
2682
Dan Stoza6b9454d2014-11-07 16:00:59 -08002683bool SurfaceFlinger::handlePageFlip()
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002684{
Ady Abraham09bd3922019-04-08 10:44:56 -07002685 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08002686 ALOGV("handlePageFlip");
2687
Brian Andersond6927fb2016-07-23 23:37:30 -07002688 nsecs_t latchTime = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002689
Mathias Agopian4fec8732012-06-29 14:12:52 -07002690 bool visibleRegions = false;
Dan Stoza6b9454d2014-11-07 16:00:59 -08002691 bool frameQueued = false;
Mike Stroyan0cd76192017-04-20 12:10:48 -06002692 bool newDataLatched = false;
Eric Penner51c59cd2014-07-28 19:51:58 -07002693
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07002694 const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
2695
Eric Penner51c59cd2014-07-28 19:51:58 -07002696 // Store the set of layers that need updates. This set must not change as
2697 // buffers are being latched, as this could result in a deadlock.
2698 // Example: Two producers share the same command stream and:
2699 // 1.) Layer 0 is latched
2700 // 2.) Layer 0 gets a new frame
2701 // 2.) Layer 1 gets a new frame
2702 // 3.) Layer 1 is latched.
2703 // Display is now waiting on Layer 1's frame, which is behind layer 0's
2704 // second frame. But layer 0's second frame could be waiting on display.
Robert Carr2047fae2016-11-28 14:09:09 -08002705 mDrawingState.traverseInZOrder([&](Layer* layer) {
Marissa Wallfd668622018-05-10 10:21:13 -07002706 if (layer->hasReadyFrame()) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08002707 frameQueued = true;
Ana Krulec010d2192018-10-08 06:29:54 -07002708 if (layer->shouldPresentNow(expectedPresentTime)) {
Robert Carr2047fae2016-11-28 14:09:09 -08002709 mLayersWithQueuedFrames.push_back(layer);
Dan Stozaee44edd2015-03-23 15:50:23 -07002710 } else {
Ady Abraham09bd3922019-04-08 10:44:56 -07002711 ATRACE_NAME("!layer->shouldPresentNow()");
Dan Stozaee44edd2015-03-23 15:50:23 -07002712 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08002713 }
Dan Stozaee44edd2015-03-23 15:50:23 -07002714 } else {
2715 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08002716 }
Robert Carr2047fae2016-11-28 14:09:09 -08002717 });
2718
chaviw49a108c2019-08-12 11:23:06 -07002719 // The client can continue submitting buffers for offscreen layers, but they will not
2720 // be shown on screen. Therefore, we need to latch and release buffers of offscreen
2721 // layers to ensure dequeueBuffer doesn't block indefinitely.
2722 for (Layer* offscreenLayer : mOffscreenLayers) {
2723 offscreenLayer->traverseInZOrder(LayerVector::StateSet::Drawing,
2724 [&](Layer* l) { l->latchAndReleaseBuffer(); });
2725 }
2726
Lloyd Piquef2c79392018-12-20 16:23:33 -08002727 if (!mLayersWithQueuedFrames.empty()) {
2728 // mStateLock is needed for latchBuffer as LayerRejecter::reject()
2729 // writes to Layer current state. See also b/119481871
2730 Mutex::Autolock lock(mStateLock);
2731
2732 for (auto& layer : mLayersWithQueuedFrames) {
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07002733 if (layer->latchBuffer(visibleRegions, latchTime, expectedPresentTime)) {
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002734 mLayersPendingRefresh.push_back(layer);
2735 }
Lloyd Piquef2c79392018-12-20 16:23:33 -08002736 layer->useSurfaceDamage();
Lloyd Piquef2c79392018-12-20 16:23:33 -08002737 if (layer->isBufferLatched()) {
2738 newDataLatched = true;
2739 }
Mike Stroyan0cd76192017-04-20 12:10:48 -06002740 }
Mathias Agopian4fec8732012-06-29 14:12:52 -07002741 }
Mathias Agopian4da75192010-08-10 17:19:56 -07002742
Mathias Agopian3b1d2b62012-07-11 13:48:17 -07002743 mVisibleRegionsDirty |= visibleRegions;
Dan Stoza6b9454d2014-11-07 16:00:59 -08002744
2745 // If we will need to wake up at some time in the future to deal with a
2746 // queued frame that shouldn't be displayed during this vsync period, wake
2747 // up during the next vsync period to check again.
Chia-I Wua36bf922017-06-30 12:51:05 -07002748 if (frameQueued && (mLayersWithQueuedFrames.empty() || !newDataLatched)) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08002749 signalLayerUpdate();
2750 }
2751
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08002752 // enter boot animation on first buffer latch
2753 if (CC_UNLIKELY(mBootStage == BootStage::BOOTLOADER && newDataLatched)) {
2754 ALOGI("Enter boot animation");
2755 mBootStage = BootStage::BOOTANIMATION;
2756 }
2757
Dan Stoza6b9454d2014-11-07 16:00:59 -08002758 // Only continue with the refresh if there is actually new work to do
Mike Stroyan0cd76192017-04-20 12:10:48 -06002759 return !mLayersWithQueuedFrames.empty() && newDataLatched;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002760}
2761
Mathias Agopianad456f92011-01-13 17:53:01 -08002762void SurfaceFlinger::invalidateHwcGeometry()
2763{
Dan Stoza9e56aa02015-11-02 13:00:03 -08002764 mGeometryInvalid = true;
Mathias Agopianad456f92011-01-13 17:53:01 -08002765}
2766
Robert Carrc0df3122019-04-11 13:18:21 -07002767status_t SurfaceFlinger::addClientLayer(const sp<Client>& client, const sp<IBinder>& handle,
2768 const sp<IGraphicBufferProducer>& gbc, const sp<Layer>& lbc,
2769 const sp<IBinder>& parentHandle,
2770 const sp<Layer>& parentLayer, bool addToCurrentState) {
Dan Stoza7d89d062015-04-30 13:29:25 -07002771 // add this layer to the current state list
2772 {
2773 Mutex::Autolock _l(mStateLock);
Robert Carrc0df3122019-04-11 13:18:21 -07002774 sp<Layer> parent;
2775 if (parentHandle != nullptr) {
2776 parent = fromHandle(parentHandle);
2777 if (parent == nullptr) {
2778 return NAME_NOT_FOUND;
2779 }
2780 } else {
2781 parent = parentLayer;
2782 }
2783
Robert Carr1f0a16a2016-10-24 16:27:39 -07002784 if (mNumLayers >= MAX_LAYERS) {
chaviweadf0d42019-08-12 13:28:29 -07002785 ALOGE("AddClientLayer failed, mNumLayers (%zu) >= MAX_LAYERS (%zu)", mNumLayers.load(),
Courtney Goeltzenleuchterab702f52017-04-19 15:14:02 -06002786 MAX_LAYERS);
Dan Stoza7d89d062015-04-30 13:29:25 -07002787 return NO_MEMORY;
2788 }
Robert Carrc0df3122019-04-11 13:18:21 -07002789
2790 mLayersByLocalBinderToken.emplace(handle->localBinder(), lbc);
2791
Robert Carrb89ea9d2018-12-10 13:01:14 -08002792 if (parent == nullptr && addToCurrentState) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07002793 mCurrentState.layersSortedByZ.add(lbc);
chaviwac841852019-01-16 16:04:43 -08002794 } else if (parent == nullptr) {
2795 lbc->onRemovedFromCurrentState();
2796 } else if (parent->isRemovedFromCurrentState()) {
2797 parent->addChild(lbc);
2798 lbc->onRemovedFromCurrentState();
Robert Carrb89ea9d2018-12-10 13:01:14 -08002799 } else {
Robert Carr1f0a16a2016-10-24 16:27:39 -07002800 parent->addChild(lbc);
2801 }
Chia-I Wu98f1c102017-05-30 14:54:08 -07002802
Yiwei Zhang243b3782018-05-15 17:40:04 -07002803 if (gbc != nullptr) {
2804 mGraphicBufferProducerList.insert(IInterface::asBinder(gbc).get());
2805 LOG_ALWAYS_FATAL_IF(mGraphicBufferProducerList.size() >
2806 mMaxGraphicBufferProducerListSize,
2807 "Suspected IGBP leak: %zu IGBPs (%zu max), %zu Layers",
2808 mGraphicBufferProducerList.size(),
chaviweadf0d42019-08-12 13:28:29 -07002809 mMaxGraphicBufferProducerListSize, mNumLayers.load());
Yiwei Zhang243b3782018-05-15 17:40:04 -07002810 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07002811 mLayersAdded = true;
Dan Stoza7d89d062015-04-30 13:29:25 -07002812 }
2813
Mathias Agopian96f08192010-06-02 23:28:45 -07002814 // attach this layer to the client
Mathias Agopianac9fa422013-02-11 16:40:36 -08002815 client->attachLayer(handle, lbc);
Mathias Agopian4f113742011-05-03 16:21:41 -07002816
Dan Stoza7d89d062015-04-30 13:29:25 -07002817 return NO_ERROR;
Mathias Agopian96f08192010-06-02 23:28:45 -07002818}
2819
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08002820uint32_t SurfaceFlinger::peekTransactionFlags() {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07002821 return mTransactionFlags;
Mathias Agopiandea20b12011-05-03 17:04:02 -07002822}
2823
Mathias Agopian3f844832013-08-07 21:24:32 -07002824uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07002825 return mTransactionFlags.fetch_and(~flags) & flags;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002826}
2827
Mathias Agopian3f844832013-08-07 21:24:32 -07002828uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) {
Ana Krulec7ecce8c2018-10-12 13:44:41 -07002829 return setTransactionFlags(flags, Scheduler::TransactionStart::NORMAL);
Dan Stoza84d619e2018-03-28 17:07:36 -07002830}
2831
2832uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags,
Ana Krulec7ecce8c2018-10-12 13:44:41 -07002833 Scheduler::TransactionStart transactionStart) {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07002834 uint32_t old = mTransactionFlags.fetch_or(flags);
Dominik Laskowskieddeda12019-07-19 11:54:13 -07002835 mVSyncModulator->setTransactionStart(transactionStart);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002836 if ((old & flags)==0) { // wake the server up
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08002837 signalTransaction();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002838 }
2839 return old;
2840}
2841
Marissa Wall713b63f2018-10-17 15:42:43 -07002842bool SurfaceFlinger::flushTransactionQueues() {
Valerie Haufce31b82019-04-30 16:41:14 -07002843 // to prevent onHandleDestroyed from being called while the lock is held,
2844 // we must keep a copy of the transactions (specifically the composer
2845 // states) around outside the scope of the lock
2846 std::vector<const TransactionState> transactions;
Marissa Walle6e3c0d2019-03-29 10:28:30 -07002847 bool flushedATransaction = false;
Valerie Haufce31b82019-04-30 16:41:14 -07002848 {
2849 Mutex::Autolock _l(mStateLock);
Marissa Walle6e3c0d2019-03-29 10:28:30 -07002850
Valerie Haufce31b82019-04-30 16:41:14 -07002851 auto it = mTransactionQueues.begin();
2852 while (it != mTransactionQueues.end()) {
2853 auto& [applyToken, transactionQueue] = *it;
Marissa Wall713b63f2018-10-17 15:42:43 -07002854
Valerie Haufce31b82019-04-30 16:41:14 -07002855 while (!transactionQueue.empty()) {
2856 const auto& transaction = transactionQueue.front();
2857 if (!transactionIsReadyToBeApplied(transaction.desiredPresentTime,
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07002858 true /* useCachedExpectedPresentTime */,
Valerie Haufce31b82019-04-30 16:41:14 -07002859 transaction.states)) {
2860 setTransactionFlags(eTransactionFlushNeeded);
2861 break;
2862 }
2863 transactions.push_back(transaction);
2864 applyTransactionState(transaction.states, transaction.displays, transaction.flags,
2865 mPendingInputWindowCommands, transaction.desiredPresentTime,
Valerie Hau9dab9732019-08-20 09:29:25 -07002866 transaction.buffer, transaction.postTime,
2867 transaction.privileged, transaction.hasListenerCallbacks,
2868 transaction.listenerCallbacks, /*isMainThread*/ true);
Valerie Haufce31b82019-04-30 16:41:14 -07002869 transactionQueue.pop();
2870 flushedATransaction = true;
Marissa Wall713b63f2018-10-17 15:42:43 -07002871 }
Marissa Wall713b63f2018-10-17 15:42:43 -07002872
Valerie Haufce31b82019-04-30 16:41:14 -07002873 if (transactionQueue.empty()) {
2874 it = mTransactionQueues.erase(it);
2875 mTransactionCV.broadcast();
2876 } else {
Valerie Haue5562ec2019-05-14 12:39:16 -07002877 it = std::next(it, 1);
Valerie Haufce31b82019-04-30 16:41:14 -07002878 }
Valerie Hauf6016b62019-03-28 10:49:59 -07002879 }
Marissa Wall713b63f2018-10-17 15:42:43 -07002880 }
Marissa Walle6e3c0d2019-03-29 10:28:30 -07002881 return flushedATransaction;
2882}
2883
2884bool SurfaceFlinger::transactionFlushNeeded() {
2885 return !mTransactionQueues.empty();
Marissa Wall713b63f2018-10-17 15:42:43 -07002886}
2887
chaviwca27f252018-02-06 16:46:39 -08002888
Marissa Wall17b4e452018-12-26 16:32:34 -08002889bool SurfaceFlinger::transactionIsReadyToBeApplied(int64_t desiredPresentTime,
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07002890 bool useCachedExpectedPresentTime,
Marissa Wall17b4e452018-12-26 16:32:34 -08002891 const Vector<ComposerState>& states) {
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07002892 if (!useCachedExpectedPresentTime)
2893 populateExpectedPresentTime();
2894
2895 const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
Marissa Wall17b4e452018-12-26 16:32:34 -08002896 // Do not present if the desiredPresentTime has not passed unless it is more than one second
2897 // in the future. We ignore timestamps more than 1 second in the future for stability reasons.
2898 if (desiredPresentTime >= 0 && desiredPresentTime >= expectedPresentTime &&
2899 desiredPresentTime < expectedPresentTime + s2ns(1)) {
2900 return false;
2901 }
2902
Marissa Wall713b63f2018-10-17 15:42:43 -07002903 for (const ComposerState& state : states) {
2904 const layer_state_t& s = state.state;
2905 if (!(s.what & layer_state_t::eAcquireFenceChanged)) {
2906 continue;
2907 }
2908 if (s.acquireFence && s.acquireFence->getStatus() == Fence::Status::Unsignaled) {
Marissa Wall17b4e452018-12-26 16:32:34 -08002909 return false;
Marissa Wall713b63f2018-10-17 15:42:43 -07002910 }
2911 }
Marissa Wall17b4e452018-12-26 16:32:34 -08002912 return true;
Marissa Wall713b63f2018-10-17 15:42:43 -07002913}
2914
Valerie Hau9dab9732019-08-20 09:29:25 -07002915void SurfaceFlinger::setTransactionState(
2916 const Vector<ComposerState>& states, const Vector<DisplayState>& displays, uint32_t flags,
2917 const sp<IBinder>& applyToken, const InputWindowCommands& inputWindowCommands,
2918 int64_t desiredPresentTime, const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
2919 const std::vector<ListenerCallbacks>& listenerCallbacks) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07002920 ATRACE_CALL();
Robert Carr14167e02019-02-13 13:50:55 -08002921
Valerie Haubc6ddb12019-03-08 11:10:15 -08002922 const int64_t postTime = systemTime();
2923
Robert Carr14167e02019-02-13 13:50:55 -08002924 bool privileged = callingThreadHasUnscopedSurfaceFlingerAccess();
2925
Mathias Agopian698c0872011-06-28 19:09:31 -07002926 Mutex::Autolock _l(mStateLock);
Mathias Agopiane57f2922012-08-09 16:29:12 -07002927
Marissa Wall713b63f2018-10-17 15:42:43 -07002928 // If its TransactionQueue already has a pending TransactionState or if it is pending
Valerie Hauf6016b62019-03-28 10:49:59 -07002929 auto itr = mTransactionQueues.find(applyToken);
2930 // if this is an animation frame, wait until prior animation frame has
2931 // been applied by SF
2932 if (flags & eAnimation) {
2933 while (itr != mTransactionQueues.end()) {
2934 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
2935 if (CC_UNLIKELY(err != NO_ERROR)) {
2936 ALOGW_IF(err == TIMED_OUT,
2937 "setTransactionState timed out "
2938 "waiting for animation frame to apply");
2939 break;
2940 }
2941 itr = mTransactionQueues.find(applyToken);
2942 }
2943 }
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07002944
2945 // Expected present time is computed and cached on invalidate, so it may be stale.
2946 if (itr != mTransactionQueues.end() || !transactionIsReadyToBeApplied(
2947 desiredPresentTime, false /* useCachedExpectedPresentTime */, states)) {
Robert Carr14167e02019-02-13 13:50:55 -08002948 mTransactionQueues[applyToken].emplace(states, displays, flags, desiredPresentTime,
Valerie Hau9dab9732019-08-20 09:29:25 -07002949 uncacheBuffer, postTime, privileged,
2950 hasListenerCallbacks, listenerCallbacks);
Marissa Walle6e3c0d2019-03-29 10:28:30 -07002951 setTransactionFlags(eTransactionFlushNeeded);
Marissa Wall713b63f2018-10-17 15:42:43 -07002952 return;
2953 }
2954
Valerie Haubc6ddb12019-03-08 11:10:15 -08002955 applyTransactionState(states, displays, flags, inputWindowCommands, desiredPresentTime,
Valerie Hau9dab9732019-08-20 09:29:25 -07002956 uncacheBuffer, postTime, privileged, hasListenerCallbacks,
2957 listenerCallbacks);
Marissa Wall713b63f2018-10-17 15:42:43 -07002958}
2959
Valerie Hau9dab9732019-08-20 09:29:25 -07002960void SurfaceFlinger::applyTransactionState(
2961 const Vector<ComposerState>& states, const Vector<DisplayState>& displays, uint32_t flags,
2962 const InputWindowCommands& inputWindowCommands, const int64_t desiredPresentTime,
2963 const client_cache_t& uncacheBuffer, const int64_t postTime, bool privileged,
2964 bool hasListenerCallbacks, const std::vector<ListenerCallbacks>& listenerCallbacks,
2965 bool isMainThread) {
Marissa Wall713b63f2018-10-17 15:42:43 -07002966 uint32_t transactionFlags = 0;
2967
Jamie Gennis2d5e2302012-10-15 18:24:43 -07002968 if (flags & eAnimation) {
2969 // For window updates that are part of an animation we must wait for
2970 // previous animation "frames" to be handled.
Valerie Hau38448362019-04-11 14:49:33 -07002971 while (!isMainThread && mAnimTransactionPending) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07002972 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
Jamie Gennis2d5e2302012-10-15 18:24:43 -07002973 if (CC_UNLIKELY(err != NO_ERROR)) {
2974 // just in case something goes wrong in SF, return to the
Jamie Gennis7c41bf72012-10-17 09:29:47 -07002975 // caller after a few seconds.
2976 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out "
2977 "waiting for previous animation frame");
Jamie Gennis2d5e2302012-10-15 18:24:43 -07002978 mAnimTransactionPending = false;
2979 break;
2980 }
2981 }
2982 }
2983
chaviwca27f252018-02-06 16:46:39 -08002984 for (const DisplayState& display : displays) {
2985 transactionFlags |= setDisplayStateLocked(display);
Jamie Gennisb8d69a52011-10-10 15:48:06 -07002986 }
2987
Valerie Hau9dab9732019-08-20 09:29:25 -07002988 // start and end registration for listeners w/ no surface so they can get their callback. Note
2989 // that listeners with SurfaceControls will start registration during setClientStateLocked
2990 // below.
2991 for (const auto& listener : listenerCallbacks) {
2992 mTransactionCompletedThread.startRegistration(listener);
2993 mTransactionCompletedThread.endRegistration(listener);
Marissa Walld600d572019-03-26 15:38:50 -07002994 }
2995
Valerie Hau9dab9732019-08-20 09:29:25 -07002996 std::unordered_set<ListenerCallbacks, ListenerCallbacksHash> listenerCallbacksWithSurfaces;
Marissa Walle2ffb422018-10-12 11:33:52 -07002997 uint32_t clientStateFlags = 0;
chaviwca27f252018-02-06 16:46:39 -08002998 for (const ComposerState& state : states) {
Valerie Hau9dab9732019-08-20 09:29:25 -07002999 clientStateFlags |= setClientStateLocked(state, desiredPresentTime, postTime, privileged,
3000 listenerCallbacksWithSurfaces);
Marissa Wall3dad52d2019-03-22 14:03:19 -07003001 }
3002
Valerie Hau9dab9732019-08-20 09:29:25 -07003003 for (const auto& listenerCallback : listenerCallbacksWithSurfaces) {
Marissa Wallefb71af2019-06-27 14:45:53 -07003004 mTransactionCompletedThread.endRegistration(listenerCallback);
3005 }
3006
Marissa Walle2ffb422018-10-12 11:33:52 -07003007 // If the state doesn't require a traversal and there are callbacks, send them now
Valerie Hau9dab9732019-08-20 09:29:25 -07003008 if (!(clientStateFlags & eTraversalNeeded) && hasListenerCallbacks) {
Marissa Walle2ffb422018-10-12 11:33:52 -07003009 mTransactionCompletedThread.sendCallbacks();
3010 }
3011 transactionFlags |= clientStateFlags;
chaviwca27f252018-02-06 16:46:39 -08003012
chaviw273171b2018-12-26 11:46:30 -08003013 transactionFlags |= addInputWindowCommands(inputWindowCommands);
3014
Marissa Wall947d34e2019-03-29 14:03:53 -07003015 if (uncacheBuffer.isValid()) {
3016 ClientCache::getInstance().erase(uncacheBuffer);
Alec Mouri4545a8a2019-08-08 20:05:32 -07003017 getRenderEngine().unbindExternalTextureBuffer(uncacheBuffer.id);
Marissa Wall78b72202019-03-15 14:58:34 -07003018 }
3019
Jorim Jaggibdcf09c2017-08-08 15:22:08 +02003020 // If a synchronous transaction is explicitly requested without any changes, force a transaction
3021 // anyway. This can be used as a flush mechanism for previous async transactions.
3022 // Empty animation transaction can be used to simulate back-pressure, so also force a
3023 // transaction for empty animation transactions.
3024 if (transactionFlags == 0 &&
3025 ((flags & eSynchronous) || (flags & eAnimation))) {
Robert Carr2a7dbb42016-05-24 11:41:28 -07003026 transactionFlags = eTransactionNeeded;
3027 }
3028
Marissa Wall06255332019-03-27 13:48:27 -07003029 // If we are on the main thread, we are about to preform a traversal. Clear the traversal bit
3030 // so we don't have to wake up again next frame to preform an uneeded traversal.
3031 if (isMainThread && (transactionFlags & eTraversalNeeded)) {
3032 transactionFlags = transactionFlags & (~eTraversalNeeded);
3033 mTraversalNeededMainThread = true;
3034 }
3035
Mathias Agopian386aa982011-11-07 21:58:03 -08003036 if (transactionFlags) {
Lloyd Pique4dccc412018-01-22 17:21:36 -08003037 if (mInterceptor->isEnabled()) {
3038 mInterceptor->saveTransaction(states, mCurrentState.displays, displays, flags);
Irvelffc9efc2016-07-27 15:16:37 -07003039 }
Irvel468051e2016-06-13 16:44:44 -07003040
Mathias Agopian386aa982011-11-07 21:58:03 -08003041 // this triggers the transaction
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003042 const auto start = (flags & eEarlyWakeup) ? Scheduler::TransactionStart::EARLY
3043 : Scheduler::TransactionStart::NORMAL;
Dan Stoza84d619e2018-03-28 17:07:36 -07003044 setTransactionFlags(transactionFlags, start);
Mathias Agopian386aa982011-11-07 21:58:03 -08003045
3046 // if this is a synchronous transaction, wait for it to take effect
3047 // before returning.
3048 if (flags & eSynchronous) {
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003049 mTransactionPending = true;
Mathias Agopian386aa982011-11-07 21:58:03 -08003050 }
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003051 if (flags & eAnimation) {
3052 mAnimTransactionPending = true;
3053 }
chaviw4fe36852019-04-15 16:25:49 -07003054 if (mPendingInputWindowCommands.syncInputWindows) {
3055 mPendingSyncInputWindows = true;
3056 }
Valerie Hau0779ded2019-03-19 12:43:04 -07003057
3058 // applyTransactionState can be called by either the main SF thread or by
3059 // another process through setTransactionState. While a given process may wish
3060 // to wait on synchronous transactions, the main SF thread should never
3061 // be blocked. Therefore, we only wait if isMainThread is false.
3062 while (!isMainThread && (mTransactionPending || mPendingSyncInputWindows)) {
Mathias Agopian386aa982011-11-07 21:58:03 -08003063 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
3064 if (CC_UNLIKELY(err != NO_ERROR)) {
3065 // just in case something goes wrong in SF, return to the
3066 // called after a few seconds.
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003067 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");
3068 mTransactionPending = false;
chaviw95ef3c42019-02-14 10:55:09 -08003069 mPendingSyncInputWindows = false;
Mathias Agopian386aa982011-11-07 21:58:03 -08003070 break;
3071 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -07003072 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003073 }
3074}
3075
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003076uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s) {
3077 const ssize_t index = mCurrentState.displays.indexOfKey(s.token);
3078 if (index < 0) return 0;
Jesse Hall9a143922012-10-04 16:29:19 -07003079
Mathias Agopiane57f2922012-08-09 16:29:12 -07003080 uint32_t flags = 0;
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003081 DisplayDeviceState& state = mCurrentState.displays.editValueAt(index);
3082
3083 const uint32_t what = s.what;
3084 if (what & DisplayState::eSurfaceChanged) {
3085 if (IInterface::asBinder(state.surface) != IInterface::asBinder(s.surface)) {
3086 state.surface = s.surface;
3087 flags |= eDisplayTransactionNeeded;
Michael Lentine47e45402014-07-18 15:34:25 -07003088 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07003089 }
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003090 if (what & DisplayState::eLayerStackChanged) {
3091 if (state.layerStack != s.layerStack) {
3092 state.layerStack = s.layerStack;
3093 flags |= eDisplayTransactionNeeded;
3094 }
3095 }
3096 if (what & DisplayState::eDisplayProjectionChanged) {
3097 if (state.orientation != s.orientation) {
3098 state.orientation = s.orientation;
3099 flags |= eDisplayTransactionNeeded;
3100 }
3101 if (state.frame != s.frame) {
3102 state.frame = s.frame;
3103 flags |= eDisplayTransactionNeeded;
3104 }
3105 if (state.viewport != s.viewport) {
3106 state.viewport = s.viewport;
3107 flags |= eDisplayTransactionNeeded;
3108 }
3109 }
3110 if (what & DisplayState::eDisplaySizeChanged) {
3111 if (state.width != s.width) {
3112 state.width = s.width;
3113 flags |= eDisplayTransactionNeeded;
3114 }
3115 if (state.height != s.height) {
3116 state.height = s.height;
3117 flags |= eDisplayTransactionNeeded;
3118 }
3119 }
3120
Mathias Agopiane57f2922012-08-09 16:29:12 -07003121 return flags;
3122}
3123
Robert Carr14167e02019-02-13 13:50:55 -08003124bool SurfaceFlinger::callingThreadHasUnscopedSurfaceFlingerAccess() {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003125 IPCThreadState* ipc = IPCThreadState::self();
3126 const int pid = ipc->getCallingPid();
3127 const int uid = ipc->getCallingUid();
Robert Carrd4ae7f32018-06-07 16:10:57 -07003128 if ((uid != AID_GRAPHICS && uid != AID_SYSTEM) &&
Ana Krulec13be8ad2018-08-21 02:43:56 +00003129 !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003130 return false;
3131 }
3132 return true;
3133}
3134
Marissa Wall3dad52d2019-03-22 14:03:19 -07003135uint32_t SurfaceFlinger::setClientStateLocked(
Valerie Hau9dab9732019-08-20 09:29:25 -07003136 const ComposerState& composerState, int64_t desiredPresentTime, int64_t postTime,
3137 bool privileged,
3138 std::unordered_set<ListenerCallbacks, ListenerCallbacksHash>& listenerCallbacks) {
chaviwca27f252018-02-06 16:46:39 -08003139 const layer_state_t& s = composerState.state;
chaviwca27f252018-02-06 16:46:39 -08003140
Valerie Hau9dab9732019-08-20 09:29:25 -07003141 for (auto& listener : s.listeners) {
3142 // note that startRegistration will not re-register if the listener has
3143 // already be registered for a prior surface control
3144 mTransactionCompletedThread.startRegistration(listener);
3145 listenerCallbacks.insert(listener);
3146 }
3147
Vishnu Nairf03652d2019-07-16 17:56:56 -07003148 sp<Layer> layer(fromHandle(s.surface));
chaviw8b3871a2017-11-01 17:41:01 -07003149 if (layer == nullptr) {
Valerie Hau9dab9732019-08-20 09:29:25 -07003150 for (auto& [listener, callbackIds] : s.listeners) {
Marissa Wallefb71af2019-06-27 14:45:53 -07003151 mTransactionCompletedThread.registerUnpresentedCallbackHandle(
Valerie Hau9dab9732019-08-20 09:29:25 -07003152 new CallbackHandle(listener, callbackIds, s.surface));
Marissa Wall88e20482019-06-24 10:49:42 -07003153 }
chaviw8b3871a2017-11-01 17:41:01 -07003154 return 0;
3155 }
3156
chaviw8b3871a2017-11-01 17:41:01 -07003157 uint32_t flags = 0;
3158
Garfield Tan8a3083e2018-12-03 13:21:07 -08003159 const uint64_t what = s.what;
Jorim Jaggidba32732018-05-28 17:43:52 +02003160
3161 // If we are deferring transaction, make sure to push the pending state, as otherwise the
3162 // pending state will also be deferred.
Marissa Wallf58c14b2018-07-24 10:50:43 -07003163 if (what & layer_state_t::eDeferTransaction_legacy) {
Jorim Jaggidba32732018-05-28 17:43:52 +02003164 layer->pushPendingState();
3165 }
3166
chaviw8b3871a2017-11-01 17:41:01 -07003167 if (what & layer_state_t::ePositionChanged) {
chaviw214c89d2019-09-04 16:03:53 -07003168 if (layer->setPosition(s.x, s.y)) {
chaviw8b3871a2017-11-01 17:41:01 -07003169 flags |= eTraversalNeeded;
Mathias Agopiane57f2922012-08-09 16:29:12 -07003170 }
chaviw8b3871a2017-11-01 17:41:01 -07003171 }
3172 if (what & layer_state_t::eLayerChanged) {
3173 // NOTE: index needs to be calculated before we update the state
3174 const auto& p = layer->getParent();
3175 if (p == nullptr) {
chaviw64f7b422017-07-12 10:31:58 -07003176 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
chaviw8b3871a2017-11-01 17:41:01 -07003177 if (layer->setLayer(s.z) && idx >= 0) {
Mathias Agopiane57f2922012-08-09 16:29:12 -07003178 mCurrentState.layersSortedByZ.removeAt(idx);
3179 mCurrentState.layersSortedByZ.add(layer);
3180 // we need traversal (state changed)
3181 // AND transaction (list changed)
3182 flags |= eTransactionNeeded|eTraversalNeeded;
3183 }
chaviw8b3871a2017-11-01 17:41:01 -07003184 } else {
3185 if (p->setChildLayer(layer, s.z)) {
chaviw06178942017-07-27 10:25:59 -07003186 flags |= eTransactionNeeded|eTraversalNeeded;
3187 }
3188 }
chaviw8b3871a2017-11-01 17:41:01 -07003189 }
3190 if (what & layer_state_t::eRelativeLayerChanged) {
Robert Carr503c7042017-09-27 15:06:08 -07003191 // NOTE: index needs to be calculated before we update the state
3192 const auto& p = layer->getParent();
3193 if (p == nullptr) {
3194 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
3195 if (layer->setRelativeLayer(s.relativeLayerHandle, s.z) && idx >= 0) {
3196 mCurrentState.layersSortedByZ.removeAt(idx);
3197 mCurrentState.layersSortedByZ.add(layer);
3198 // we need traversal (state changed)
3199 // AND transaction (list changed)
3200 flags |= eTransactionNeeded|eTraversalNeeded;
3201 }
3202 } else {
3203 if (p->setChildRelativeLayer(layer, s.relativeLayerHandle, s.z)) {
3204 flags |= eTransactionNeeded|eTraversalNeeded;
3205 }
chaviw8b3871a2017-11-01 17:41:01 -07003206 }
3207 }
3208 if (what & layer_state_t::eSizeChanged) {
3209 if (layer->setSize(s.w, s.h)) {
3210 flags |= eTraversalNeeded;
3211 }
3212 }
3213 if (what & layer_state_t::eAlphaChanged) {
3214 if (layer->setAlpha(s.alpha))
3215 flags |= eTraversalNeeded;
3216 }
3217 if (what & layer_state_t::eColorChanged) {
3218 if (layer->setColor(s.color))
3219 flags |= eTraversalNeeded;
3220 }
Peiyong Lind3788632018-09-18 16:01:31 -07003221 if (what & layer_state_t::eColorTransformChanged) {
3222 if (layer->setColorTransform(s.colorTransform)) {
3223 flags |= eTraversalNeeded;
3224 }
3225 }
Valerie Haudd0b7572019-01-29 14:59:27 -08003226 if (what & layer_state_t::eBackgroundColorChanged) {
3227 if (layer->setBackgroundColor(s.color, s.bgColorAlpha, s.bgColorDataspace)) {
3228 flags |= eTraversalNeeded;
3229 }
3230 }
chaviw8b3871a2017-11-01 17:41:01 -07003231 if (what & layer_state_t::eMatrixChanged) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003232 // TODO: b/109894387
3233 //
3234 // SurfaceFlinger's renderer is not prepared to handle cropping in the face of arbitrary
3235 // rotation. To see the problem observe that if we have a square parent, and a child
3236 // of the same size, then we rotate the child 45 degrees around it's center, the child
3237 // must now be cropped to a non rectangular 8 sided region.
3238 //
3239 // Of course we can fix this in the future. For now, we are lucky, SurfaceControl is
3240 // private API, and the WindowManager only uses rotation in one case, which is on a top
3241 // level layer in which cropping is not an issue.
3242 //
3243 // However given that abuse of rotation matrices could lead to surfaces extending outside
3244 // of cropped areas, we need to prevent non-root clients without permission ACCESS_SURFACE_FLINGER
3245 // (a.k.a. everyone except WindowManager and tests) from setting non rectangle preserving
3246 // transformations.
Robert Carr14167e02019-02-13 13:50:55 -08003247 if (layer->setMatrix(s.matrix, privileged))
chaviw8b3871a2017-11-01 17:41:01 -07003248 flags |= eTraversalNeeded;
3249 }
3250 if (what & layer_state_t::eTransparentRegionChanged) {
3251 if (layer->setTransparentRegionHint(s.transparentRegion))
3252 flags |= eTraversalNeeded;
3253 }
3254 if (what & layer_state_t::eFlagsChanged) {
3255 if (layer->setFlags(s.flags, s.mask))
3256 flags |= eTraversalNeeded;
3257 }
Marissa Wallf58c14b2018-07-24 10:50:43 -07003258 if (what & layer_state_t::eCropChanged_legacy) {
chaviw214c89d2019-09-04 16:03:53 -07003259 if (layer->setCrop_legacy(s.crop_legacy)) flags |= eTraversalNeeded;
chaviw8b3871a2017-11-01 17:41:01 -07003260 }
Lucas Dupin1b6531c2018-07-05 17:18:21 -07003261 if (what & layer_state_t::eCornerRadiusChanged) {
3262 if (layer->setCornerRadius(s.cornerRadius))
3263 flags |= eTraversalNeeded;
3264 }
chaviw8b3871a2017-11-01 17:41:01 -07003265 if (what & layer_state_t::eLayerStackChanged) {
3266 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
3267 // We only allow setting layer stacks for top level layers,
3268 // everything else inherits layer stack from its parent.
3269 if (layer->hasParent()) {
3270 ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
3271 layer->getName().string());
3272 } else if (idx < 0) {
3273 ALOGE("Attempt to set layer stack on layer without parent (%s) that "
3274 "that also does not appear in the top level layer list. Something"
3275 " has gone wrong.", layer->getName().string());
3276 } else if (layer->setLayerStack(s.layerStack)) {
3277 mCurrentState.layersSortedByZ.removeAt(idx);
3278 mCurrentState.layersSortedByZ.add(layer);
3279 // we need traversal (state changed)
3280 // AND transaction (list changed)
Lloyd Piqued432a7c2018-03-23 16:05:31 -07003281 flags |= eTransactionNeeded|eTraversalNeeded|eDisplayLayerStackChanged;
chaviw8b3871a2017-11-01 17:41:01 -07003282 }
3283 }
Marissa Wallf58c14b2018-07-24 10:50:43 -07003284 if (what & layer_state_t::eDeferTransaction_legacy) {
3285 if (s.barrierHandle_legacy != nullptr) {
3286 layer->deferTransactionUntil_legacy(s.barrierHandle_legacy, s.frameNumber_legacy);
3287 } else if (s.barrierGbp_legacy != nullptr) {
3288 const sp<IGraphicBufferProducer>& gbp = s.barrierGbp_legacy;
chaviw8b3871a2017-11-01 17:41:01 -07003289 if (authenticateSurfaceTextureLocked(gbp)) {
3290 const auto& otherLayer =
3291 (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
Marissa Wallf58c14b2018-07-24 10:50:43 -07003292 layer->deferTransactionUntil_legacy(otherLayer, s.frameNumber_legacy);
chaviw8b3871a2017-11-01 17:41:01 -07003293 } else {
3294 ALOGE("Attempt to defer transaction to to an"
3295 " unrecognized GraphicBufferProducer");
Robert Carr1db73f62016-12-21 12:58:51 -08003296 }
3297 }
chaviw8b3871a2017-11-01 17:41:01 -07003298 // We don't trigger a traversal here because if no other state is
3299 // changed, we don't want this to cause any more work
3300 }
chaviw8b3871a2017-11-01 17:41:01 -07003301 if (what & layer_state_t::eReparentChildren) {
3302 if (layer->reparentChildren(s.reparentHandle)) {
3303 flags |= eTransactionNeeded|eTraversalNeeded;
Robert Carrc3574f72016-03-24 12:19:32 -07003304 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07003305 }
chaviw8b3871a2017-11-01 17:41:01 -07003306 if (what & layer_state_t::eDetachChildren) {
3307 layer->detachChildren();
3308 }
3309 if (what & layer_state_t::eOverrideScalingModeChanged) {
3310 layer->setOverrideScalingMode(s.overrideScalingMode);
3311 // We don't trigger a traversal here because if no other state is
3312 // changed, we don't want this to cause any more work
3313 }
Marissa Wall61c58622018-07-18 10:12:20 -07003314 if (what & layer_state_t::eTransformChanged) {
3315 if (layer->setTransform(s.transform)) flags |= eTraversalNeeded;
3316 }
3317 if (what & layer_state_t::eTransformToDisplayInverseChanged) {
3318 if (layer->setTransformToDisplayInverse(s.transformToDisplayInverse))
3319 flags |= eTraversalNeeded;
3320 }
3321 if (what & layer_state_t::eCropChanged) {
3322 if (layer->setCrop(s.crop)) flags |= eTraversalNeeded;
3323 }
Marissa Wall861616d2018-10-22 12:52:23 -07003324 if (what & layer_state_t::eFrameChanged) {
3325 if (layer->setFrame(s.frame)) flags |= eTraversalNeeded;
3326 }
Marissa Wall61c58622018-07-18 10:12:20 -07003327 if (what & layer_state_t::eAcquireFenceChanged) {
3328 if (layer->setAcquireFence(s.acquireFence)) flags |= eTraversalNeeded;
3329 }
3330 if (what & layer_state_t::eDataspaceChanged) {
3331 if (layer->setDataspace(s.dataspace)) flags |= eTraversalNeeded;
3332 }
3333 if (what & layer_state_t::eHdrMetadataChanged) {
3334 if (layer->setHdrMetadata(s.hdrMetadata)) flags |= eTraversalNeeded;
3335 }
3336 if (what & layer_state_t::eSurfaceDamageRegionChanged) {
3337 if (layer->setSurfaceDamageRegion(s.surfaceDamageRegion)) flags |= eTraversalNeeded;
3338 }
3339 if (what & layer_state_t::eApiChanged) {
3340 if (layer->setApi(s.api)) flags |= eTraversalNeeded;
3341 }
3342 if (what & layer_state_t::eSidebandStreamChanged) {
3343 if (layer->setSidebandStream(s.sidebandStream)) flags |= eTraversalNeeded;
3344 }
Robert Carr720e5062018-07-30 17:45:14 -07003345 if (what & layer_state_t::eInputInfoChanged) {
Vishnu Nairce5d0cc2019-02-28 14:38:41 -08003346 if (privileged) {
Robert Carr11ac2012019-01-22 09:05:25 -08003347 layer->setInputInfo(s.inputInfo);
3348 flags |= eTraversalNeeded;
3349 } else {
3350 ALOGE("Attempt to update InputWindowInfo without permission ACCESS_SURFACE_FLINGER");
3351 }
Robert Carr720e5062018-07-30 17:45:14 -07003352 }
Evan Rosky1f6d6d52018-12-06 10:47:26 -08003353 if (what & layer_state_t::eMetadataChanged) {
3354 if (layer->setMetadata(s.metadata)) flags |= eTraversalNeeded;
3355 }
Peiyong Linc502cb72019-03-01 15:00:23 -08003356 if (what & layer_state_t::eColorSpaceAgnosticChanged) {
3357 if (layer->setColorSpaceAgnostic(s.colorSpaceAgnostic)) {
3358 flags |= eTraversalNeeded;
3359 }
3360 }
Vishnu Nair14d76922019-08-05 08:41:20 -07003361 // This has to happen after we reparent children because when we reparent to null we remove
3362 // child layers from current state and remove its relative z. If the children are reparented in
3363 // the same transaction, then we have to make sure we reparent the children first so we do not
3364 // lose its relative z order.
3365 if (what & layer_state_t::eReparent) {
3366 bool hadParent = layer->hasParent();
3367 if (layer->reparent(s.parentHandleForChild)) {
3368 if (!hadParent) {
3369 mCurrentState.layersSortedByZ.remove(layer);
3370 }
3371 flags |= eTransactionNeeded | eTraversalNeeded;
3372 }
3373 }
Marissa Walle2ffb422018-10-12 11:33:52 -07003374 std::vector<sp<CallbackHandle>> callbackHandles;
Valerie Hau9dab9732019-08-20 09:29:25 -07003375 if ((what & layer_state_t::eHasListenerCallbacksChanged) && (!s.listeners.empty())) {
3376 for (auto& [listener, callbackIds] : s.listeners) {
Marissa Walle2ffb422018-10-12 11:33:52 -07003377 callbackHandles.emplace_back(new CallbackHandle(listener, callbackIds, s.surface));
3378 }
3379 }
Marissa Wall78b72202019-03-15 14:58:34 -07003380 bool bufferChanged = what & layer_state_t::eBufferChanged;
3381 bool cacheIdChanged = what & layer_state_t::eCachedBufferChanged;
3382 sp<GraphicBuffer> buffer;
Alec Mouri4545a8a2019-08-08 20:05:32 -07003383 if (bufferChanged && cacheIdChanged && s.buffer != nullptr) {
Marissa Wall78b72202019-03-15 14:58:34 -07003384 buffer = s.buffer;
Alec Mouri4545a8a2019-08-08 20:05:32 -07003385 bool success = ClientCache::getInstance().add(s.cachedBuffer, s.buffer);
3386 if (success) {
3387 getRenderEngine().cacheExternalTextureBuffer(s.buffer);
3388 success = ClientCache::getInstance()
3389 .registerErasedRecipient(s.cachedBuffer,
3390 wp<ClientCache::ErasedRecipient>(this));
3391 if (!success) {
3392 getRenderEngine().unbindExternalTextureBuffer(s.buffer->getId());
3393 }
3394 }
Marissa Wall78b72202019-03-15 14:58:34 -07003395 } else if (cacheIdChanged) {
Marissa Wall947d34e2019-03-29 14:03:53 -07003396 buffer = ClientCache::getInstance().get(s.cachedBuffer);
Marissa Wall78b72202019-03-15 14:58:34 -07003397 } else if (bufferChanged) {
3398 buffer = s.buffer;
Marissa Wall73411622019-01-25 10:45:41 -08003399 }
Marissa Wall78b72202019-03-15 14:58:34 -07003400 if (buffer) {
Marissa Wall947d34e2019-03-29 14:03:53 -07003401 if (layer->setBuffer(buffer, postTime, desiredPresentTime, s.cachedBuffer)) {
Valerie Haubc6ddb12019-03-08 11:10:15 -08003402 flags |= eTraversalNeeded;
Valerie Haubc6ddb12019-03-08 11:10:15 -08003403 }
Marissa Wallebc2c052019-01-16 19:16:55 -08003404 }
Marissa Walle2ffb422018-10-12 11:33:52 -07003405 if (layer->setTransactionCompletedListeners(callbackHandles)) flags |= eTraversalNeeded;
3406 // Do not put anything that updates layer state or modifies flags after
3407 // setTransactionCompletedListener
Mathias Agopiane57f2922012-08-09 16:29:12 -07003408 return flags;
3409}
3410
chaviw273171b2018-12-26 11:46:30 -08003411uint32_t SurfaceFlinger::addInputWindowCommands(const InputWindowCommands& inputWindowCommands) {
3412 uint32_t flags = 0;
3413 if (!inputWindowCommands.transferTouchFocusCommands.empty()) {
3414 flags |= eTraversalNeeded;
3415 }
3416
chaviwa911b102019-02-14 10:18:33 -08003417 if (inputWindowCommands.syncInputWindows) {
3418 flags |= eTraversalNeeded;
3419 }
3420
Vishnu Nairec0ab382019-02-13 15:32:56 -08003421 mPendingInputWindowCommands.merge(inputWindowCommands);
chaviw273171b2018-12-26 11:46:30 -08003422 return flags;
3423}
3424
Marissa Wall2d814fb2019-04-09 18:52:57 +00003425status_t SurfaceFlinger::createLayer(const String8& name, const sp<Client>& client, uint32_t w,
3426 uint32_t h, PixelFormat format, uint32_t flags,
3427 LayerMetadata metadata, sp<IBinder>* handle,
Robert Carrc0df3122019-04-11 13:18:21 -07003428 sp<IGraphicBufferProducer>* gbp,
3429 const sp<IBinder>& parentHandle,
3430 const sp<Layer>& parentLayer) {
Mathias Agopian6e2d6482009-07-09 18:16:43 -07003431 if (int32_t(w|h) < 0) {
Mathias Agopian921e6ac2012-07-23 23:11:29 -07003432 ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
Mathias Agopian6e2d6482009-07-09 18:16:43 -07003433 int(w), int(h));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003434 return BAD_VALUE;
Mathias Agopian6e2d6482009-07-09 18:16:43 -07003435 }
Andreas Huber8b42e8a2010-08-16 08:49:37 -07003436
Robert Carrc0df3122019-04-11 13:18:21 -07003437 ALOG_ASSERT(parentLayer == nullptr || parentHandle == nullptr,
3438 "Expected only one of parentLayer or parentHandle to be non-null. "
3439 "Programmer error?");
3440
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003441 status_t result = NO_ERROR;
3442
3443 sp<Layer> layer;
3444
Cody Northropbc755282017-03-31 12:00:08 -06003445 String8 uniqueName = getUniqueLayerName(name);
3446
Evan Roskya1f1e152019-01-24 16:17:46 -08003447 bool primaryDisplayOnly = false;
3448
3449 // window type is WINDOW_TYPE_DONT_SCREENSHOT from SurfaceControl.java
3450 // TODO b/64227542
3451 if (metadata.has(METADATA_WINDOW_TYPE)) {
3452 int32_t windowType = metadata.getInt32(METADATA_WINDOW_TYPE, 0);
3453 if (windowType == 441731) {
Ady Abraham8f1ee7f2019-04-05 10:32:50 -07003454 metadata.setInt32(METADATA_WINDOW_TYPE, InputWindowInfo::TYPE_NAVIGATION_BAR_PANEL);
Evan Roskya1f1e152019-01-24 16:17:46 -08003455 primaryDisplayOnly = true;
3456 }
3457 }
3458
Mathias Agopian3165cc22012-08-08 19:42:09 -07003459 switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
Marissa Wall61c58622018-07-18 10:12:20 -07003460 case ISurfaceComposerClient::eFXSurfaceBufferQueue:
Evan Roskya1f1e152019-01-24 16:17:46 -08003461 result = createBufferQueueLayer(client, uniqueName, w, h, flags, std::move(metadata),
3462 format, handle, gbp, &layer);
David Sodman0c69cad2017-08-21 12:12:51 -07003463
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003464 break;
Marissa Wall61c58622018-07-18 10:12:20 -07003465 case ISurfaceComposerClient::eFXSurfaceBufferState:
Evan Roskya1f1e152019-01-24 16:17:46 -08003466 result = createBufferStateLayer(client, uniqueName, w, h, flags, std::move(metadata),
3467 handle, &layer);
Marissa Wall61c58622018-07-18 10:12:20 -07003468 break;
chaviw13fdc492017-06-27 12:40:18 -07003469 case ISurfaceComposerClient::eFXSurfaceColor:
Vishnu Nair88a11f22018-11-28 18:30:57 -08003470 // check if buffer size is set for color layer.
3471 if (w > 0 || h > 0) {
3472 ALOGE("createLayer() failed, w or h cannot be set for color layer (w=%d, h=%d)",
3473 int(w), int(h));
3474 return BAD_VALUE;
3475 }
3476
Evan Roskya1f1e152019-01-24 16:17:46 -08003477 result = createColorLayer(client, uniqueName, w, h, flags, std::move(metadata), handle,
3478 &layer);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003479 break;
Robert Carr6b3f6c52018-08-13 13:05:17 -07003480 case ISurfaceComposerClient::eFXSurfaceContainer:
Vishnu Nair88a11f22018-11-28 18:30:57 -08003481 // check if buffer size is set for container layer.
3482 if (w > 0 || h > 0) {
3483 ALOGE("createLayer() failed, w or h cannot be set for container layer (w=%d, h=%d)",
3484 int(w), int(h));
3485 return BAD_VALUE;
3486 }
Evan Roskya1f1e152019-01-24 16:17:46 -08003487 result = createContainerLayer(client, uniqueName, w, h, flags, std::move(metadata),
3488 handle, &layer);
Robert Carr6b3f6c52018-08-13 13:05:17 -07003489 break;
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003490 default:
3491 result = BAD_VALUE;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003492 break;
3493 }
3494
Dan Stoza7d89d062015-04-30 13:29:25 -07003495 if (result != NO_ERROR) {
3496 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003497 }
Dan Stoza7d89d062015-04-30 13:29:25 -07003498
Evan Roskya1f1e152019-01-24 16:17:46 -08003499 if (primaryDisplayOnly) {
3500 layer->setPrimaryDisplayOnly();
Chia-I Wuab0c3192017-08-01 11:29:00 -07003501 }
3502
Robert Carrb89ea9d2018-12-10 13:01:14 -08003503 bool addToCurrentState = callingThreadHasUnscopedSurfaceFlingerAccess();
Robert Carrc0df3122019-04-11 13:18:21 -07003504 result = addClientLayer(client, *handle, *gbp, layer, parentHandle, parentLayer,
3505 addToCurrentState);
Dan Stoza7d89d062015-04-30 13:29:25 -07003506 if (result != NO_ERROR) {
3507 return result;
3508 }
Lloyd Pique4dccc412018-01-22 17:21:36 -08003509 mInterceptor->saveSurfaceCreation(layer);
Dan Stoza7d89d062015-04-30 13:29:25 -07003510
3511 setTransactionFlags(eTransactionNeeded);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003512 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003513}
3514
Cody Northropbc755282017-03-31 12:00:08 -06003515String8 SurfaceFlinger::getUniqueLayerName(const String8& name)
3516{
3517 bool matchFound = true;
3518 uint32_t dupeCounter = 0;
3519
3520 // Tack on our counter whether there is a hit or not, so everyone gets a tag
3521 String8 uniqueName = name + "#" + String8(std::to_string(dupeCounter).c_str());
3522
Dan Stoza436ccf32018-06-21 12:10:12 -07003523 // Grab the state lock since we're accessing mCurrentState
3524 Mutex::Autolock lock(mStateLock);
3525
Cody Northropbc755282017-03-31 12:00:08 -06003526 // Loop over layers until we're sure there is no matching name
3527 while (matchFound) {
3528 matchFound = false;
Dan Stoza436ccf32018-06-21 12:10:12 -07003529 mCurrentState.traverseInZOrder([&](Layer* layer) {
Cody Northropbc755282017-03-31 12:00:08 -06003530 if (layer->getName() == uniqueName) {
3531 matchFound = true;
3532 uniqueName = name + "#" + String8(std::to_string(++dupeCounter).c_str());
3533 }
3534 });
3535 }
3536
Marissa Wallf1de4bd2018-05-22 13:05:01 -07003537 ALOGV_IF(dupeCounter > 0, "duplicate layer name: changing %s to %s", name.c_str(),
3538 uniqueName.c_str());
Cody Northropbc755282017-03-31 12:00:08 -06003539
3540 return uniqueName;
3541}
3542
Marissa Wallfd668622018-05-10 10:21:13 -07003543status_t SurfaceFlinger::createBufferQueueLayer(const sp<Client>& client, const String8& name,
3544 uint32_t w, uint32_t h, uint32_t flags,
Evan Roskya1f1e152019-01-24 16:17:46 -08003545 LayerMetadata metadata, PixelFormat& format,
3546 sp<IBinder>* handle,
Marissa Wallfd668622018-05-10 10:21:13 -07003547 sp<IGraphicBufferProducer>* gbp,
3548 sp<Layer>* outLayer) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003549 // initialize the surfaces
Mathias Agopian92a979a2012-08-02 18:32:23 -07003550 switch (format) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003551 case PIXEL_FORMAT_TRANSPARENT:
3552 case PIXEL_FORMAT_TRANSLUCENT:
3553 format = PIXEL_FORMAT_RGBA_8888;
3554 break;
3555 case PIXEL_FORMAT_OPAQUE:
Mathias Agopian8f105402010-04-05 18:01:24 -07003556 format = PIXEL_FORMAT_RGBX_8888;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003557 break;
3558 }
3559
Evan Roskya1f1e152019-01-24 16:17:46 -08003560 sp<BufferQueueLayer> layer = getFactory().createBufferQueueLayer(
3561 LayerCreationArgs(this, client, name, w, h, flags, std::move(metadata)));
Marissa Wallfd668622018-05-10 10:21:13 -07003562 status_t err = layer->setDefaultBufferProperties(w, h, format);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003563 if (err == NO_ERROR) {
David Sodman0c69cad2017-08-21 12:12:51 -07003564 *handle = layer->getHandle();
3565 *gbp = layer->getProducer();
3566 *outLayer = layer;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003567 }
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003568
Marissa Wallfd668622018-05-10 10:21:13 -07003569 ALOGE_IF(err, "createBufferQueueLayer() failed (%s)", strerror(-err));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003570 return err;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003571}
3572
Marissa Wall61c58622018-07-18 10:12:20 -07003573status_t SurfaceFlinger::createBufferStateLayer(const sp<Client>& client, const String8& name,
3574 uint32_t w, uint32_t h, uint32_t flags,
Evan Roskya1f1e152019-01-24 16:17:46 -08003575 LayerMetadata metadata, sp<IBinder>* handle,
3576 sp<Layer>* outLayer) {
3577 sp<BufferStateLayer> layer = getFactory().createBufferStateLayer(
3578 LayerCreationArgs(this, client, name, w, h, flags, std::move(metadata)));
Marissa Wall61c58622018-07-18 10:12:20 -07003579 *handle = layer->getHandle();
3580 *outLayer = layer;
3581
3582 return NO_ERROR;
3583}
3584
Evan Roskya1f1e152019-01-24 16:17:46 -08003585status_t SurfaceFlinger::createColorLayer(const sp<Client>& client, const String8& name, uint32_t w,
3586 uint32_t h, uint32_t flags, LayerMetadata metadata,
3587 sp<IBinder>* handle, sp<Layer>* outLayer) {
3588 *outLayer = getFactory().createColorLayer(
3589 LayerCreationArgs(this, client, name, w, h, flags, std::move(metadata)));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003590 *handle = (*outLayer)->getHandle();
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003591 return NO_ERROR;
Mathias Agopian118d0242011-10-13 16:02:48 -07003592}
3593
Evan Roskya1f1e152019-01-24 16:17:46 -08003594status_t SurfaceFlinger::createContainerLayer(const sp<Client>& client, const String8& name,
3595 uint32_t w, uint32_t h, uint32_t flags,
3596 LayerMetadata metadata, sp<IBinder>* handle,
3597 sp<Layer>* outLayer) {
3598 *outLayer = getFactory().createContainerLayer(
3599 LayerCreationArgs(this, client, name, w, h, flags, std::move(metadata)));
Robert Carr6b3f6c52018-08-13 13:05:17 -07003600 *handle = (*outLayer)->getHandle();
3601 return NO_ERROR;
3602}
3603
3604
Robert Carr6fb1a7e2018-12-11 12:07:25 -08003605void SurfaceFlinger::markLayerPendingRemovalLocked(const sp<Layer>& layer) {
Robert Carr2e102c92018-10-23 12:11:15 -07003606 mLayersPendingRemoval.add(layer);
3607 mLayersRemoved = true;
3608 setTransactionFlags(eTransactionNeeded);
3609}
3610
Robert Carr695d5282018-12-18 15:27:58 -08003611void SurfaceFlinger::onHandleDestroyed(sp<Layer>& layer)
Rob Carr4bba3702018-10-08 21:53:30 +00003612{
Robert Carr2e102c92018-10-23 12:11:15 -07003613 Mutex::Autolock lock(mStateLock);
Robert Carr6fb1a7e2018-12-11 12:07:25 -08003614 // If a layer has a parent, we allow it to out-live it's handle
3615 // with the idea that the parent holds a reference and will eventually
3616 // be cleaned up. However no one cleans up the top-level so we do so
3617 // here.
3618 if (layer->getParent() == nullptr) {
3619 mCurrentState.layersSortedByZ.remove(layer);
3620 }
3621 markLayerPendingRemovalLocked(layer);
Robert Carrc0df3122019-04-11 13:18:21 -07003622
3623 auto it = mLayersByLocalBinderToken.begin();
3624 while (it != mLayersByLocalBinderToken.end()) {
3625 if (it->second == layer) {
3626 it = mLayersByLocalBinderToken.erase(it);
3627 } else {
3628 it++;
3629 }
3630 }
3631
Robert Carr695d5282018-12-18 15:27:58 -08003632 layer.clear();
Rob Carr4bba3702018-10-08 21:53:30 +00003633}
3634
Mathias Agopianb60314a2012-04-10 22:09:54 -07003635// ---------------------------------------------------------------------------
3636
Andy McFadden13a082e2012-08-24 10:16:42 -07003637void SurfaceFlinger::onInitializeDisplays() {
Dominik Laskowski83b88212018-12-11 13:34:06 -08003638 const auto display = getDefaultDisplayDeviceLocked();
3639 if (!display) return;
3640
3641 const sp<IBinder> token = display->getDisplayToken().promote();
3642 LOG_ALWAYS_FATAL_IF(token == nullptr);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07003643
Jesse Hall01e29052013-02-19 16:13:35 -08003644 // reset screen orientation and use primary layer stack
Andy McFadden13a082e2012-08-24 10:16:42 -07003645 Vector<ComposerState> state;
3646 Vector<DisplayState> displays;
3647 DisplayState d;
Jesse Hall01e29052013-02-19 16:13:35 -08003648 d.what = DisplayState::eDisplayProjectionChanged |
3649 DisplayState::eLayerStackChanged;
Dominik Laskowski83b88212018-12-11 13:34:06 -08003650 d.token = token;
Jesse Hall01e29052013-02-19 16:13:35 -08003651 d.layerStack = 0;
Andy McFadden13a082e2012-08-24 10:16:42 -07003652 d.orientation = DisplayState::eOrientationDefault;
Jeff Brown4c05dd12012-09-09 00:07:17 -07003653 d.frame.makeInvalid();
3654 d.viewport.makeInvalid();
Michael Lentine47e45402014-07-18 15:34:25 -07003655 d.width = 0;
3656 d.height = 0;
Andy McFadden13a082e2012-08-24 10:16:42 -07003657 displays.add(d);
Valerie Hau9dab9732019-08-20 09:29:25 -07003658 setTransactionState(state, displays, 0, nullptr, mPendingInputWindowCommands, -1, {}, false,
3659 {});
Jamie Gennis6547ff42013-07-16 20:12:42 -07003660
Dominik Laskowskie9774092018-12-11 10:04:24 -08003661 setPowerModeInternal(display, HWC_POWER_MODE_NORMAL);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07003662
Dominik Laskowski83b88212018-12-11 13:34:06 -08003663 const nsecs_t vsyncPeriod = getVsyncPeriod();
3664 mAnimFrameTracker.setDisplayRefreshPeriod(vsyncPeriod);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08003665
Brian Andersond0010582017-03-07 13:20:31 -08003666 // Use phase of 0 since phase is not known.
3667 // Use latency of 0, which will snap to the ideal latency.
Dominik Laskowski83b88212018-12-11 13:34:06 -08003668 DisplayStatInfo stats{0 /* vsyncTime */, vsyncPeriod};
Ana Krulece588e312018-09-18 12:32:24 -07003669 setCompositorTimingSnapped(stats, 0);
Andy McFadden13a082e2012-08-24 10:16:42 -07003670}
3671
3672void SurfaceFlinger::initializeDisplays() {
Dominik Laskowski8c001672018-05-30 16:52:06 -07003673 // Async since we may be called from the main thread.
Dominik Laskowski83b88212018-12-11 13:34:06 -08003674 postMessageAsync(
3675 new LambdaMessage([this]() NO_THREAD_SAFETY_ANALYSIS { onInitializeDisplays(); }));
Andy McFadden13a082e2012-08-24 10:16:42 -07003676}
3677
Ady Abraham27c70212019-06-11 10:52:26 -07003678void SurfaceFlinger::setVsyncEnabledInHWC(DisplayId displayId, HWC2::Vsync enabled) {
3679 if (mHWCVsyncState != enabled) {
3680 getHwComposer().setVsyncEnabled(displayId, enabled);
3681 mHWCVsyncState = enabled;
3682 }
3683}
3684
Dominik Laskowskie9774092018-12-11 10:04:24 -08003685void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& display, int mode) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07003686 if (display->isVirtual()) {
3687 ALOGE("%s: Invalid operation on virtual display", __FUNCTION__);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07003688 return;
3689 }
3690
Dominik Laskowski075d3172018-05-24 15:50:06 -07003691 const auto displayId = display->getId();
3692 LOG_ALWAYS_FATAL_IF(!displayId);
3693
Dominik Laskowski34157762018-10-31 13:07:19 -07003694 ALOGD("Setting power mode %d on display %s", mode, to_string(*displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07003695
3696 int currentMode = display->getPowerMode();
3697 if (mode == currentMode) {
Prashant Malani2c9b11f2014-05-25 01:36:31 -07003698 return;
3699 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07003700
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003701 display->setPowerMode(mode);
3702
Lloyd Pique4dccc412018-01-22 17:21:36 -08003703 if (mInterceptor->isEnabled()) {
Dominik Laskowskie9774092018-12-11 10:04:24 -08003704 mInterceptor->savePowerModeUpdate(display->getSequenceId(), mode);
Irvelffc9efc2016-07-27 15:16:37 -07003705 }
3706
Prashant Malani2c9b11f2014-05-25 01:36:31 -07003707 if (currentMode == HWC_POWER_MODE_OFF) {
Tim Murrayf9d4e442016-08-02 15:43:59 -07003708 // Turn on the display
Dominik Laskowski075d3172018-05-24 15:50:06 -07003709 getHwComposer().setPowerMode(*displayId, mode);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003710 if (display->isPrimary() && mode != HWC_POWER_MODE_DOZE_SUSPEND) {
Ady Abraham27c70212019-06-11 10:52:26 -07003711 setVsyncEnabledInHWC(*displayId, mHWCVsyncPendingState);
Ana Krulecc2870422019-01-29 19:00:58 -08003712 mScheduler->onScreenAcquired(mAppConnectionHandle);
3713 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
Andy McFaddenc01a79d2012-09-27 16:02:06 -07003714 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003715
Prashant Malani2c9b11f2014-05-25 01:36:31 -07003716 mVisibleRegionsDirty = true;
Dan Stozab90cf072015-03-05 11:05:59 -08003717 mHasPoweredOff = true;
Dan Stozac7a25ad2018-04-12 11:45:09 -07003718 repaintEverything();
Tim Murrayf9d4e442016-08-02 15:43:59 -07003719
3720 struct sched_param param = {0};
3721 param.sched_priority = 1;
3722 if (sched_setscheduler(0, SCHED_FIFO, &param) != 0) {
3723 ALOGW("Couldn't set SCHED_FIFO on display on");
3724 }
Prashant Malani2c9b11f2014-05-25 01:36:31 -07003725 } else if (mode == HWC_POWER_MODE_OFF) {
Tim Murrayf9d4e442016-08-02 15:43:59 -07003726 // Turn off the display
3727 struct sched_param param = {0};
3728 if (sched_setscheduler(0, SCHED_OTHER, &param) != 0) {
3729 ALOGW("Couldn't set SCHED_OTHER on display off");
3730 }
3731
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003732 if (display->isPrimary() && currentMode != HWC_POWER_MODE_DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08003733 mScheduler->disableHardwareVsync(true);
3734 mScheduler->onScreenReleased(mAppConnectionHandle);
Mathias Agopiancde87a32012-09-13 14:09:01 -07003735 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07003736
Ady Abraham27c70212019-06-11 10:52:26 -07003737 // Make sure HWVsync is disabled before turning off the display
3738 setVsyncEnabledInHWC(*displayId, HWC2::Vsync::Disable);
3739
Dominik Laskowski075d3172018-05-24 15:50:06 -07003740 getHwComposer().setPowerMode(*displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07003741 mVisibleRegionsDirty = true;
3742 // from this point on, SF will stop drawing on this display
Matthew Bouyack38d49612017-05-12 12:49:32 -07003743 } else if (mode == HWC_POWER_MODE_DOZE ||
3744 mode == HWC_POWER_MODE_NORMAL) {
Zheng Zhang8a43fe62017-03-17 11:19:39 +01003745 // Update display while dozing
Dominik Laskowski075d3172018-05-24 15:50:06 -07003746 getHwComposer().setPowerMode(*displayId, mode);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003747 if (display->isPrimary() && currentMode == HWC_POWER_MODE_DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08003748 mScheduler->onScreenAcquired(mAppConnectionHandle);
3749 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
Zheng Zhang8a43fe62017-03-17 11:19:39 +01003750 }
3751 } else if (mode == HWC_POWER_MODE_DOZE_SUSPEND) {
3752 // Leave display going to doze
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003753 if (display->isPrimary()) {
Ana Krulecc2870422019-01-29 19:00:58 -08003754 mScheduler->disableHardwareVsync(true);
3755 mScheduler->onScreenReleased(mAppConnectionHandle);
Zheng Zhang8a43fe62017-03-17 11:19:39 +01003756 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07003757 getHwComposer().setPowerMode(*displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07003758 } else {
Matthew Bouyack38d49612017-05-12 12:49:32 -07003759 ALOGE("Attempting to set unknown power mode: %d\n", mode);
Dominik Laskowski075d3172018-05-24 15:50:06 -07003760 getHwComposer().setPowerMode(*displayId, mode);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07003761 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003762
Yiwei Zhang3a226d22018-10-16 09:23:03 -07003763 if (display->isPrimary()) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08003764 mTimeStats->setPowerMode(mode);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003765 mRefreshRateStats->setPowerMode(mode);
Ady Abraham6fe2c172019-07-12 12:37:57 -07003766 mScheduler->setDisplayPowerState(mode == HWC_POWER_MODE_NORMAL);
Yiwei Zhang3a226d22018-10-16 09:23:03 -07003767 }
3768
Dominik Laskowski34157762018-10-31 13:07:19 -07003769 ALOGD("Finished setting power mode %d on display %s", mode, to_string(*displayId).c_str());
Andy McFaddenc01a79d2012-09-27 16:02:06 -07003770}
3771
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003772void SurfaceFlinger::setPowerMode(const sp<IBinder>& displayToken, int mode) {
Dominik Laskowski83b88212018-12-11 13:34:06 -08003773 postMessageSync(new LambdaMessage([&]() NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003774 const auto display = getDisplayDevice(displayToken);
3775 if (!display) {
3776 ALOGE("Attempt to set power mode %d for invalid display token %p", mode,
3777 displayToken.get());
3778 } else if (display->isVirtual()) {
3779 ALOGW("Attempt to set power mode %d for virtual display", mode);
3780 } else {
Dominik Laskowskie9774092018-12-11 10:04:24 -08003781 setPowerModeInternal(display, mode);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07003782 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07003783 }));
Mathias Agopianb60314a2012-04-10 22:09:54 -07003784}
3785
3786// ---------------------------------------------------------------------------
3787
Dominik Laskowskic2867142019-01-21 11:33:38 -08003788status_t SurfaceFlinger::doDump(int fd, const DumpArgs& args,
3789 bool asProto) NO_THREAD_SAFETY_ANALYSIS {
Yiwei Zhang5434a782018-12-05 18:06:32 -08003790 std::string result;
Mathias Agopian99b49842011-06-27 16:05:52 -07003791
Mathias Agopianbd115332013-04-18 16:41:04 -07003792 IPCThreadState* ipc = IPCThreadState::self();
3793 const int pid = ipc->getCallingPid();
3794 const int uid = ipc->getCallingUid();
Vishnu Nair6a408532017-10-24 09:11:27 -07003795
Mathias Agopianbd115332013-04-18 16:41:04 -07003796 if ((uid != AID_SHELL) &&
3797 !PermissionCache::checkPermission(sDump, pid, uid)) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08003798 StringAppendF(&result, "Permission Denial: can't dump SurfaceFlinger from pid=%d, uid=%d\n",
3799 pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003800 } else {
Jesse Hallfcd15b42014-12-23 13:57:23 -08003801 // Try to get the main lock, but give up after one second
Mathias Agopian9795c422009-08-26 16:36:26 -07003802 // (this would indicate SF is stuck, but we want to be able to
3803 // print something in dumpsys).
Jesse Hallfcd15b42014-12-23 13:57:23 -08003804 status_t err = mStateLock.timedLock(s2ns(1));
3805 bool locked = (err == NO_ERROR);
Mathias Agopian9795c422009-08-26 16:36:26 -07003806 if (!locked) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08003807 StringAppendF(&result,
3808 "SurfaceFlinger appears to be unresponsive (%s [%d]), dumping anyways "
3809 "(no locks held)\n",
3810 strerror(-err), err);
Mathias Agopian9795c422009-08-26 16:36:26 -07003811 }
3812
Dominik Laskowskic2867142019-01-21 11:33:38 -08003813 using namespace std::string_literals;
chaviwa3d7bd32017-11-03 09:41:53 -07003814
Dominik Laskowskic2867142019-01-21 11:33:38 -08003815 static const std::unordered_map<std::string, Dumper> dumpers = {
Dominik Laskowskic2867142019-01-21 11:33:38 -08003816 {"--display-id"s, dumper(&SurfaceFlinger::dumpDisplayIdentificationData)},
Dominik Laskowski98041832019-08-01 18:35:59 -07003817 {"--dispsync"s,
3818 dumper([this](std::string& s) { mScheduler->getPrimaryDispSync().dump(s); })},
Dominik Laskowskib6e54372019-09-04 14:06:28 -07003819 {"--edid"s, argsDumper(&SurfaceFlinger::dumpRawDisplayIdentificationData)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08003820 {"--frame-events"s, dumper(&SurfaceFlinger::dumpFrameEventsLocked)},
3821 {"--latency"s, argsDumper(&SurfaceFlinger::dumpStatsLocked)},
3822 {"--latency-clear"s, argsDumper(&SurfaceFlinger::clearStatsLocked)},
3823 {"--list"s, dumper(&SurfaceFlinger::listLayersLocked)},
3824 {"--static-screen"s, dumper(&SurfaceFlinger::dumpStaticScreenStats)},
3825 {"--timestats"s, protoDumper(&SurfaceFlinger::dumpTimeStats)},
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08003826 {"--vsync"s, dumper(&SurfaceFlinger::dumpVSync)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08003827 {"--wide-color"s, dumper(&SurfaceFlinger::dumpWideColorInfo)},
3828 };
Mathias Agopian25e66fc2012-01-28 22:31:55 -08003829
Dominik Laskowskic2867142019-01-21 11:33:38 -08003830 const auto flag = args.empty() ? ""s : std::string(String8(args[0]));
Mathias Agopian25e66fc2012-01-28 22:31:55 -08003831
Dominik Laskowski46470112019-08-02 13:13:11 -07003832 const auto it = dumpers.find(flag);
3833 if (it != dumpers.end()) {
Dominik Laskowskic2867142019-01-21 11:33:38 -08003834 (it->second)(args, asProto, result);
Vishnu Nair8406fd72019-07-30 11:29:31 -07003835 } else if (!asProto) {
3836 dumpAllLocked(args, result);
Mathias Agopian48b888a2011-01-19 16:15:53 -08003837 }
3838
Mathias Agopian9795c422009-08-26 16:36:26 -07003839 if (locked) {
3840 mStateLock.unlock();
3841 }
Vishnu Nair8406fd72019-07-30 11:29:31 -07003842
Dominik Laskowski46470112019-08-02 13:13:11 -07003843 if (it == dumpers.end()) {
3844 const LayersProto layersProto = dumpProtoFromMainThread();
3845 if (asProto) {
3846 result.append(layersProto.SerializeAsString());
3847 } else {
Vishnu Nair0f085c62019-08-30 08:49:12 -07003848 // Dump info that we need to access from the main thread
Dominik Laskowski46470112019-08-02 13:13:11 -07003849 const auto layerTree = LayerProtoParser::generateLayerTree(layersProto);
3850 result.append(LayerProtoParser::layerTreeToString(layerTree));
3851 result.append("\n");
Vishnu Nair0f085c62019-08-30 08:49:12 -07003852 dumpOffscreenLayers(result);
Dominik Laskowski46470112019-08-02 13:13:11 -07003853 }
Vishnu Nair8406fd72019-07-30 11:29:31 -07003854 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003855 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08003856 write(fd, result.c_str(), result.size());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003857 return NO_ERROR;
3858}
3859
Nataniel Borges8e7dc722019-02-28 15:10:28 -08003860status_t SurfaceFlinger::dumpCritical(int fd, const DumpArgs&, bool asProto) {
3861 if (asProto && mTracing.isEnabled()) {
3862 mTracing.writeToFileAsync();
3863 }
3864
3865 return doDump(fd, DumpArgs(), asProto);
3866}
3867
Dominik Laskowskic2867142019-01-21 11:33:38 -08003868void SurfaceFlinger::listLayersLocked(std::string& result) const {
Yiwei Zhang5434a782018-12-05 18:06:32 -08003869 mCurrentState.traverseInZOrder(
3870 [&](Layer* layer) { StringAppendF(&result, "%s\n", layer->getName().string()); });
Mathias Agopian25e66fc2012-01-28 22:31:55 -08003871}
3872
Dominik Laskowskic2867142019-01-21 11:33:38 -08003873void SurfaceFlinger::dumpStatsLocked(const DumpArgs& args, std::string& result) const {
Dominik Laskowski83b88212018-12-11 13:34:06 -08003874 StringAppendF(&result, "%" PRId64 "\n", getVsyncPeriod());
Jamie Gennis4b0eba92013-02-05 13:30:24 -08003875
Dominik Laskowskic2867142019-01-21 11:33:38 -08003876 if (args.size() > 1) {
3877 const auto name = String8(args[1]);
Robert Carr2047fae2016-11-28 14:09:09 -08003878 mCurrentState.traverseInZOrder([&](Layer* layer) {
Jamie Gennis4b0eba92013-02-05 13:30:24 -08003879 if (name == layer->getName()) {
Svetoslavd85084b2014-03-20 10:28:31 -07003880 layer->dumpFrameStats(result);
Jamie Gennis4b0eba92013-02-05 13:30:24 -08003881 }
Robert Carr2047fae2016-11-28 14:09:09 -08003882 });
Dominik Laskowskic2867142019-01-21 11:33:38 -08003883 } else {
3884 mAnimFrameTracker.dumpStats(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08003885 }
3886}
3887
Dominik Laskowskic2867142019-01-21 11:33:38 -08003888void SurfaceFlinger::clearStatsLocked(const DumpArgs& args, std::string&) {
Robert Carr2047fae2016-11-28 14:09:09 -08003889 mCurrentState.traverseInZOrder([&](Layer* layer) {
Dominik Laskowskic2867142019-01-21 11:33:38 -08003890 if (args.size() < 2 || String8(args[1]) == layer->getName()) {
Svetoslavd85084b2014-03-20 10:28:31 -07003891 layer->clearFrameStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08003892 }
Robert Carr2047fae2016-11-28 14:09:09 -08003893 });
Jamie Gennis4b0eba92013-02-05 13:30:24 -08003894
Svetoslavd85084b2014-03-20 10:28:31 -07003895 mAnimFrameTracker.clearStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08003896}
3897
Dominik Laskowskic2867142019-01-21 11:33:38 -08003898void SurfaceFlinger::dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const {
3899 mTimeStats->parseArgs(asProto, args, result);
3900}
3901
Jamie Gennis6547ff42013-07-16 20:12:42 -07003902// This should only be called from the main thread. Otherwise it would need
3903// the lock and should use mCurrentState rather than mDrawingState.
3904void SurfaceFlinger::logFrameStats() {
Robert Carr2047fae2016-11-28 14:09:09 -08003905 mDrawingState.traverseInZOrder([&](Layer* layer) {
Jamie Gennis6547ff42013-07-16 20:12:42 -07003906 layer->logFrameStats();
Robert Carr2047fae2016-11-28 14:09:09 -08003907 });
Jamie Gennis6547ff42013-07-16 20:12:42 -07003908
3909 mAnimFrameTracker.logAndResetStats(String8("<win-anim>"));
3910}
3911
Yiwei Zhang5434a782018-12-05 18:06:32 -08003912void SurfaceFlinger::appendSfConfigString(std::string& result) const {
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08003913 result.append(" [sf");
Fabien Sanglardc93afd52017-03-13 13:02:42 -07003914
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08003915 if (isLayerTripleBufferingDisabled())
3916 result.append(" DISABLE_TRIPLE_BUFFERING");
Fabien Sanglardc45a7d92017-03-14 13:24:22 -07003917
Yiwei Zhang5434a782018-12-05 18:06:32 -08003918 StringAppendF(&result, " PRESENT_TIME_OFFSET=%" PRId64, dispSyncPresentTimeOffset);
3919 StringAppendF(&result, " FORCE_HWC_FOR_RBG_TO_YUV=%d", useHwcForRgbToYuv);
3920 StringAppendF(&result, " MAX_VIRT_DISPLAY_DIM=%" PRIu64, maxVirtualDisplaySize);
3921 StringAppendF(&result, " RUNNING_WITHOUT_SYNC_FRAMEWORK=%d", !hasSyncFramework);
3922 StringAppendF(&result, " NUM_FRAMEBUFFER_SURFACE_BUFFERS=%" PRId64,
3923 maxFrameBufferAcquiredBuffers);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08003924 result.append("]");
Andy McFadden4803b742012-09-24 19:07:20 -07003925}
3926
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08003927void SurfaceFlinger::dumpVSync(std::string& result) const {
Dominik Laskowski98041832019-08-01 18:35:59 -07003928 mScheduler->dump(result);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003929 StringAppendF(&result, "+ Refresh rate switching: %s\n",
3930 mRefreshRateConfigs->refreshRateSwitchingSupported() ? "on" : "off");
Dominik Laskowski98041832019-08-01 18:35:59 -07003931 StringAppendF(&result, "+ Smart video mode: %s\n\n", mUseSmart90ForVideo ? "on" : "off");
3932
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003933 mRefreshRateStats->dump(result);
Dominik Laskowski98041832019-08-01 18:35:59 -07003934 result.append("\n");
3935
Ana Krulec757f63a2019-01-25 10:46:18 -08003936 mPhaseOffsets->dump(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08003937 StringAppendF(&result,
Dominik Laskowski98041832019-08-01 18:35:59 -07003938 " present offset: %9" PRId64 " ns\t VSYNC period: %9" PRId64 " ns\n\n",
Ana Krulec757f63a2019-01-25 10:46:18 -08003939 dispSyncPresentTimeOffset, getVsyncPeriod());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08003940
Ady Abraham42b3beb2019-07-09 18:09:52 -07003941 StringAppendF(&result, "Allowed Display Configs: ");
Steven Thomas2bbaabe2019-08-28 16:08:35 -07003942 for (int32_t configId : mAllowedDisplayConfigs) {
3943 StringAppendF(&result, "%" PRIu32 " Hz, ",
3944 mRefreshRateConfigs->getRefreshRateFromConfigId(configId).fps);
Ady Abraham42b3beb2019-07-09 18:09:52 -07003945 }
3946 StringAppendF(&result, "(config override by backdoor: %s)\n\n",
3947 mDebugDisplayConfigSetByBackdoor ? "yes" : "no");
Dominik Laskowski98041832019-08-01 18:35:59 -07003948
Ana Krulecc2870422019-01-29 19:00:58 -08003949 mScheduler->dump(mAppConnectionHandle, result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08003950}
3951
Yiwei Zhang5434a782018-12-05 18:06:32 -08003952void SurfaceFlinger::dumpStaticScreenStats(std::string& result) const {
3953 result.append("Static screen stats:\n");
David Sodman4a36e932017-11-07 14:29:47 -08003954 for (size_t b = 0; b < SurfaceFlingerBE::NUM_BUCKETS - 1; ++b) {
3955 float bucketTimeSec = getBE().mFrameBuckets[b] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08003956 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08003957 static_cast<float>(getBE().mFrameBuckets[b]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08003958 StringAppendF(&result, " < %zd frames: %.3f s (%.1f%%)\n", b + 1, bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08003959 }
David Sodman4a36e932017-11-07 14:29:47 -08003960 float bucketTimeSec = getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08003961 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08003962 static_cast<float>(getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08003963 StringAppendF(&result, " %zd+ frames: %.3f s (%.1f%%)\n", SurfaceFlingerBE::NUM_BUCKETS - 1,
3964 bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08003965}
3966
Dan Stozae77c7662016-05-13 11:37:28 -07003967void SurfaceFlinger::recordBufferingStats(const char* layerName,
3968 std::vector<OccupancyTracker::Segment>&& history) {
David Sodmancbaf0832017-11-07 14:21:36 -08003969 Mutex::Autolock lock(getBE().mBufferingStatsMutex);
3970 auto& stats = getBE().mBufferingStats[layerName];
Dan Stozae77c7662016-05-13 11:37:28 -07003971 for (const auto& segment : history) {
3972 if (!segment.usedThirdBuffer) {
3973 stats.twoBufferTime += segment.totalTime;
3974 }
3975 if (segment.occupancyAverage < 1.0f) {
3976 stats.doubleBufferedTime += segment.totalTime;
3977 } else if (segment.occupancyAverage < 2.0f) {
3978 stats.tripleBufferedTime += segment.totalTime;
3979 }
3980 ++stats.numSegments;
3981 stats.totalTime += segment.totalTime;
3982 }
3983}
3984
Yiwei Zhang5434a782018-12-05 18:06:32 -08003985void SurfaceFlinger::dumpFrameEventsLocked(std::string& result) {
3986 result.append("Layer frame timestamps:\n");
Brian Andersond6927fb2016-07-23 23:37:30 -07003987
3988 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
3989 const size_t count = currentLayers.size();
3990 for (size_t i=0 ; i<count ; i++) {
3991 currentLayers[i]->dumpFrameEvents(result);
3992 }
3993}
3994
Yiwei Zhang5434a782018-12-05 18:06:32 -08003995void SurfaceFlinger::dumpBufferingStats(std::string& result) const {
Dan Stozae77c7662016-05-13 11:37:28 -07003996 result.append("Buffering stats:\n");
3997 result.append(" [Layer name] <Active time> <Two buffer> "
3998 "<Double buffered> <Triple buffered>\n");
David Sodmancbaf0832017-11-07 14:21:36 -08003999 Mutex::Autolock lock(getBE().mBufferingStatsMutex);
Dan Stozae77c7662016-05-13 11:37:28 -07004000 typedef std::tuple<std::string, float, float, float> BufferTuple;
4001 std::map<float, BufferTuple, std::greater<float>> sorted;
David Sodmancbaf0832017-11-07 14:21:36 -08004002 for (const auto& statsPair : getBE().mBufferingStats) {
Dan Stozae77c7662016-05-13 11:37:28 -07004003 const char* name = statsPair.first.c_str();
David Sodmancbaf0832017-11-07 14:21:36 -08004004 const SurfaceFlingerBE::BufferingStats& stats = statsPair.second;
Dan Stozae77c7662016-05-13 11:37:28 -07004005 if (stats.numSegments == 0) {
4006 continue;
4007 }
4008 float activeTime = ns2ms(stats.totalTime) / 1000.0f;
4009 float twoBufferRatio = static_cast<float>(stats.twoBufferTime) /
4010 stats.totalTime;
4011 float doubleBufferRatio = static_cast<float>(
4012 stats.doubleBufferedTime) / stats.totalTime;
4013 float tripleBufferRatio = static_cast<float>(
4014 stats.tripleBufferedTime) / stats.totalTime;
4015 sorted.insert({activeTime, {name, twoBufferRatio,
4016 doubleBufferRatio, tripleBufferRatio}});
4017 }
4018 for (const auto& sortedPair : sorted) {
4019 float activeTime = sortedPair.first;
4020 const BufferTuple& values = sortedPair.second;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004021 StringAppendF(&result, " [%s] %.2f %.3f %.3f %.3f\n", std::get<0>(values).c_str(),
4022 activeTime, std::get<1>(values), std::get<2>(values), std::get<3>(values));
Dan Stozae77c7662016-05-13 11:37:28 -07004023 }
4024 result.append("\n");
4025}
4026
Yiwei Zhang5434a782018-12-05 18:06:32 -08004027void SurfaceFlinger::dumpDisplayIdentificationData(std::string& result) const {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004028 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004029 const auto displayId = display->getId();
4030 if (!displayId) {
4031 continue;
4032 }
4033 const auto hwcDisplayId = getHwComposer().fromPhysicalDisplayId(*displayId);
Dominik Laskowski7e045462018-05-30 13:02:02 -07004034 if (!hwcDisplayId) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004035 continue;
4036 }
4037
Yiwei Zhang5434a782018-12-05 18:06:32 -08004038 StringAppendF(&result,
4039 "Display %s (HWC display %" PRIu64 "): ", to_string(*displayId).c_str(),
4040 *hwcDisplayId);
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004041 uint8_t port;
4042 DisplayIdentificationData data;
Dominik Laskowski7e045462018-05-30 13:02:02 -07004043 if (!getHwComposer().getDisplayIdentificationData(*hwcDisplayId, &port, &data)) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004044 result.append("no identification data\n");
4045 continue;
4046 }
4047
4048 if (!isEdid(data)) {
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004049 result.append("unknown identification data\n");
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004050 continue;
4051 }
4052
4053 const auto edid = parseEdid(data);
4054 if (!edid) {
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004055 result.append("invalid EDID\n");
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004056 continue;
4057 }
4058
Yiwei Zhang5434a782018-12-05 18:06:32 -08004059 StringAppendF(&result, "port=%u pnpId=%s displayName=\"", port, edid->pnpId.data());
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004060 result.append(edid->displayName.data(), edid->displayName.length());
4061 result.append("\"\n");
4062 }
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004063}
4064
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004065void SurfaceFlinger::dumpRawDisplayIdentificationData(const DumpArgs& args,
4066 std::string& result) const {
4067 hwc2_display_t hwcDisplayId;
4068 uint8_t port;
4069 DisplayIdentificationData data;
4070
4071 if (args.size() > 1 && base::ParseUint(String8(args[1]), &hwcDisplayId) &&
4072 getHwComposer().getDisplayIdentificationData(hwcDisplayId, &port, &data)) {
4073 result.append(reinterpret_cast<const char*>(data.data()), data.size());
4074 }
4075}
4076
Yiwei Zhang5434a782018-12-05 18:06:32 -08004077void SurfaceFlinger::dumpWideColorInfo(std::string& result) const {
Peiyong Linff84a152019-05-17 18:36:19 -07004078 StringAppendF(&result, "Device has wide color built-in display: %d\n", hasWideColorDisplay);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004079 StringAppendF(&result, "Device uses color management: %d\n", useColorManagement);
4080 StringAppendF(&result, "DisplayColorSetting: %s\n",
4081 decodeDisplayColorSetting(mDisplayColorSetting).c_str());
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004082
4083 // TODO: print out if wide-color mode is active or not
4084
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004085 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004086 const auto displayId = display->getId();
4087 if (!displayId) {
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004088 continue;
4089 }
4090
Yiwei Zhang5434a782018-12-05 18:06:32 -08004091 StringAppendF(&result, "Display %s color modes:\n", to_string(*displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004092 std::vector<ColorMode> modes = getHwComposer().getColorModes(*displayId);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004093 for (auto&& mode : modes) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004094 StringAppendF(&result, " %s (%d)\n", decodeColorMode(mode).c_str(), mode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004095 }
4096
Lloyd Pique32cbe282018-10-19 13:09:22 -07004097 ColorMode currentMode = display->getCompositionDisplay()->getState().colorMode;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004098 StringAppendF(&result, " Current color mode: %s (%d)\n",
4099 decodeColorMode(currentMode).c_str(), currentMode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004100 }
4101 result.append("\n");
4102}
4103
Vishnu Nair8406fd72019-07-30 11:29:31 -07004104LayersProto SurfaceFlinger::dumpDrawingStateProto(uint32_t traceFlags) const {
chaviw1d044282017-09-27 12:19:28 -07004105 LayersProto layersProto;
Vishnu Nair8406fd72019-07-30 11:29:31 -07004106 mDrawingState.traverseInZOrder([&](Layer* layer) {
chaviw1d044282017-09-27 12:19:28 -07004107 LayerProto* layerProto = layersProto.add_layers();
Vishnu Nair8406fd72019-07-30 11:29:31 -07004108 layer->writeToProtoDrawingState(layerProto, traceFlags);
4109 layer->writeToProtoCommonState(layerProto, LayerVector::StateSet::Drawing, traceFlags);
chaviw1d044282017-09-27 12:19:28 -07004110 });
4111
4112 return layersProto;
4113}
4114
Vishnu Nair0f085c62019-08-30 08:49:12 -07004115void SurfaceFlinger::dumpOffscreenLayersProto(LayersProto& layersProto, uint32_t traceFlags) const {
4116 // Add a fake invisible root layer to the proto output and parent all the offscreen layers to
4117 // it.
4118 LayerProto* rootProto = layersProto.add_layers();
4119 const int32_t offscreenRootLayerId = INT32_MAX - 2;
4120 rootProto->set_id(offscreenRootLayerId);
4121 rootProto->set_name("Offscreen Root");
4122
4123 for (Layer* offscreenLayer : mOffscreenLayers) {
4124 // Add layer as child of the fake root
4125 rootProto->add_children(offscreenLayer->sequence);
4126
4127 // Add layer
4128 LayerProto* layerProto = layersProto.add_layers();
4129 offscreenLayer->writeToProtoDrawingState(layerProto, traceFlags);
4130 offscreenLayer->writeToProtoCommonState(layerProto, LayerVector::StateSet::Drawing,
4131 traceFlags);
4132 layerProto->set_parent(offscreenRootLayerId);
4133
4134 // Add children
4135 offscreenLayer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
4136 if (layer == offscreenLayer) {
4137 return;
4138 }
4139 LayerProto* childProto = layersProto.add_layers();
4140 layer->writeToProtoDrawingState(childProto, traceFlags);
4141 layer->writeToProtoCommonState(childProto, LayerVector::StateSet::Drawing, traceFlags);
4142 });
4143 }
4144}
4145
Vishnu Nair8406fd72019-07-30 11:29:31 -07004146LayersProto SurfaceFlinger::dumpProtoFromMainThread(uint32_t traceFlags) {
4147 LayersProto layersProto;
4148 postMessageSync(new LambdaMessage([&]() { layersProto = dumpDrawingStateProto(traceFlags); }));
4149 return layersProto;
4150}
4151
Vishnu Nair0f085c62019-08-30 08:49:12 -07004152void SurfaceFlinger::dumpOffscreenLayers(std::string& result) {
4153 result.append("Offscreen Layers:\n");
4154 postMessageSync(new LambdaMessage([&]() {
4155 for (Layer* offscreenLayer : mOffscreenLayers) {
4156 offscreenLayer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
4157 layer->dumpCallingUidPid(result);
4158 });
4159 }
4160 }));
4161}
4162
Dominik Laskowskic2867142019-01-21 11:33:38 -08004163void SurfaceFlinger::dumpAllLocked(const DumpArgs& args, std::string& result) const {
4164 const bool colorize = !args.empty() && args[0] == String16("--color");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004165 Colorizer colorizer(colorize);
4166
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004167 // figure out if we're stuck somewhere
4168 const nsecs_t now = systemTime();
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004169 const nsecs_t inTransaction(mDebugInTransaction);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004170 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
4171
4172 /*
Andy McFadden4803b742012-09-24 19:07:20 -07004173 * Dump library configuration.
4174 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004175
4176 colorizer.bold(result);
Andy McFadden4803b742012-09-24 19:07:20 -07004177 result.append("Build configuration:");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004178 colorizer.reset(result);
Andy McFadden4803b742012-09-24 19:07:20 -07004179 appendSfConfigString(result);
4180 appendUiConfigString(result);
4181 appendGuiConfigString(result);
4182 result.append("\n");
4183
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004184 result.append("\nDisplay identification data:\n");
4185 dumpDisplayIdentificationData(result);
4186
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004187 result.append("\nWide-Color information:\n");
4188 dumpWideColorInfo(result);
4189
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004190 colorizer.bold(result);
Mathias Agopianca088332013-03-28 17:44:13 -07004191 result.append("Sync configuration: ");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004192 colorizer.reset(result);
Mathias Agopianca088332013-03-28 17:44:13 -07004193 result.append(SyncFeatures::getInstance().toString());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004194 result.append("\n\n");
Mathias Agopianca088332013-03-28 17:44:13 -07004195
Andy McFadden41d67d72014-04-25 16:58:34 -07004196 colorizer.bold(result);
Dominik Laskowski98041832019-08-01 18:35:59 -07004197 result.append("Scheduler:\n");
Andy McFadden41d67d72014-04-25 16:58:34 -07004198 colorizer.reset(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004199 dumpVSync(result);
Dan Stozab90cf072015-03-05 11:05:59 -08004200 result.append("\n");
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004201
Dan Stozab90cf072015-03-05 11:05:59 -08004202 dumpStaticScreenStats(result);
4203 result.append("\n");
4204
Alec Mouri40189b02019-03-05 15:07:54 -08004205 StringAppendF(&result, "Total missed frame count: %u\n", mFrameMissedCount.load());
4206 StringAppendF(&result, "HWC missed frame count: %u\n", mHwcFrameMissedCount.load());
4207 StringAppendF(&result, "GPU missed frame count: %u\n\n", mGpuFrameMissedCount.load());
Marissa Wallcfcdaa52018-05-21 15:45:59 -07004208
Dan Stozae77c7662016-05-13 11:37:28 -07004209 dumpBufferingStats(result);
4210
Andy McFadden4803b742012-09-24 19:07:20 -07004211 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004212 * Dump the visible layer list
4213 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004214 colorizer.bold(result);
chaviweadf0d42019-08-12 13:28:29 -07004215 StringAppendF(&result, "Visible layers (count = %zu)\n", mNumLayers.load());
Yiwei Zhang5434a782018-12-05 18:06:32 -08004216 StringAppendF(&result, "GraphicBufferProducers: %zu, max %zu\n",
4217 mGraphicBufferProducerList.size(), mMaxGraphicBufferProducerListSize);
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004218 colorizer.reset(result);
chaviw1d044282017-09-27 12:19:28 -07004219
Chia-I Wu2f884132018-09-13 15:17:58 -07004220 {
Lloyd Pique207def92019-02-28 16:09:52 -08004221 StringAppendF(&result, "Composition layers\n");
4222 mDrawingState.traverseInZOrder([&](Layer* layer) {
4223 auto compositionLayer = layer->getCompositionLayer();
4224 if (compositionLayer) compositionLayer->dump(result);
4225 });
4226 }
4227
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004228 /*
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004229 * Dump Display state
4230 */
4231
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004232 colorizer.bold(result);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004233 StringAppendF(&result, "Displays (%zu entries)\n", mDisplays.size());
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004234 colorizer.reset(result);
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004235 for (const auto& [token, display] : mDisplays) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004236 display->dump(result);
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004237 }
Chia-I Wu1e043612018-03-01 09:45:09 -08004238 result.append("\n");
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004239
4240 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004241 * Dump SurfaceFlinger global state
4242 */
4243
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004244 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02004245 result.append("SurfaceFlinger global state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004246 colorizer.reset(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004247
Lloyd Piqueb97e04f2018-10-18 17:07:05 -07004248 getRenderEngine().dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004249
Ady Abrahama3b08ef2019-07-15 18:43:10 -07004250 DebugEGLImageTracker::getInstance()->dump(result);
4251
Dominik Laskowski075d3172018-05-24 15:50:06 -07004252 if (const auto display = getDefaultDisplayDeviceLocked()) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07004253 display->getCompositionDisplay()->getState().undefinedRegion.dump(result,
4254 "undefinedRegion");
Yiwei Zhang5434a782018-12-05 18:06:32 -08004255 StringAppendF(&result, " orientation=%d, isPoweredOn=%d\n", display->getOrientation(),
4256 display->isPoweredOn());
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08004257 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08004258 StringAppendF(&result,
4259 " transaction-flags : %08x\n"
4260 " gpu_to_cpu_unsupported : %d\n",
4261 mTransactionFlags.load(), !mGpuToCpuSupported);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004262
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08004263 if (const auto displayId = getInternalDisplayIdLocked();
Dominik Laskowski075d3172018-05-24 15:50:06 -07004264 displayId && getHwComposer().isConnected(*displayId)) {
4265 const auto activeConfig = getHwComposer().getActiveConfig(*displayId);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004266 StringAppendF(&result,
4267 " refresh-rate : %f fps\n"
4268 " x-dpi : %f\n"
4269 " y-dpi : %f\n",
4270 1e9 / activeConfig->getVsyncPeriod(), activeConfig->getDpiX(),
4271 activeConfig->getDpiY());
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004272 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004273
Yiwei Zhang5434a782018-12-05 18:06:32 -08004274 StringAppendF(&result, " transaction time: %f us\n", inTransactionDuration / 1000.0);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004275
Dan Stozae22aec72016-08-01 13:20:59 -07004276 /*
Yichi Chenadc69612018-09-15 14:51:18 +08004277 * Tracing state
4278 */
4279 mTracing.dump(result);
4280 result.append("\n");
4281
4282 /*
Dan Stozae22aec72016-08-01 13:20:59 -07004283 * HWC layer minidump
4284 */
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004285 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004286 const auto displayId = display->getId();
4287 if (!displayId) {
Dan Stozae22aec72016-08-01 13:20:59 -07004288 continue;
4289 }
4290
Yiwei Zhang5434a782018-12-05 18:06:32 -08004291 StringAppendF(&result, "Display %s HWC layers:\n", to_string(*displayId).c_str());
Dan Stozae22aec72016-08-01 13:20:59 -07004292 Layer::miniDumpHeader(result);
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004293 const sp<DisplayDevice> displayDevice = display;
4294 mCurrentState.traverseInZOrder(
4295 [&](Layer* layer) { layer->miniDump(result, displayDevice); });
Dan Stozae22aec72016-08-01 13:20:59 -07004296 result.append("\n");
4297 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004298
4299 /*
4300 * Dump HWComposer state
4301 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004302 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02004303 result.append("h/w composer state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004304 colorizer.reset(result);
Dan Stoza9f26a9c2016-06-22 14:51:09 -07004305 bool hwcDisabled = mDebugDisableHWC || mDebugRegion;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004306 StringAppendF(&result, " h/w composer %s\n", hwcDisabled ? "disabled" : "enabled");
Dominik Laskowski075d3172018-05-24 15:50:06 -07004307 getHwComposer().dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004308
4309 /*
4310 * Dump gralloc state
4311 */
4312 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
4313 alloc.dump(result);
Karthik Ravi Shankar171155a2017-06-28 15:40:24 -07004314
4315 /*
4316 * Dump VrFlinger state if in use.
4317 */
4318 if (mVrFlingerRequestsDisplay && mVrFlinger) {
4319 result.append("VrFlinger state:\n");
Yiwei Zhang5434a782018-12-05 18:06:32 -08004320 result.append(mVrFlinger->Dump());
Karthik Ravi Shankar171155a2017-06-28 15:40:24 -07004321 result.append("\n");
4322 }
Ana Krulecb43429d2019-01-09 14:28:51 -08004323
Yiwei Zhang7eb58b72019-04-22 19:00:02 -07004324 result.append(mTimeStats->miniDump());
4325 result.append("\n");
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004326}
4327
Chia-I Wu28f320b2018-05-03 11:02:56 -07004328void SurfaceFlinger::updateColorMatrixLocked() {
4329 mat4 colorMatrix;
4330 if (mGlobalSaturationFactor != 1.0f) {
4331 // Rec.709 luma coefficients
4332 float3 luminance{0.213f, 0.715f, 0.072f};
4333 luminance *= 1.0f - mGlobalSaturationFactor;
4334 mat4 saturationMatrix = mat4(
4335 vec4{luminance.r + mGlobalSaturationFactor, luminance.r, luminance.r, 0.0f},
4336 vec4{luminance.g, luminance.g + mGlobalSaturationFactor, luminance.g, 0.0f},
4337 vec4{luminance.b, luminance.b, luminance.b + mGlobalSaturationFactor, 0.0f},
4338 vec4{0.0f, 0.0f, 0.0f, 1.0f}
4339 );
4340 colorMatrix = mClientColorMatrix * saturationMatrix * mDaltonizer();
4341 } else {
4342 colorMatrix = mClientColorMatrix * mDaltonizer();
4343 }
4344
4345 if (mCurrentState.colorMatrix != colorMatrix) {
4346 mCurrentState.colorMatrix = colorMatrix;
4347 mCurrentState.colorMatrixChanged = true;
4348 setTransactionFlags(eTransactionNeeded);
4349 }
4350}
4351
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07004352status_t SurfaceFlinger::CheckTransactCodeCredentials(uint32_t code) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004353#pragma clang diagnostic push
4354#pragma clang diagnostic error "-Wswitch-enum"
4355 switch (static_cast<ISurfaceComposerTag>(code)) {
4356 // These methods should at minimum make sure that the client requested
4357 // access to SF.
Dan Stozae3344402018-08-20 19:53:42 +00004358 case BOOT_FINISHED:
4359 case CLEAR_ANIMATION_FRAME_STATS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004360 case CREATE_DISPLAY:
4361 case DESTROY_DISPLAY:
Dan Stozae3344402018-08-20 19:53:42 +00004362 case ENABLE_VSYNC_INJECTIONS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004363 case GET_ANIMATION_FRAME_STATS:
4364 case GET_HDR_CAPABILITIES:
4365 case SET_ACTIVE_CONFIG:
Ady Abraham838de062019-02-04 10:24:03 -08004366 case SET_ALLOWED_DISPLAY_CONFIGS:
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08004367 case GET_ALLOWED_DISPLAY_CONFIGS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004368 case SET_ACTIVE_COLOR_MODE:
Chia-I Wu90f669f2017-10-05 14:24:41 -07004369 case INJECT_VSYNC:
Kevin DuBois9c0a1762018-10-16 13:32:31 -07004370 case SET_POWER_MODE:
Kevin DuBois74e53772018-11-19 10:52:38 -08004371 case GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES:
Kevin DuBois1d4249a2018-08-29 10:45:14 -07004372 case SET_DISPLAY_CONTENT_SAMPLING_ENABLED:
Ady Abraham8532d012019-05-08 14:50:56 -07004373 case GET_DISPLAYED_CONTENT_SAMPLE:
4374 case NOTIFY_POWER_HINT: {
Robert Carrd4ae7f32018-06-07 16:10:57 -07004375 if (!callingThreadHasUnscopedSurfaceFlingerAccess()) {
4376 IPCThreadState* ipc = IPCThreadState::self();
4377 ALOGE("Permission Denial: can't access SurfaceFlinger pid=%d, uid=%d",
4378 ipc->getCallingPid(), ipc->getCallingUid());
Mathias Agopian375f5632009-06-15 18:24:59 -07004379 return PERMISSION_DENIED;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004380 }
Robert Carr1db73f62016-12-21 12:58:51 -08004381 return OK;
4382 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004383 case GET_LAYER_DEBUG_INFO: {
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07004384 IPCThreadState* ipc = IPCThreadState::self();
4385 const int pid = ipc->getCallingPid();
4386 const int uid = ipc->getCallingUid();
Ana Krulec13be8ad2018-08-21 02:43:56 +00004387 if ((uid != AID_SHELL) && !PermissionCache::checkPermission(sDump, pid, uid)) {
4388 ALOGE("Layer debug info permission denied for pid=%d, uid=%d", pid, uid);
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07004389 return PERMISSION_DENIED;
4390 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004391 return OK;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004392 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004393 // Used by apps to hook Choreographer to SurfaceFlinger.
4394 case CREATE_DISPLAY_EVENT_CONNECTION:
4395 // The following calls are currently used by clients that do not
4396 // request necessary permissions. However, they do not expose any secret
4397 // information, so it is OK to pass them.
4398 case AUTHENTICATE_SURFACE:
Peiyong Lind1fedb42019-03-11 17:48:41 -07004399 case GET_ACTIVE_COLOR_MODE:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004400 case GET_ACTIVE_CONFIG:
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08004401 case GET_PHYSICAL_DISPLAY_IDS:
4402 case GET_PHYSICAL_DISPLAY_TOKEN:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004403 case GET_DISPLAY_COLOR_MODES:
Daniel Solomon42d04562019-01-20 21:03:19 -08004404 case GET_DISPLAY_NATIVE_PRIMARIES:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004405 case GET_DISPLAY_CONFIGS:
4406 case GET_DISPLAY_STATS:
4407 case GET_SUPPORTED_FRAME_TIMESTAMPS:
4408 // Calling setTransactionState is safe, because you need to have been
4409 // granted a reference to Client* and Handle* to do anything with it.
4410 case SET_TRANSACTION_STATE:
Robert Carrb89ea9d2018-12-10 13:01:14 -08004411 case CREATE_CONNECTION:
Ady Abraham37965d42018-11-01 13:43:32 -07004412 case GET_COLOR_MANAGEMENT:
Peiyong Lin3c2791e2019-01-14 17:05:18 -08004413 case GET_COMPOSITION_PREFERENCE:
Marissa Wallebc2c052019-01-16 19:16:55 -08004414 case GET_PROTECTED_CONTENT_SUPPORT:
Dan Gittik57e63c52019-01-18 16:37:54 +00004415 case IS_WIDE_COLOR_DISPLAY:
4416 case GET_DISPLAY_BRIGHTNESS_SUPPORT:
4417 case SET_DISPLAY_BRIGHTNESS: {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004418 return OK;
4419 }
Chong Zhangda6c1592019-07-16 13:45:06 -07004420 case CAPTURE_LAYERS: {
4421 IPCThreadState* ipc = IPCThreadState::self();
4422 const int pid = ipc->getCallingPid();
4423 const int uid = ipc->getCallingUid();
4424 // allow media to capture layer for video thumbnails
4425 if ((uid != AID_GRAPHICS && uid != AID_MEDIA) &&
4426 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
4427 ALOGE("Permission Denial: can't capture layer pid=%d, uid=%d", pid, uid);
4428 return PERMISSION_DENIED;
4429 }
4430 return OK;
4431 }
Dan Stoza84ab9372018-12-17 15:27:57 -08004432 case CAPTURE_SCREEN:
4433 case ADD_REGION_SAMPLING_LISTENER:
4434 case REMOVE_REGION_SAMPLING_LISTENER: {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004435 // codes that require permission check
chaviwa76b2712017-09-20 12:02:26 -07004436 IPCThreadState* ipc = IPCThreadState::self();
4437 const int pid = ipc->getCallingPid();
4438 const int uid = ipc->getCallingUid();
4439 if ((uid != AID_GRAPHICS) &&
4440 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
4441 ALOGE("Permission Denial: can't read framebuffer pid=%d, uid=%d", pid, uid);
4442 return PERMISSION_DENIED;
4443 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004444 return OK;
4445 }
4446 // The following codes are deprecated and should never be allowed to access SF.
4447 case CONNECT_DISPLAY_UNUSED:
4448 case CREATE_GRAPHIC_BUFFER_ALLOC_UNUSED: {
4449 ALOGE("Attempting to access SurfaceFlinger with unused code: %u", code);
4450 return PERMISSION_DENIED;
chaviwa76b2712017-09-20 12:02:26 -07004451 }
chaviw93df2ea2019-04-30 16:45:12 -07004452 case CAPTURE_SCREEN_BY_ID: {
4453 IPCThreadState* ipc = IPCThreadState::self();
4454 const int uid = ipc->getCallingUid();
Peiyong Lin96cfebc2019-05-15 11:36:13 -07004455 if (uid == AID_ROOT || uid == AID_GRAPHICS || uid == AID_SYSTEM || uid == AID_SHELL) {
chaviw93df2ea2019-04-30 16:45:12 -07004456 return OK;
4457 }
4458 return PERMISSION_DENIED;
4459 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004460 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004461
4462 // These codes are used for the IBinder protocol to either interrogate the recipient
4463 // side of the transaction for its canonical interface descriptor or to dump its state.
4464 // We let them pass by default.
4465 if (code == IBinder::INTERFACE_TRANSACTION || code == IBinder::DUMP_TRANSACTION ||
4466 code == IBinder::PING_TRANSACTION || code == IBinder::SHELL_COMMAND_TRANSACTION ||
4467 code == IBinder::SYSPROPS_TRANSACTION) {
4468 return OK;
4469 }
Ady Abraham03b02dd2019-03-21 15:40:11 -07004470 // Numbers from 1000 to 1034 are currently used for backdoors. The code
Ana Krulec13be8ad2018-08-21 02:43:56 +00004471 // in onTransact verifies that the user is root, and has access to use SF.
Ady Abraham34392f72019-04-10 11:29:27 -07004472 if (code >= 1000 && code <= 1035) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004473 ALOGV("Accessing SurfaceFlinger through backdoor code: %u", code);
4474 return OK;
4475 }
4476 ALOGE("Permission Denial: SurfaceFlinger did not recognize request code: %u", code);
4477 return PERMISSION_DENIED;
4478#pragma clang diagnostic pop
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07004479}
4480
Ana Krulec13be8ad2018-08-21 02:43:56 +00004481status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
4482 uint32_t flags) {
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07004483 status_t credentialCheck = CheckTransactCodeCredentials(code);
4484 if (credentialCheck != OK) {
4485 return credentialCheck;
4486 }
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07004487
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004488 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
4489 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
Mathias Agopianb8a55602009-06-26 19:06:36 -07004490 CHECK_INTERFACE(ISurfaceComposer, data, reply);
Romain Guy8c6bbd62017-06-05 13:51:43 -07004491 IPCThreadState* ipc = IPCThreadState::self();
4492 const int uid = ipc->getCallingUid();
4493 if (CC_UNLIKELY(uid != AID_SYSTEM
4494 && !PermissionCache::checkCallingPermission(sHardwareTest))) {
Mathias Agopian375f5632009-06-15 18:24:59 -07004495 const int pid = ipc->getCallingPid();
Steve Blocke6f43dd2012-01-06 19:20:56 +00004496 ALOGE("Permission Denial: "
Mathias Agopian375f5632009-06-15 18:24:59 -07004497 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004498 return PERMISSION_DENIED;
4499 }
4500 int n;
4501 switch (code) {
Mathias Agopian01b76682009-04-16 20:04:08 -07004502 case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
Mathias Agopian35b48d12010-09-13 22:57:58 -07004503 case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004504 return NO_ERROR;
4505 case 1002: // SHOW_UPDATES
4506 n = data.readInt32();
4507 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
Mathias Agopian53331da2011-08-22 21:44:41 -07004508 invalidateHwcGeometry();
4509 repaintEverything();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004510 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004511 case 1004:{ // repaint everything
Mathias Agopian53331da2011-08-22 21:44:41 -07004512 repaintEverything();
Mathias Agopiancbb288b2009-09-07 16:32:45 -07004513 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004514 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -07004515 case 1005:{ // force transaction
Steven Thomas6d8110b2017-08-31 18:24:21 -07004516 Mutex::Autolock _l(mStateLock);
Mathias Agopiane57f2922012-08-09 16:29:12 -07004517 setTransactionFlags(
4518 eTransactionNeeded|
4519 eDisplayTransactionNeeded|
4520 eTraversalNeeded);
Mathias Agopiancbb288b2009-09-07 16:32:45 -07004521 return NO_ERROR;
4522 }
Mathias Agopian4d143ee2012-02-23 20:05:39 -08004523 case 1006:{ // send empty update
4524 signalRefresh();
4525 return NO_ERROR;
4526 }
Mathias Agopian53331da2011-08-22 21:44:41 -07004527 case 1008: // toggle use of hw composer
4528 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07004529 mDebugDisableHWC = n != 0;
Mathias Agopian53331da2011-08-22 21:44:41 -07004530 invalidateHwcGeometry();
4531 repaintEverything();
4532 return NO_ERROR;
Mathias Agopiana4583642011-08-23 18:03:18 -07004533 case 1009: // toggle use of transform hint
4534 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07004535 mDebugDisableTransformHint = n != 0;
Mathias Agopiana4583642011-08-23 18:03:18 -07004536 invalidateHwcGeometry();
4537 repaintEverything();
4538 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004539 case 1010: // interrogate.
Mathias Agopian01b76682009-04-16 20:04:08 -07004540 reply->writeInt32(0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004541 reply->writeInt32(0);
4542 reply->writeInt32(mDebugRegion);
Mathias Agopianb9494d52012-04-18 02:28:45 -07004543 reply->writeInt32(0);
Dianne Hackborn12839be2012-02-06 21:21:05 -08004544 reply->writeInt32(mDebugDisableHWC);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004545 return NO_ERROR;
4546 case 1013: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004547 const auto display = getDefaultDisplayDevice();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004548 if (!display) {
4549 return NAME_NOT_FOUND;
4550 }
4551
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004552 reply->writeInt32(display->getPageFlipCount());
Mathias Agopianff2ed702013-09-01 21:36:12 -07004553 return NO_ERROR;
4554 }
4555 case 1014: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07004556 Mutex::Autolock _l(mStateLock);
Mathias Agopianff2ed702013-09-01 21:36:12 -07004557 // daltonize
4558 n = data.readInt32();
4559 switch (n % 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07004560 case 1:
4561 mDaltonizer.setType(ColorBlindnessType::Protanomaly);
4562 break;
4563 case 2:
4564 mDaltonizer.setType(ColorBlindnessType::Deuteranomaly);
4565 break;
4566 case 3:
4567 mDaltonizer.setType(ColorBlindnessType::Tritanomaly);
4568 break;
4569 default:
4570 mDaltonizer.setType(ColorBlindnessType::None);
4571 break;
Mathias Agopianff2ed702013-09-01 21:36:12 -07004572 }
4573 if (n >= 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07004574 mDaltonizer.setMode(ColorBlindnessMode::Correction);
Mathias Agopianff2ed702013-09-01 21:36:12 -07004575 } else {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07004576 mDaltonizer.setMode(ColorBlindnessMode::Simulation);
Mathias Agopianff2ed702013-09-01 21:36:12 -07004577 }
Chia-I Wu28f320b2018-05-03 11:02:56 -07004578
4579 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07004580 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004581 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07004582 case 1015: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07004583 Mutex::Autolock _l(mStateLock);
Alan Viverette9c5a3332013-09-12 20:04:35 -07004584 // apply a color matrix
4585 n = data.readInt32();
Alan Viverette9c5a3332013-09-12 20:04:35 -07004586 if (n) {
Romain Guy0147a172017-06-01 13:53:56 -07004587 // color matrix is sent as a column-major mat4 matrix
Alan Viverette794c5ba2013-10-03 16:40:52 -07004588 for (size_t i = 0 ; i < 4; i++) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07004589 for (size_t j = 0; j < 4; j++) {
Chia-I Wu28f320b2018-05-03 11:02:56 -07004590 mClientColorMatrix[i][j] = data.readFloat();
Dan Stoza9f26a9c2016-06-22 14:51:09 -07004591 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07004592 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07004593 } else {
Chia-I Wu28f320b2018-05-03 11:02:56 -07004594 mClientColorMatrix = mat4();
Alan Viverette9c5a3332013-09-12 20:04:35 -07004595 }
Romain Guy88d37dd2017-05-26 17:57:05 -07004596
4597 // Check that supplied matrix's last row is {0,0,0,1} so we can avoid
4598 // the division by w in the fragment shader
Chia-I Wu28f320b2018-05-03 11:02:56 -07004599 float4 lastRow(transpose(mClientColorMatrix)[3]);
Romain Guy88d37dd2017-05-26 17:57:05 -07004600 if (any(greaterThan(abs(lastRow - float4{0, 0, 0, 1}), float4{1e-4f}))) {
4601 ALOGE("The color transform's last row must be (0, 0, 0, 1)");
4602 }
4603
Chia-I Wu28f320b2018-05-03 11:02:56 -07004604 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07004605 return NO_ERROR;
4606 }
Dominik Laskowski8d32ddc2019-08-07 11:25:35 -07004607 case 1016: { // Unused.
4608 return NAME_NOT_FOUND;
Ruchi Kandoif52b3c82014-04-24 16:42:35 -07004609 }
Dan Stozaee44edd2015-03-23 15:50:23 -07004610 case 1017: {
4611 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07004612 mForceFullDamage = n != 0;
Dan Stozaee44edd2015-03-23 15:50:23 -07004613 return NO_ERROR;
4614 }
Dan Stozadb4ac3c2015-04-14 11:34:01 -07004615 case 1018: { // Modify Choreographer's phase offset
4616 n = data.readInt32();
Ana Krulecc2870422019-01-29 19:00:58 -08004617 mScheduler->setPhaseOffset(mAppConnectionHandle, static_cast<nsecs_t>(n));
Dan Stozadb4ac3c2015-04-14 11:34:01 -07004618 return NO_ERROR;
4619 }
4620 case 1019: { // Modify SurfaceFlinger's phase offset
4621 n = data.readInt32();
Ana Krulecc2870422019-01-29 19:00:58 -08004622 mScheduler->setPhaseOffset(mSfConnectionHandle, static_cast<nsecs_t>(n));
Dan Stozadb4ac3c2015-04-14 11:34:01 -07004623 return NO_ERROR;
4624 }
Irvel468051e2016-06-13 16:44:44 -07004625 case 1020: { // Layer updates interceptor
4626 n = data.readInt32();
4627 if (n) {
4628 ALOGV("Interceptor enabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08004629 mInterceptor->enable(mDrawingState.layersSortedByZ, mDrawingState.displays);
Irvel468051e2016-06-13 16:44:44 -07004630 }
4631 else{
4632 ALOGV("Interceptor disabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08004633 mInterceptor->disable();
Irvel468051e2016-06-13 16:44:44 -07004634 }
4635 return NO_ERROR;
4636 }
Dan Stoza8cf150a2016-08-02 10:27:31 -07004637 case 1021: { // Disable HWC virtual displays
4638 n = data.readInt32();
4639 mUseHwcVirtualDisplays = !n;
4640 return NO_ERROR;
4641 }
Romain Guy0147a172017-06-01 13:53:56 -07004642 case 1022: { // Set saturation boost
Chia-I Wu28f320b2018-05-03 11:02:56 -07004643 Mutex::Autolock _l(mStateLock);
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08004644 mGlobalSaturationFactor = std::max(0.0f, std::min(data.readFloat(), 2.0f));
Romain Guy0147a172017-06-01 13:53:56 -07004645
Chia-I Wu28f320b2018-05-03 11:02:56 -07004646 updateColorMatrixLocked();
Romain Guy0147a172017-06-01 13:53:56 -07004647 return NO_ERROR;
4648 }
Romain Guy54f154a2017-10-24 21:40:32 +01004649 case 1023: { // Set native mode
Daniel Solomon7c7ede22019-07-11 16:35:40 -07004650 int32_t colorMode;
4651
Chia-I Wu0d711262018-05-21 15:19:35 -07004652 mDisplayColorSetting = static_cast<DisplayColorSetting>(data.readInt32());
Daniel Solomon7c7ede22019-07-11 16:35:40 -07004653 if (data.readInt32(&colorMode) == NO_ERROR) {
4654 mForceColorMode = static_cast<ColorMode>(colorMode);
4655 }
Romain Guy54f154a2017-10-24 21:40:32 +01004656 invalidateHwcGeometry();
4657 repaintEverything();
4658 return NO_ERROR;
4659 }
Peiyong Lin4bac91c2018-10-25 09:48:33 -07004660 // Deprecate, use 1030 to check whether the device is color managed.
4661 case 1024: {
4662 return NAME_NOT_FOUND;
Romain Guy54f154a2017-10-24 21:40:32 +01004663 }
Vishnu Nair87704c92018-01-08 15:32:57 -08004664 case 1025: { // Set layer tracing
Adrian Roos1e1a1282017-11-01 19:05:31 +01004665 n = data.readInt32();
4666 if (n) {
Yichi Chenadc69612018-09-15 14:51:18 +08004667 ALOGD("LayerTracing enabled");
Nataniel Borges2b796da2019-02-15 13:32:18 -08004668 Mutex::Autolock lock(mStateLock);
4669 mTracingEnabledChanged = true;
Adrian Roos1e1a1282017-11-01 19:05:31 +01004670 mTracing.enable();
Adrian Roos1e1a1282017-11-01 19:05:31 +01004671 reply->writeInt32(NO_ERROR);
4672 } else {
Yichi Chenadc69612018-09-15 14:51:18 +08004673 ALOGD("LayerTracing disabled");
Nataniel Borges2b796da2019-02-15 13:32:18 -08004674 bool writeFile = false;
4675 {
4676 Mutex::Autolock lock(mStateLock);
4677 mTracingEnabledChanged = true;
4678 writeFile = mTracing.disable();
4679 }
4680
4681 if (writeFile) {
4682 reply->writeInt32(mTracing.writeToFile());
4683 } else {
4684 reply->writeInt32(NO_ERROR);
4685 }
Adrian Roos1e1a1282017-11-01 19:05:31 +01004686 }
4687 return NO_ERROR;
4688 }
Vishnu Nair87704c92018-01-08 15:32:57 -08004689 case 1026: { // Get layer tracing status
4690 reply->writeBool(mTracing.isEnabled());
4691 return NO_ERROR;
4692 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08004693 // Is a DisplayColorSetting supported?
4694 case 1027: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004695 const auto display = getDefaultDisplayDevice();
4696 if (!display) {
Chia-I Wu0d711262018-05-21 15:19:35 -07004697 return NAME_NOT_FOUND;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08004698 }
Chia-I Wu0d711262018-05-21 15:19:35 -07004699
4700 DisplayColorSetting setting = static_cast<DisplayColorSetting>(data.readInt32());
4701 switch (setting) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -08004702 case DisplayColorSetting::kManaged:
Peiyong Lin13effd12018-07-24 17:01:47 -07004703 reply->writeBool(useColorManagement);
Chia-I Wu0d711262018-05-21 15:19:35 -07004704 break;
Lloyd Pique6a3b4462019-03-07 20:58:12 -08004705 case DisplayColorSetting::kUnmanaged:
Chia-I Wu0d711262018-05-21 15:19:35 -07004706 reply->writeBool(true);
4707 break;
Lloyd Pique6a3b4462019-03-07 20:58:12 -08004708 case DisplayColorSetting::kEnhanced:
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004709 reply->writeBool(display->hasRenderIntent(RenderIntent::ENHANCE));
Chia-I Wu0d711262018-05-21 15:19:35 -07004710 break;
4711 default: // vendor display color setting
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004712 reply->writeBool(
4713 display->hasRenderIntent(static_cast<RenderIntent>(setting)));
Chia-I Wu0d711262018-05-21 15:19:35 -07004714 break;
4715 }
4716 return NO_ERROR;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08004717 }
Steven Thomas97f1f4c2018-06-01 12:04:16 -07004718 // Is VrFlinger active?
4719 case 1028: {
4720 Mutex::Autolock _l(mStateLock);
Lloyd Pique441d5042018-10-18 16:49:51 -07004721 reply->writeBool(getHwComposer().isUsingVrComposer());
Steven Thomas97f1f4c2018-06-01 12:04:16 -07004722 return NO_ERROR;
4723 }
Nataniel Borges2b796da2019-02-15 13:32:18 -08004724 // Set buffer size for SF tracing (value in KB)
4725 case 1029: {
4726 n = data.readInt32();
4727 if (n <= 0 || n > MAX_TRACING_MEMORY) {
4728 ALOGW("Invalid buffer size: %d KB", n);
4729 reply->writeInt32(BAD_VALUE);
4730 return BAD_VALUE;
4731 }
4732
4733 ALOGD("Updating trace buffer to %d KB", n);
4734 mTracing.setBufferSize(n * 1024);
4735 reply->writeInt32(NO_ERROR);
4736 return NO_ERROR;
4737 }
Peiyong Lin13effd12018-07-24 17:01:47 -07004738 // Is device color managed?
4739 case 1030: {
4740 reply->writeBool(useColorManagement);
4741 return NO_ERROR;
4742 }
Peiyong Lin9d846a52018-11-05 13:18:20 -08004743 // Override default composition data space
4744 // adb shell service call SurfaceFlinger 1031 i32 1 DATASPACE_NUMBER DATASPACE_NUMBER \
4745 // && adb shell stop zygote && adb shell start zygote
4746 // to restore: adb shell service call SurfaceFlinger 1031 i32 0 && \
4747 // adb shell stop zygote && adb shell start zygote
4748 case 1031: {
4749 Mutex::Autolock _l(mStateLock);
4750 n = data.readInt32();
4751 if (n) {
4752 n = data.readInt32();
4753 if (n) {
4754 Dataspace dataspace = static_cast<Dataspace>(n);
4755 if (!validateCompositionDataspace(dataspace)) {
4756 return BAD_VALUE;
4757 }
4758 mDefaultCompositionDataspace = dataspace;
4759 }
4760 n = data.readInt32();
4761 if (n) {
4762 Dataspace dataspace = static_cast<Dataspace>(n);
4763 if (!validateCompositionDataspace(dataspace)) {
4764 return BAD_VALUE;
4765 }
4766 mWideColorGamutCompositionDataspace = dataspace;
4767 }
4768 } else {
4769 // restore composition data space.
4770 mDefaultCompositionDataspace = defaultCompositionDataspace;
4771 mWideColorGamutCompositionDataspace = wideColorGamutCompositionDataspace;
4772 }
4773 return NO_ERROR;
4774 }
Vishnu Nair9245d3b2019-03-22 13:38:56 -07004775 // Set trace flags
4776 case 1033: {
4777 n = data.readUint32();
4778 ALOGD("Updating trace flags to 0x%x", n);
4779 mTracing.setTraceFlags(n);
4780 reply->writeInt32(NO_ERROR);
4781 return NO_ERROR;
4782 }
Ady Abraham03b02dd2019-03-21 15:40:11 -07004783 case 1034: {
4784 // TODO(b/129297325): expose this via developer menu option
4785 n = data.readInt32();
Steven Thomas2bbaabe2019-08-28 16:08:35 -07004786 if (n && !mRefreshRateOverlay &&
4787 mRefreshRateConfigs->refreshRateSwitchingSupported()) {
Ady Abrahamfed164b2019-05-10 17:12:54 -07004788 RefreshRateType type;
4789 {
4790 std::lock_guard<std::mutex> lock(mActiveConfigLock);
4791 type = mDesiredActiveConfig.type;
4792 }
Ady Abraham03b02dd2019-03-21 15:40:11 -07004793 mRefreshRateOverlay = std::make_unique<RefreshRateOverlay>(*this);
Ady Abrahamfed164b2019-05-10 17:12:54 -07004794 mRefreshRateOverlay->changeRefreshRate(type);
Ady Abraham03b02dd2019-03-21 15:40:11 -07004795 } else if (!n) {
4796 mRefreshRateOverlay.reset();
4797 }
4798 return NO_ERROR;
4799 }
Ady Abraham34392f72019-04-10 11:29:27 -07004800 case 1035: {
4801 n = data.readInt32();
4802 mDebugDisplayConfigSetByBackdoor = false;
4803 if (n >= 0) {
4804 const auto displayToken = getInternalDisplayToken();
4805 status_t result = setAllowedDisplayConfigs(displayToken, {n});
4806 if (result != NO_ERROR) {
4807 return result;
4808 }
4809 mDebugDisplayConfigSetByBackdoor = true;
4810 }
4811 return NO_ERROR;
4812 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004813 }
4814 }
4815 return err;
4816}
4817
Steven Thomas6d8110b2017-08-31 18:24:21 -07004818void SurfaceFlinger::repaintEverything() {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07004819 mRepaintEverything = true;
Dan Stozac7a25ad2018-04-12 11:45:09 -07004820 signalTransaction();
Steven Thomas6d8110b2017-08-31 18:24:21 -07004821}
4822
Ana Krulec7d1d6832018-12-27 11:10:09 -08004823void SurfaceFlinger::repaintEverythingForHWC() {
4824 mRepaintEverything = true;
Ady Abraham8532d012019-05-08 14:50:56 -07004825 mEventQueue->invalidate();
Ana Krulec7d1d6832018-12-27 11:10:09 -08004826}
4827
Dan Stoza2b6d38e2017-06-01 16:40:30 -07004828// A simple RAII class to disconnect from an ANativeWindow* when it goes out of scope
4829class WindowDisconnector {
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07004830public:
Dan Stoza2b6d38e2017-06-01 16:40:30 -07004831 WindowDisconnector(ANativeWindow* window, int api) : mWindow(window), mApi(api) {}
4832 ~WindowDisconnector() {
4833 native_window_api_disconnect(mWindow, mApi);
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07004834 }
4835
Dan Stoza2b6d38e2017-06-01 16:40:30 -07004836private:
4837 ANativeWindow* mWindow;
4838 const int mApi;
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07004839};
4840
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004841status_t SurfaceFlinger::captureScreen(const sp<IBinder>& displayToken,
Robert Carr108b2c72019-04-02 16:32:58 -07004842 sp<GraphicBuffer>* outBuffer, bool& outCapturedSecureLayers,
4843 const Dataspace reqDataspace,
Peiyong Lin0e003c92018-09-17 11:09:51 -07004844 const ui::PixelFormat reqPixelFormat, Rect sourceCrop,
chaviw0e3479f2018-09-10 16:49:30 -07004845 uint32_t reqWidth, uint32_t reqHeight,
4846 bool useIdentityTransform,
Robert Carrfa8855f2019-02-19 10:05:00 -08004847 ISurfaceComposer::Rotation rotation,
4848 bool captureSecureLayers) {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07004849 ATRACE_CALL();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08004850
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004851 if (!displayToken) return BAD_VALUE;
chaviwa76b2712017-09-20 12:02:26 -07004852
Chia-I Wuc80dcbb2018-08-24 15:34:02 -07004853 auto renderAreaRotation = fromSurfaceComposerRotation(rotation);
4854
Chia-I Wu20261cb2018-08-23 12:55:44 -07004855 sp<DisplayDevice> display;
4856 {
4857 Mutex::Autolock _l(mStateLock);
Garfield Tan3b1b8af2018-03-16 17:37:33 -07004858
Chia-I Wu20261cb2018-08-23 12:55:44 -07004859 display = getDisplayDeviceLocked(displayToken);
4860 if (!display) return BAD_VALUE;
4861
Chia-I Wucb023152018-08-28 12:57:23 -07004862 // set the requested width/height to the logical display viewport size
4863 // by default
4864 if (reqWidth == 0 || reqHeight == 0) {
4865 reqWidth = uint32_t(display->getViewport().width());
4866 reqHeight = uint32_t(display->getViewport().height());
Chia-I Wu20261cb2018-08-23 12:55:44 -07004867 }
Yiwei Zhang06a58e22018-08-20 16:42:23 -07004868 }
4869
Peiyong Lin0e003c92018-09-17 11:09:51 -07004870 DisplayRenderArea renderArea(display, sourceCrop, reqWidth, reqHeight, reqDataspace,
Robert Carrfa8855f2019-02-19 10:05:00 -08004871 renderAreaRotation, captureSecureLayers);
chaviwa76b2712017-09-20 12:02:26 -07004872
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08004873 auto traverseLayers = std::bind(&SurfaceFlinger::traverseLayersInDisplay, this, display,
4874 std::placeholders::_1);
Peiyong Lin0e003c92018-09-17 11:09:51 -07004875 return captureScreenCommon(renderArea, traverseLayers, outBuffer, reqPixelFormat,
Robert Carr108b2c72019-04-02 16:32:58 -07004876 useIdentityTransform, outCapturedSecureLayers);
chaviwa76b2712017-09-20 12:02:26 -07004877}
4878
chaviw93df2ea2019-04-30 16:45:12 -07004879static Dataspace pickDataspaceFromColorMode(const ColorMode colorMode) {
4880 switch (colorMode) {
4881 case ColorMode::DISPLAY_P3:
4882 case ColorMode::BT2100_PQ:
4883 case ColorMode::BT2100_HLG:
4884 case ColorMode::DISPLAY_BT2020:
4885 return Dataspace::DISPLAY_P3;
4886 default:
4887 return Dataspace::V0_SRGB;
4888 }
4889}
4890
4891const sp<DisplayDevice> SurfaceFlinger::getDisplayByIdOrLayerStack(uint64_t displayOrLayerStack) {
4892 const sp<IBinder> displayToken = getPhysicalDisplayTokenLocked(DisplayId{displayOrLayerStack});
4893 if (displayToken) {
4894 return getDisplayDeviceLocked(displayToken);
4895 }
4896 // Couldn't find display by displayId. Try to get display by layerStack since virtual displays
4897 // may not have a displayId.
4898 for (const auto& [token, display] : mDisplays) {
4899 if (display->getLayerStack() == displayOrLayerStack) {
4900 return display;
4901 }
4902 }
4903 return nullptr;
4904}
4905
4906status_t SurfaceFlinger::captureScreen(uint64_t displayOrLayerStack, Dataspace* outDataspace,
4907 sp<GraphicBuffer>* outBuffer) {
4908 sp<DisplayDevice> display;
4909 uint32_t width;
4910 uint32_t height;
4911 ui::Transform::orientation_flags captureOrientation;
4912 {
4913 Mutex::Autolock _l(mStateLock);
4914 display = getDisplayByIdOrLayerStack(displayOrLayerStack);
4915 if (!display) {
4916 return BAD_VALUE;
4917 }
4918
4919 width = uint32_t(display->getViewport().width());
4920 height = uint32_t(display->getViewport().height());
4921
4922 captureOrientation = fromSurfaceComposerRotation(
4923 static_cast<ISurfaceComposer::Rotation>(display->getOrientation()));
Alec Mouri21fab752019-06-20 14:12:17 -07004924 if (captureOrientation == ui::Transform::orientation_flags::ROT_90) {
4925 captureOrientation = ui::Transform::orientation_flags::ROT_270;
4926 } else if (captureOrientation == ui::Transform::orientation_flags::ROT_270) {
4927 captureOrientation = ui::Transform::orientation_flags::ROT_90;
4928 }
chaviw93df2ea2019-04-30 16:45:12 -07004929 *outDataspace =
4930 pickDataspaceFromColorMode(display->getCompositionDisplay()->getState().colorMode);
4931 }
4932
4933 DisplayRenderArea renderArea(display, Rect(), width, height, *outDataspace, captureOrientation,
4934 false /* captureSecureLayers */);
4935
4936 auto traverseLayers = std::bind(&SurfaceFlinger::traverseLayersInDisplay, this, display,
4937 std::placeholders::_1);
4938 bool ignored = false;
4939 return captureScreenCommon(renderArea, traverseLayers, outBuffer, ui::PixelFormat::RGBA_8888,
4940 false /* useIdentityTransform */,
4941 ignored /* outCapturedSecureLayers */);
4942}
4943
Robert Carr866455f2019-04-02 16:28:26 -07004944status_t SurfaceFlinger::captureLayers(
4945 const sp<IBinder>& layerHandleBinder, sp<GraphicBuffer>* outBuffer,
4946 const Dataspace reqDataspace, const ui::PixelFormat reqPixelFormat, const Rect& sourceCrop,
4947 const std::unordered_set<sp<IBinder>, ISurfaceComposer::SpHash<IBinder>>& excludeHandles,
4948 float frameScale, bool childrenOnly) {
chaviwa76b2712017-09-20 12:02:26 -07004949 ATRACE_CALL();
4950
4951 class LayerRenderArea : public RenderArea {
4952 public:
Robert Carr578038f2018-03-09 12:25:24 -08004953 LayerRenderArea(SurfaceFlinger* flinger, const sp<Layer>& layer, const Rect crop,
Peiyong Lin0e003c92018-09-17 11:09:51 -07004954 int32_t reqWidth, int32_t reqHeight, Dataspace reqDataSpace,
4955 bool childrenOnly)
4956 : RenderArea(reqWidth, reqHeight, CaptureFill::CLEAR, reqDataSpace),
Robert Carr578038f2018-03-09 12:25:24 -08004957 mLayer(layer),
4958 mCrop(crop),
Chia-I Wu5f6664c2018-08-28 11:01:44 -07004959 mNeedsFiltering(false),
Robert Carr578038f2018-03-09 12:25:24 -08004960 mFlinger(flinger),
4961 mChildrenOnly(childrenOnly) {}
Peiyong Linefefaac2018-08-17 12:27:51 -07004962 const ui::Transform& getTransform() const override { return mTransform; }
Lloyd Pique0449b0f2018-12-20 16:23:45 -08004963 Rect getBounds() const override {
4964 const Layer::State& layerState(mLayer->getDrawingState());
4965 return mLayer->getBufferSize(layerState);
4966 }
Marissa Wall61c58622018-07-18 10:12:20 -07004967 int getHeight() const override {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08004968 return mLayer->getBufferSize(mLayer->getDrawingState()).getHeight();
Marissa Wall61c58622018-07-18 10:12:20 -07004969 }
Vishnu Nair88a11f22018-11-28 18:30:57 -08004970 int getWidth() const override {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08004971 return mLayer->getBufferSize(mLayer->getDrawingState()).getWidth();
Vishnu Nair88a11f22018-11-28 18:30:57 -08004972 }
chaviwa76b2712017-09-20 12:02:26 -07004973 bool isSecure() const override { return false; }
Chia-I Wu5f6664c2018-08-28 11:01:44 -07004974 bool needsFiltering() const override { return mNeedsFiltering; }
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004975 const sp<const DisplayDevice> getDisplayDevice() const override { return nullptr; }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08004976 Rect getSourceCrop() const override {
4977 if (mCrop.isEmpty()) {
4978 return getBounds();
4979 } else {
4980 return mCrop;
4981 }
4982 }
Robert Carr578038f2018-03-09 12:25:24 -08004983 class ReparentForDrawing {
4984 public:
4985 const sp<Layer>& oldParent;
4986 const sp<Layer>& newParent;
4987
Vishnu Nair4351ad52019-02-11 14:13:02 -08004988 ReparentForDrawing(const sp<Layer>& oldParent, const sp<Layer>& newParent,
4989 const Rect& drawingBounds)
Robert Carr578038f2018-03-09 12:25:24 -08004990 : oldParent(oldParent), newParent(newParent) {
Vishnu Nair4351ad52019-02-11 14:13:02 -08004991 // Compute and cache the bounds for the new parent layer.
4992 newParent->computeBounds(drawingBounds.toFloatRect(), ui::Transform());
Robert Carr15eae092018-03-23 13:43:53 -07004993 oldParent->setChildrenDrawingParent(newParent);
Robert Carr578038f2018-03-09 12:25:24 -08004994 }
Vishnu Nairbce6ffd2019-02-14 10:58:59 -08004995 ~ReparentForDrawing() { oldParent->setChildrenDrawingParent(oldParent); }
Robert Carr578038f2018-03-09 12:25:24 -08004996 };
4997
4998 void render(std::function<void()> drawLayers) override {
Chia-I Wu5f6664c2018-08-28 11:01:44 -07004999 const Rect sourceCrop = getSourceCrop();
5000 // no need to check rotation because there is none
5001 mNeedsFiltering = sourceCrop.width() != getReqWidth() ||
5002 sourceCrop.height() != getReqHeight();
5003
Robert Carr578038f2018-03-09 12:25:24 -08005004 if (!mChildrenOnly) {
5005 mTransform = mLayer->getTransform().inverse();
5006 drawLayers();
5007 } else {
5008 Rect bounds = getBounds();
chaviw32811fd2019-08-12 13:16:09 -07005009 // In the "childrenOnly" case we reparent the children to a screenshot
5010 // layer which has no properties set and which does not draw.
5011 sp<ContainerLayer> screenshotParentLayer =
5012 mFlinger->getFactory().createContainerLayer(
5013 LayerCreationArgs(mFlinger, nullptr, String8("Screenshot Parent"),
5014 bounds.getWidth(), bounds.getHeight(), 0,
5015 LayerMetadata()));
Robert Carr578038f2018-03-09 12:25:24 -08005016
Vishnu Nair4351ad52019-02-11 14:13:02 -08005017 ReparentForDrawing reparent(mLayer, screenshotParentLayer, sourceCrop);
Robert Carr578038f2018-03-09 12:25:24 -08005018 drawLayers();
5019 }
5020 }
chaviwa76b2712017-09-20 12:02:26 -07005021
chaviwa76b2712017-09-20 12:02:26 -07005022 private:
chaviw7206d492017-11-10 16:16:12 -08005023 const sp<Layer> mLayer;
5024 const Rect mCrop;
Robert Carr578038f2018-03-09 12:25:24 -08005025
Peiyong Linefefaac2018-08-17 12:27:51 -07005026 ui::Transform mTransform;
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005027 bool mNeedsFiltering;
Robert Carr578038f2018-03-09 12:25:24 -08005028
5029 SurfaceFlinger* mFlinger;
5030 const bool mChildrenOnly;
chaviwa76b2712017-09-20 12:02:26 -07005031 };
5032
Robert Carrc0df3122019-04-11 13:18:21 -07005033 int reqWidth = 0;
5034 int reqHeight = 0;
5035 sp<Layer> parent;
chaviw7206d492017-11-10 16:16:12 -08005036 Rect crop(sourceCrop);
Robert Carrc0df3122019-04-11 13:18:21 -07005037 std::unordered_set<sp<Layer>, ISurfaceComposer::SpHash<Layer>> excludeLayers;
chaviw7206d492017-11-10 16:16:12 -08005038
Robert Carrc0df3122019-04-11 13:18:21 -07005039 {
5040 Mutex::Autolock _l(mStateLock);
chaviw7206d492017-11-10 16:16:12 -08005041
Robert Carrc0df3122019-04-11 13:18:21 -07005042 parent = fromHandle(layerHandleBinder);
5043 if (parent == nullptr || parent->isRemovedFromCurrentState()) {
5044 ALOGE("captureLayers called with an invalid or removed parent");
5045 return NAME_NOT_FOUND;
5046 }
5047
5048 const int uid = IPCThreadState::self()->getCallingUid();
5049 const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
5050 if (!forSystem && parent->getCurrentState().flags & layer_state_t::eLayerSecure) {
5051 ALOGW("Attempting to capture secure layer: PERMISSION_DENIED");
5052 return PERMISSION_DENIED;
5053 }
5054
5055 if (sourceCrop.width() <= 0) {
5056 crop.left = 0;
5057 crop.right = parent->getBufferSize(parent->getCurrentState()).getWidth();
5058 }
5059
5060 if (sourceCrop.height() <= 0) {
5061 crop.top = 0;
5062 crop.bottom = parent->getBufferSize(parent->getCurrentState()).getHeight();
5063 }
5064 reqWidth = crop.width() * frameScale;
5065 reqHeight = crop.height() * frameScale;
5066
5067 for (const auto& handle : excludeHandles) {
5068 sp<Layer> excludeLayer = fromHandle(handle);
5069 if (excludeLayer != nullptr) {
5070 excludeLayers.emplace(excludeLayer);
5071 } else {
5072 ALOGW("Invalid layer handle passed as excludeLayer to captureLayers");
5073 return NAME_NOT_FOUND;
5074 }
5075 }
5076 } // mStateLock
chaviw7206d492017-11-10 16:16:12 -08005077
Chia-I Wu20261cb2018-08-23 12:55:44 -07005078 // really small crop or frameScale
5079 if (reqWidth <= 0) {
5080 reqWidth = 1;
5081 }
5082 if (reqHeight <= 0) {
5083 reqHeight = 1;
5084 }
5085
Robert Carr866455f2019-04-02 16:28:26 -07005086 LayerRenderArea renderArea(this, parent, crop, reqWidth, reqHeight, reqDataspace, childrenOnly);
5087 auto traverseLayers = [parent, childrenOnly,
5088 &excludeLayers](const LayerVector::Visitor& visitor) {
chaviwa76b2712017-09-20 12:02:26 -07005089 parent->traverseChildrenInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
5090 if (!layer->isVisible()) {
5091 return;
Robert Carr578038f2018-03-09 12:25:24 -08005092 } else if (childrenOnly && layer == parent.get()) {
5093 return;
chaviwa76b2712017-09-20 12:02:26 -07005094 }
Robert Carr866455f2019-04-02 16:28:26 -07005095
5096 sp<Layer> p = layer;
5097 while (p != nullptr) {
5098 if (excludeLayers.count(p) != 0) {
5099 return;
5100 }
5101 p = p->getParent();
5102 }
5103
chaviwa76b2712017-09-20 12:02:26 -07005104 visitor(layer);
5105 });
5106 };
Robert Carr108b2c72019-04-02 16:32:58 -07005107
5108 bool outCapturedSecureLayers = false;
5109 return captureScreenCommon(renderArea, traverseLayers, outBuffer, reqPixelFormat, false,
5110 outCapturedSecureLayers);
chaviwa76b2712017-09-20 12:02:26 -07005111}
5112
5113status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea,
5114 TraverseLayersFunction traverseLayers,
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005115 sp<GraphicBuffer>* outBuffer,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005116 const ui::PixelFormat reqPixelFormat,
Robert Carr108b2c72019-04-02 16:32:58 -07005117 bool useIdentityTransform,
5118 bool& outCapturedSecureLayers) {
chaviwa76b2712017-09-20 12:02:26 -07005119 ATRACE_CALL();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005120
Peiyong Lin0e003c92018-09-17 11:09:51 -07005121 // TODO(b/116112787) Make buffer usage a parameter.
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005122 const uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
5123 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
Lloyd Pique90c115d2018-09-18 21:39:42 -07005124 *outBuffer =
5125 getFactory().createGraphicBuffer(renderArea.getReqWidth(), renderArea.getReqHeight(),
5126 static_cast<android_pixel_format>(reqPixelFormat), 1,
5127 usage, "screenshot");
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005128
Robert Carr108b2c72019-04-02 16:32:58 -07005129 return captureScreenCommon(renderArea, traverseLayers, *outBuffer, useIdentityTransform,
5130 outCapturedSecureLayers);
Dan Stozaec460082018-12-17 15:35:09 -08005131}
5132
Kevin DuBois7cbcc372019-02-25 14:53:28 -08005133status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea,
5134 TraverseLayersFunction traverseLayers,
5135 const sp<GraphicBuffer>& buffer,
Robert Carr108b2c72019-04-02 16:32:58 -07005136 bool useIdentityTransform,
5137 bool& outCapturedSecureLayers) {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005138 // This mutex protects syncFd and captureResult for communication of the return values from the
5139 // main thread back to this Binder thread
5140 std::mutex captureMutex;
5141 std::condition_variable captureCondition;
5142 std::unique_lock<std::mutex> captureLock(captureMutex);
5143 int syncFd = -1;
5144 std::optional<status_t> captureResult;
5145
Robert Carr03480e22018-01-04 16:02:06 -08005146 const int uid = IPCThreadState::self()->getCallingUid();
5147 const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
5148
Dominik Laskowski8c001672018-05-30 16:52:06 -07005149 sp<LambdaMessage> message = new LambdaMessage([&] {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005150 // If there is a refresh pending, bug out early and tell the binder thread to try again
5151 // after the refresh.
5152 if (mRefreshPending) {
5153 ATRACE_NAME("Skipping screenshot for now");
5154 std::unique_lock<std::mutex> captureLock(captureMutex);
5155 captureResult = std::make_optional<status_t>(EAGAIN);
5156 captureCondition.notify_one();
5157 return;
5158 }
5159
5160 status_t result = NO_ERROR;
5161 int fd = -1;
5162 {
5163 Mutex::Autolock _l(mStateLock);
Dominik Laskowski8c001672018-05-30 16:52:06 -07005164 renderArea.render([&] {
Dan Stozaec460082018-12-17 15:35:09 -08005165 result = captureScreenImplLocked(renderArea, traverseLayers, buffer.get(),
Robert Carr108b2c72019-04-02 16:32:58 -07005166 useIdentityTransform, forSystem, &fd,
5167 outCapturedSecureLayers);
Robert Carr578038f2018-03-09 12:25:24 -08005168 });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005169 }
5170
5171 {
5172 std::unique_lock<std::mutex> captureLock(captureMutex);
5173 syncFd = fd;
5174 captureResult = std::make_optional<status_t>(result);
5175 captureCondition.notify_one();
5176 }
5177 });
5178
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005179 status_t result = postMessageAsync(message);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005180 if (result == NO_ERROR) {
Dominik Laskowski8c001672018-05-30 16:52:06 -07005181 captureCondition.wait(captureLock, [&] { return captureResult; });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005182 while (*captureResult == EAGAIN) {
5183 captureResult.reset();
5184 result = postMessageAsync(message);
5185 if (result != NO_ERROR) {
5186 return result;
5187 }
Dominik Laskowski8c001672018-05-30 16:52:06 -07005188 captureCondition.wait(captureLock, [&] { return captureResult; });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005189 }
5190 result = *captureResult;
5191 }
5192
5193 if (result == NO_ERROR) {
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005194 sync_wait(syncFd, -1);
5195 close(syncFd);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005196 }
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005197
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005198 return result;
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005199}
5200
chaviwa76b2712017-09-20 12:02:26 -07005201void SurfaceFlinger::renderScreenImplLocked(const RenderArea& renderArea,
Chia-I Wu1be50b52018-08-29 10:44:48 -07005202 TraverseLayersFunction traverseLayers,
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005203 ANativeWindowBuffer* buffer, bool useIdentityTransform,
5204 int* outSyncFd) {
Mathias Agopian180f10d2013-04-10 22:55:41 -07005205 ATRACE_CALL();
chaviwa76b2712017-09-20 12:02:26 -07005206
chaviwa76b2712017-09-20 12:02:26 -07005207 const auto reqWidth = renderArea.getReqWidth();
5208 const auto reqHeight = renderArea.getReqHeight();
Chia-I Wuf2aa3112018-08-27 14:54:37 -07005209 const auto rotation = renderArea.getRotationFlags();
Alec Mouriadb75f42019-03-28 21:42:24 -07005210 const auto transform = renderArea.getTransform();
5211 const auto sourceCrop = renderArea.getSourceCrop();
Dan Stozac1879002014-05-22 15:59:05 -07005212
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005213 renderengine::DisplaySettings clientCompositionDisplay;
5214 std::vector<renderengine::LayerSettings> clientCompositionLayers;
Romain Guy88d37dd2017-05-26 17:57:05 -07005215
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005216 // assume that bounds are never offset, and that they are the same as the
5217 // buffer bounds.
5218 clientCompositionDisplay.physicalDisplay = Rect(reqWidth, reqHeight);
Alec Mouriadb75f42019-03-28 21:42:24 -07005219 clientCompositionDisplay.clip = sourceCrop;
Lloyd Pique7e06e7f2019-03-15 18:36:44 -07005220 clientCompositionDisplay.globalTransform = transform.asMatrix4();
Alec Mouriadb75f42019-03-28 21:42:24 -07005221
5222 // Now take into account the rotation flag. We append a transform that
5223 // rotates the layer stack about the origin, then translate by buffer
5224 // boundaries to be in the right quadrant.
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005225 mat4 rotMatrix;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005226 int displacementX = 0;
5227 int displacementY = 0;
5228 float rot90InRadians = 2.0f * static_cast<float>(M_PI) / 4.0f;
5229 switch (rotation) {
5230 case ui::Transform::ROT_90:
5231 rotMatrix = mat4::rotate(rot90InRadians, vec3(0, 0, 1));
Alec Mouriadb75f42019-03-28 21:42:24 -07005232 displacementX = renderArea.getBounds().getHeight();
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005233 break;
5234 case ui::Transform::ROT_180:
5235 rotMatrix = mat4::rotate(rot90InRadians * 2.0f, vec3(0, 0, 1));
Alec Mouriadb75f42019-03-28 21:42:24 -07005236 displacementY = renderArea.getBounds().getWidth();
5237 displacementX = renderArea.getBounds().getHeight();
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005238 break;
5239 case ui::Transform::ROT_270:
5240 rotMatrix = mat4::rotate(rot90InRadians * 3.0f, vec3(0, 0, 1));
Alec Mouriadb75f42019-03-28 21:42:24 -07005241 displacementY = renderArea.getBounds().getWidth();
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005242 break;
5243 default:
5244 break;
5245 }
Alec Mouriadb75f42019-03-28 21:42:24 -07005246
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005247 // We need to transform the clipping window into the right spot.
5248 // First, rotate the clipping rectangle by the rotation hint to get the
5249 // right orientation
5250 const vec4 clipTL = vec4(sourceCrop.left, sourceCrop.top, 0, 1);
5251 const vec4 clipBR = vec4(sourceCrop.right, sourceCrop.bottom, 0, 1);
5252 const vec4 rotClipTL = rotMatrix * clipTL;
5253 const vec4 rotClipBR = rotMatrix * clipBR;
5254 const int newClipLeft = std::min(rotClipTL[0], rotClipBR[0]);
5255 const int newClipTop = std::min(rotClipTL[1], rotClipBR[1]);
5256 const int newClipRight = std::max(rotClipTL[0], rotClipBR[0]);
5257 const int newClipBottom = std::max(rotClipTL[1], rotClipBR[1]);
5258
5259 // Now reposition the clipping rectangle with the displacement vector
5260 // computed above.
5261 const mat4 displacementMat = mat4::translate(vec4(displacementX, displacementY, 0, 1));
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005262 clientCompositionDisplay.clip =
5263 Rect(newClipLeft + displacementX, newClipTop + displacementY,
5264 newClipRight + displacementX, newClipBottom + displacementY);
5265
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005266 mat4 clipTransform = displacementMat * rotMatrix;
Alec Mouriadb75f42019-03-28 21:42:24 -07005267 clientCompositionDisplay.globalTransform =
5268 clipTransform * clientCompositionDisplay.globalTransform;
5269
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005270 clientCompositionDisplay.outputDataspace = renderArea.getReqDataSpace();
5271 clientCompositionDisplay.maxLuminance = DisplayDevice::sDefaultMaxLumiance;
Mathias Agopian180f10d2013-04-10 22:55:41 -07005272
chaviw50da5042018-04-09 13:49:37 -07005273 const float alpha = RenderArea::getCaptureFillValue(renderArea.getCaptureFill());
Mathias Agopian180f10d2013-04-10 22:55:41 -07005274
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005275 renderengine::LayerSettings fillLayer;
5276 fillLayer.source.buffer.buffer = nullptr;
5277 fillLayer.source.solidColor = half3(0.0, 0.0, 0.0);
5278 fillLayer.geometry.boundaries = FloatRect(0.0, 0.0, 1.0, 1.0);
5279 fillLayer.alpha = half(alpha);
5280 clientCompositionLayers.push_back(fillLayer);
5281
5282 Region clearRegion = Region::INVALID_REGION;
chaviwa76b2712017-09-20 12:02:26 -07005283 traverseLayers([&](Layer* layer) {
Lloyd Piquef16688f2019-02-19 17:47:57 -08005284 const bool supportProtectedContent = false;
5285 Region clip(renderArea.getBounds());
5286 compositionengine::LayerFE::ClientCompositionTargetSettings targetSettings{
5287 clip,
5288 useIdentityTransform,
5289 layer->needsFiltering(renderArea.getDisplayDevice()) || renderArea.needsFiltering(),
5290 renderArea.isSecure(),
5291 supportProtectedContent,
5292 clearRegion,
5293 };
5294 auto result = layer->prepareClientComposition(targetSettings);
5295 if (result) {
5296 clientCompositionLayers.push_back(*result);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005297 }
chaviwa76b2712017-09-20 12:02:26 -07005298 });
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005299
5300 clientCompositionDisplay.clearRegion = clearRegion;
Alec Mouri6338c9d2019-02-07 16:57:51 -08005301 // Use an empty fence for the buffer fence, since we just created the buffer so
5302 // there is no need for synchronization with the GPU.
5303 base::unique_fd bufferFence;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005304 base::unique_fd drawFence;
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08005305 getRenderEngine().useProtectedContext(false);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005306 getRenderEngine().drawLayers(clientCompositionDisplay, clientCompositionLayers, buffer,
Alec Mourife0d72b2019-03-21 14:05:56 -07005307 /*useFramebufferCache=*/false, std::move(bufferFence), &drawFence);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005308
5309 *outSyncFd = drawFence.release();
Mathias Agopian180f10d2013-04-10 22:55:41 -07005310}
5311
chaviwa76b2712017-09-20 12:02:26 -07005312status_t SurfaceFlinger::captureScreenImplLocked(const RenderArea& renderArea,
5313 TraverseLayersFunction traverseLayers,
5314 ANativeWindowBuffer* buffer,
Robert Carr108b2c72019-04-02 16:32:58 -07005315 bool useIdentityTransform, bool forSystem,
5316 int* outSyncFd, bool& outCapturedSecureLayers) {
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005317 ATRACE_CALL();
5318
chaviwa76b2712017-09-20 12:02:26 -07005319 traverseLayers([&](Layer* layer) {
Robert Carr108b2c72019-04-02 16:32:58 -07005320 outCapturedSecureLayers =
5321 outCapturedSecureLayers || (layer->isVisible() && layer->isSecure());
chaviwa76b2712017-09-20 12:02:26 -07005322 });
Pablo Ceballosb5b35632016-02-23 11:18:51 -08005323
Robert Carr03480e22018-01-04 16:02:06 -08005324 // We allow the system server to take screenshots of secure layers for
5325 // use in situations like the Screen-rotation animation and place
5326 // the impetus on WindowManager to not persist them.
Robert Carr108b2c72019-04-02 16:32:58 -07005327 if (outCapturedSecureLayers && !forSystem) {
Pablo Ceballosb5b35632016-02-23 11:18:51 -08005328 ALOGW("FB is protected: PERMISSION_DENIED");
5329 return PERMISSION_DENIED;
5330 }
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005331 renderScreenImplLocked(renderArea, traverseLayers, buffer, useIdentityTransform, outSyncFd);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005332 return NO_ERROR;
Mathias Agopian74c40c02010-09-29 13:02:36 -07005333}
5334
chaviw95ef3c42019-02-14 10:55:09 -08005335void SurfaceFlinger::setInputWindowsFinished() {
5336 Mutex::Autolock _l(mStateLock);
5337
5338 mPendingSyncInputWindows = false;
5339 mTransactionCV.broadcast();
5340}
chaviw5f21a5e2019-02-14 10:00:34 -08005341
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07005342// ---------------------------------------------------------------------------
5343
Dan Stoza412903f2017-04-27 13:42:17 -07005344void SurfaceFlinger::State::traverseInZOrder(const LayerVector::Visitor& visitor) const {
5345 layersSortedByZ.traverseInZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07005346}
5347
Dan Stoza412903f2017-04-27 13:42:17 -07005348void SurfaceFlinger::State::traverseInReverseZOrder(const LayerVector::Visitor& visitor) const {
5349 layersSortedByZ.traverseInReverseZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07005350}
5351
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005352void SurfaceFlinger::traverseLayersInDisplay(const sp<const DisplayDevice>& display,
chaviwa76b2712017-09-20 12:02:26 -07005353 const LayerVector::Visitor& visitor) {
5354 // We loop through the first level of layers without traversing,
chaviw0e3479f2018-09-10 16:49:30 -07005355 // as we need to determine which layers belong to the requested display.
chaviwa76b2712017-09-20 12:02:26 -07005356 for (const auto& layer : mDrawingState.layersSortedByZ) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005357 if (!layer->belongsToDisplay(display->getLayerStack(), false)) {
chaviwa76b2712017-09-20 12:02:26 -07005358 continue;
5359 }
Chia-I Wuec2d9852017-11-21 09:21:01 -08005360 // relative layers are traversed in Layer::traverseInZOrder
chaviwa76b2712017-09-20 12:02:26 -07005361 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005362 if (!layer->belongsToDisplay(display->getLayerStack(), false)) {
Adrian Roos8acf5a02018-01-17 21:28:19 +01005363 return;
5364 }
chaviwa76b2712017-09-20 12:02:26 -07005365 if (!layer->isVisible()) {
5366 return;
5367 }
5368 visitor(layer);
5369 });
5370 }
5371}
5372
Dominik Laskowski22488f62019-03-28 09:53:04 -07005373void SurfaceFlinger::setAllowedDisplayConfigsInternal(const sp<DisplayDevice>& display,
5374 const std::vector<int32_t>& allowedConfigs) {
5375 if (!display->isPrimary()) {
Ady Abraham838de062019-02-04 10:24:03 -08005376 return;
5377 }
5378
Adrian Salidoab6ef6c2019-08-28 10:02:49 -07005379 const auto allowedDisplayConfigs = DisplayConfigs(allowedConfigs.begin(),
5380 allowedConfigs.end());
5381 if (allowedDisplayConfigs == mAllowedDisplayConfigs) {
5382 return;
5383 }
5384
Ady Abraham838de062019-02-04 10:24:03 -08005385 ALOGV("Updating allowed configs");
Adrian Salidoab6ef6c2019-08-28 10:02:49 -07005386 mAllowedDisplayConfigs = std::move(allowedDisplayConfigs);
5387
5388 // TODO(b/140204874): This hack triggers a notification that something has changed, so
5389 // that listeners that care about a change in allowed configs can get the notification.
5390 // Giving current ActiveConfig so that most other listeners would just drop the event
5391 mScheduler->onConfigChanged(mAppConnectionHandle, display->getId()->value,
5392 display->getActiveConfig());
Ady Abraham838de062019-02-04 10:24:03 -08005393
Steven Thomas2bbaabe2019-08-28 16:08:35 -07005394 if (mRefreshRateConfigs->refreshRateSwitchingSupported()) {
5395 const auto& type = mScheduler->getPreferredRefreshRateType();
5396 const auto& config = mRefreshRateConfigs->getRefreshRateFromType(type);
5397 if (isDisplayConfigAllowed(config.configId)) {
5398 ALOGV("switching to Scheduler preferred config %d", config.configId);
5399 setDesiredActiveConfig({type, config.configId, Scheduler::ConfigEvent::Changed});
5400 } else {
5401 // Set the highest allowed config by iterating backwards on available refresh rates
5402 const auto& refreshRates = mRefreshRateConfigs->getRefreshRateMap();
5403 for (auto iter = refreshRates.crbegin(); iter != refreshRates.crend(); ++iter) {
5404 if (isDisplayConfigAllowed(iter->second.configId)) {
5405 ALOGV("switching to allowed config %d", iter->second.configId);
5406 setDesiredActiveConfig(
5407 {iter->first, iter->second.configId, Scheduler::ConfigEvent::Changed});
5408 break;
5409 }
5410 }
5411 }
5412 } else if (!allowedConfigs.empty()) {
5413 ALOGV("switching to config %d", allowedConfigs[0]);
5414 setDesiredActiveConfig(
5415 {RefreshRateType::DEFAULT, allowedConfigs[0], Scheduler::ConfigEvent::Changed});
5416 }
Ady Abraham838de062019-02-04 10:24:03 -08005417}
5418
Dominik Laskowski22488f62019-03-28 09:53:04 -07005419status_t SurfaceFlinger::setAllowedDisplayConfigs(const sp<IBinder>& displayToken,
Ady Abraham838de062019-02-04 10:24:03 -08005420 const std::vector<int32_t>& allowedConfigs) {
5421 ATRACE_CALL();
5422
Dominik Laskowski22488f62019-03-28 09:53:04 -07005423 if (!displayToken || allowedConfigs.empty()) {
Ady Abraham838de062019-02-04 10:24:03 -08005424 return BAD_VALUE;
5425 }
5426
Ady Abraham34392f72019-04-10 11:29:27 -07005427 if (mDebugDisplayConfigSetByBackdoor) {
5428 // ignore this request as config is overridden by backdoor
5429 return NO_ERROR;
5430 }
5431
Ady Abraham838de062019-02-04 10:24:03 -08005432 postMessageSync(new LambdaMessage([&]() NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowski22488f62019-03-28 09:53:04 -07005433 const auto display = getDisplayDeviceLocked(displayToken);
5434 if (!display) {
5435 ALOGE("Attempt to set allowed display configs for invalid display token %p",
5436 displayToken.get());
5437 } else if (display->isVirtual()) {
5438 ALOGW("Attempt to set allowed display configs for virtual display");
5439 } else {
5440 setAllowedDisplayConfigsInternal(display, allowedConfigs);
5441 }
Ady Abraham838de062019-02-04 10:24:03 -08005442 }));
Dominik Laskowski22488f62019-03-28 09:53:04 -07005443
Ady Abraham838de062019-02-04 10:24:03 -08005444 return NO_ERROR;
5445}
5446
Dominik Laskowski22488f62019-03-28 09:53:04 -07005447status_t SurfaceFlinger::getAllowedDisplayConfigs(const sp<IBinder>& displayToken,
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08005448 std::vector<int32_t>* outAllowedConfigs) {
5449 ATRACE_CALL();
5450
Dominik Laskowski22488f62019-03-28 09:53:04 -07005451 if (!displayToken || !outAllowedConfigs) {
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08005452 return BAD_VALUE;
5453 }
5454
Dominik Laskowski22488f62019-03-28 09:53:04 -07005455 Mutex::Autolock lock(mStateLock);
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08005456
Dominik Laskowski4f1dd8c2019-04-17 15:54:30 -07005457 const auto display = getDisplayDeviceLocked(displayToken);
5458 if (!display) {
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08005459 return NAME_NOT_FOUND;
5460 }
5461
Dominik Laskowski4f1dd8c2019-04-17 15:54:30 -07005462 if (display->isPrimary()) {
5463 outAllowedConfigs->assign(mAllowedDisplayConfigs.begin(), mAllowedDisplayConfigs.end());
5464 }
5465
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08005466 return NO_ERROR;
5467}
5468
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005469void SurfaceFlinger::SetInputWindowsListener::onSetInputWindowsFinished() {
chaviw291d88a2019-02-14 10:33:58 -08005470 mFlinger->setInputWindowsFinished();
5471}
5472
Robert Carrc0df3122019-04-11 13:18:21 -07005473sp<Layer> SurfaceFlinger::fromHandle(const sp<IBinder>& handle) {
5474 BBinder *b = handle->localBinder();
5475 if (b == nullptr) {
5476 return nullptr;
5477 }
5478 auto it = mLayersByLocalBinderToken.find(b);
5479 if (it != mLayersByLocalBinderToken.end()) {
5480 return it->second.promote();
5481 }
5482 return nullptr;
5483}
5484
Alec Mouri4545a8a2019-08-08 20:05:32 -07005485void SurfaceFlinger::bufferErased(const client_cache_t& clientCacheId) {
5486 getRenderEngine().unbindExternalTextureBuffer(clientCacheId.id);
5487}
5488
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005489} // namespace android
Lloyd Pique074e8122018-07-26 12:57:23 -07005490
Mathias Agopian3f844832013-08-07 21:24:32 -07005491#if defined(__gl_h_)
5492#error "don't include gl/gl.h in this file"
5493#endif
5494
5495#if defined(__gl2_h_)
5496#error "don't include gl2/gl2.h in this file"
Chia-I Wu767fcf72017-11-30 22:07:38 -08005497#endif