blob: 669e37c93efe0fb0638a7b2552d39d4873409894 [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
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -080017// TODO(b/129481165): remove the #pragma below and fix conversion issues
18#pragma clang diagnostic push
19#pragma clang diagnostic ignored "-Wconversion"
20
Alec Mourie7d1d4a2019-02-05 01:13:46 +000021//#define LOG_NDEBUG 0
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080022#define ATRACE_TAG ATRACE_TAG_GRAPHICS
23
Alec Mouri989ddbe2020-02-06 09:26:19 -080024#include "SurfaceFlinger.h"
Dominik Laskowski83b88212018-12-11 13:34:06 -080025
Alec Mouri989ddbe2020-02-06 09:26:19 -080026#include <android/configuration.h>
27#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
28#include <android/hardware/configstore/1.1/ISurfaceFlingerConfigs.h>
29#include <android/hardware/configstore/1.1/types.h>
30#include <android/hardware/power/1.0/IPower.h>
Steven Thomas62a4cf82020-01-31 12:04:03 -080031#include <android/native_window.h>
Mathias Agopianc5b2c0b2009-05-19 19:08:10 -070032#include <binder/IPCThreadState.h>
33#include <binder/IServiceManager.h>
Mathias Agopian99b49842011-06-27 16:05:52 -070034#include <binder/PermissionCache.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070035#include <compositionengine/CompositionEngine.h>
Lloyd Piqueab039b52019-02-13 14:22:42 -080036#include <compositionengine/CompositionRefreshArgs.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070037#include <compositionengine/Display.h>
Lloyd Pique3d0c02e2018-10-19 18:38:12 -070038#include <compositionengine/DisplayColorProfile.h>
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -070039#include <compositionengine/DisplayCreationArgs.h>
Lloyd Piquede196652020-01-22 17:29:58 -080040#include <compositionengine/LayerFECompositionState.h>
Lloyd Piquecc01a452018-12-04 17:24:00 -080041#include <compositionengine/OutputLayer.h>
Lloyd Pique31cb2942018-10-19 17:23:03 -070042#include <compositionengine/RenderSurface.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070043#include <compositionengine/impl/OutputCompositionState.h>
Alec Mouri989ddbe2020-02-06 09:26:19 -080044#include <configstore/Utils.h>
45#include <cutils/compiler.h>
46#include <cutils/properties.h>
47#include <dlfcn.h>
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -080048#include <dvr/vr_flinger.h>
Alec Mouri989ddbe2020-02-06 09:26:19 -080049#include <errno.h>
Jamie Gennis1a4d8832012-08-02 20:11:05 -070050#include <gui/BufferQueue.h>
Ady Abrahama3b08ef2019-07-15 18:43:10 -070051#include <gui/DebugEGLImageTracker.h>
Andy McFadden4803b742012-09-24 19:07:20 -070052#include <gui/GuiConfig.h>
Jamie Gennis1a4d8832012-08-02 20:11:05 -070053#include <gui/IDisplayEventConnection.h>
Alec Mouri0a9c7b82018-11-16 13:05:25 -080054#include <gui/IProducerListener.h>
Kalle Raitaa099a242017-01-11 11:17:29 -080055#include <gui/LayerDebugInfo.h>
Lloyd Pique4603f3c2020-02-11 12:06:56 -080056#include <gui/LayerMetadata.h>
Steven Thomas62a4cf82020-01-31 12:04:03 -080057#include <gui/LayerState.h>
Mathias Agopiane3c697f2013-02-14 17:11:02 -080058#include <gui/Surface.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070059#include <input/IInputFlinger.h>
Alec Mouri989ddbe2020-02-06 09:26:19 -080060#include <layerproto/LayerProtoParser.h>
61#include <log/log.h>
62#include <private/android_filesystem_config.h>
63#include <private/gui/SyncFeatures.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070064#include <renderengine/RenderEngine.h>
Alec Mouri989ddbe2020-02-06 09:26:19 -080065#include <statslog.h>
66#include <sys/types.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070067#include <ui/ColorSpace.h>
68#include <ui/DebugUtils.h>
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -080069#include <ui/DisplayConfig.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070070#include <ui/DisplayInfo.h>
71#include <ui/DisplayStatInfo.h>
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -080072#include <ui/DisplayState.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070073#include <ui/GraphicBufferAllocator.h>
74#include <ui/PixelFormat.h>
Andy McFadden4803b742012-09-24 19:07:20 -070075#include <ui/UiConfig.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080076#include <utils/StopWatch.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070077#include <utils/String16.h>
78#include <utils/String8.h>
Yusuke Sato0a688f52015-07-30 23:05:39 -070079#include <utils/Timers.h>
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080080#include <utils/Trace.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070081#include <utils/misc.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080082
Alec Mouri989ddbe2020-02-06 09:26:19 -080083#include <algorithm>
84#include <cinttypes>
85#include <cmath>
86#include <cstdint>
87#include <functional>
88#include <mutex>
89#include <optional>
90#include <unordered_map>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080091
Robert Carr578038f2018-03-09 12:25:24 -080092#include "BufferLayer.h"
Marissa Wallfd668622018-05-10 10:21:13 -070093#include "BufferQueueLayer.h"
Marissa Wall61c58622018-07-18 10:12:20 -070094#include "BufferStateLayer.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +020095#include "Client.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +020096#include "Colorizer.h"
Robert Carr578038f2018-03-09 12:25:24 -080097#include "ContainerLayer.h"
Robert Carr578038f2018-03-09 12:25:24 -080098#include "DisplayDevice.h"
Steven Thomasb02664d2017-07-26 18:48:28 -070099#include "DisplayHardware/ComposerHal.h"
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700100#include "DisplayHardware/DisplayIdentification.h"
Mathias Agopiana4912602012-07-12 14:25:33 -0700101#include "DisplayHardware/FramebufferSurface.h"
Mathias Agopiana350ff92010-08-10 17:14:02 -0700102#include "DisplayHardware/HWComposer.h"
Jesse Hall99c7dbb2013-03-14 14:29:29 -0700103#include "DisplayHardware/VirtualDisplaySurface.h"
Alec Mouri989ddbe2020-02-06 09:26:19 -0800104#include "EffectLayer.h"
Mathias Agopianff2ed702013-09-01 21:36:12 -0700105#include "Effects/Daltonizer.h"
Mikael Pessa90092f42019-08-26 17:22:04 -0700106#include "FrameTracer/FrameTracer.h"
Alec Mouri989ddbe2020-02-06 09:26:19 -0800107#include "Layer.h"
108#include "LayerVector.h"
109#include "MonitoredProducer.h"
110#include "NativeWindowSurface.h"
111#include "RefreshRateOverlay.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700112#include "RegionSamplingThread.h"
Ana Krulecfefcb582018-08-07 14:22:37 -0700113#include "Scheduler/DispSync.h"
Ana Krulec241cf832018-08-10 15:03:23 -0700114#include "Scheduler/DispSyncSource.h"
Ana Krulecfefcb582018-08-07 14:22:37 -0700115#include "Scheduler/EventControlThread.h"
116#include "Scheduler/EventThread.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -0700117#include "Scheduler/MessageQueue.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700118#include "Scheduler/PhaseOffsets.h"
Ana Krulec98b5b242018-08-10 15:03:23 -0700119#include "Scheduler/Scheduler.h"
Alec Mouri989ddbe2020-02-06 09:26:19 -0800120#include "StartPropertySetThread.h"
121#include "SurfaceFlingerProperties.h"
122#include "SurfaceInterceptor.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800123#include "TimeStats/TimeStats.h"
Dominik Laskowskib6e54372019-09-04 14:06:28 -0700124#include "android-base/parseint.h"
David Sodman7e4ae112018-02-09 15:02:28 -0800125#include "android-base/stringprintf.h"
126
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800127namespace android {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700128
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700129using namespace std::string_literals;
130
Jaesoo Lee43518572017-01-23 19:03:16 +0900131using namespace android::hardware::configstore;
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900132using namespace android::hardware::configstore::V1_0;
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900133using namespace android::sysprop;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -0800134
Ady Abraham8532d012019-05-08 14:50:56 -0700135using android::hardware::power::V1_0::PowerHint;
Yiwei Zhang5434a782018-12-05 18:06:32 -0800136using base::StringAppendF;
Peiyong Lin9f034472018-03-28 15:29:00 -0700137using ui::ColorMode;
Peiyong Lin34beb7a2018-03-28 11:57:12 -0700138using ui::Dataspace;
Daniel Solomon42d04562019-01-20 21:03:19 -0800139using ui::DisplayPrimaries;
Peiyong Lin62665892018-04-16 11:07:44 -0700140using ui::Hdr;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700141using ui::RenderIntent;
Jiyong Park4b20c2e2017-01-14 19:45:11 +0900142
Steven Thomasb02664d2017-07-26 18:48:28 -0700143namespace {
Peiyong Linfca547f2018-07-09 13:03:33 -0700144
145#pragma clang diagnostic push
146#pragma clang diagnostic error "-Wswitch-enum"
147
148bool isWideColorMode(const ColorMode colorMode) {
149 switch (colorMode) {
150 case ColorMode::DISPLAY_P3:
151 case ColorMode::ADOBE_RGB:
152 case ColorMode::DCI_P3:
153 case ColorMode::BT2020:
Valerie Hau9758ae02018-10-09 16:05:09 -0700154 case ColorMode::DISPLAY_BT2020:
Peiyong Linfca547f2018-07-09 13:03:33 -0700155 case ColorMode::BT2100_PQ:
156 case ColorMode::BT2100_HLG:
157 return true;
158 case ColorMode::NATIVE:
159 case ColorMode::STANDARD_BT601_625:
160 case ColorMode::STANDARD_BT601_625_UNADJUSTED:
161 case ColorMode::STANDARD_BT601_525:
162 case ColorMode::STANDARD_BT601_525_UNADJUSTED:
163 case ColorMode::STANDARD_BT709:
164 case ColorMode::SRGB:
165 return false;
166 }
167 return false;
168}
169
170#pragma clang diagnostic pop
171
Steven Thomasb02664d2017-07-26 18:48:28 -0700172class ConditionalLock {
173public:
174 ConditionalLock(Mutex& mutex, bool lock) : mMutex(mutex), mLocked(lock) {
175 if (lock) {
176 mMutex.lock();
177 }
178 }
179 ~ConditionalLock() { if (mLocked) mMutex.unlock(); }
180private:
181 Mutex& mMutex;
182 bool mLocked;
183};
Peiyong Linfca547f2018-07-09 13:03:33 -0700184
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800185// TODO(b/141333600): Consolidate with HWC2::Display::Config::Builder::getDefaultDensity.
186constexpr float FALLBACK_DENSITY = ACONFIGURATION_DENSITY_TV / 160.f;
187
188float getDensityFromProperty(const char* property, bool required) {
189 char value[PROPERTY_VALUE_MAX];
190 const float density = property_get(property, value, nullptr) > 0 ? std::atof(value) : 0.f;
191 if (!density && required) {
192 ALOGE("%s must be defined as a build property", property);
193 return FALLBACK_DENSITY;
194 }
195 return density / 160.f;
196}
197
Peiyong Lin9d846a52018-11-05 13:18:20 -0800198// Currently we only support V0_SRGB and DISPLAY_P3 as composition preference.
199bool validateCompositionDataspace(Dataspace dataspace) {
200 return dataspace == Dataspace::V0_SRGB || dataspace == Dataspace::DISPLAY_P3;
201}
202
Steven Thomasd4071902020-03-24 16:02:53 -0700203class FrameRateFlexibilityToken : public BBinder {
204public:
205 FrameRateFlexibilityToken(std::function<void()> callback) : mCallback(callback) {}
206 virtual ~FrameRateFlexibilityToken() { mCallback(); }
207
208private:
209 std::function<void()> mCallback;
210};
211
Steven Thomasb02664d2017-07-26 18:48:28 -0700212} // namespace anonymous
213
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800214// ---------------------------------------------------------------------------
215
Mathias Agopian99b49842011-06-27 16:05:52 -0700216const String16 sHardwareTest("android.permission.HARDWARE_TEST");
217const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER");
218const String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER");
219const String16 sDump("android.permission.DUMP");
Ady Abrahama09852a2020-02-20 14:23:42 -0800220const char* KERNEL_IDLE_TIMER_PROP = "vendor.display.enable_kernel_idle_timer";
Mathias Agopian99b49842011-06-27 16:05:52 -0700221
222// ---------------------------------------------------------------------------
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700223int64_t SurfaceFlinger::dispSyncPresentTimeOffset;
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700224bool SurfaceFlinger::useHwcForRgbToYuv;
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800225uint64_t SurfaceFlinger::maxVirtualDisplaySize;
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800226bool SurfaceFlinger::hasSyncFramework;
Steven Thomas050b2c82017-03-06 11:45:16 -0800227bool SurfaceFlinger::useVrFlinger;
Fabien Sanglard1971b632017-03-10 14:50:03 -0800228int64_t SurfaceFlinger::maxFrameBufferAcquiredBuffers;
Brian Lindahla13f2d52020-03-05 11:54:17 +0100229uint32_t SurfaceFlinger::maxGraphicsWidth;
230uint32_t SurfaceFlinger::maxGraphicsHeight;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600231bool SurfaceFlinger::hasWideColorDisplay;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800232ui::Rotation SurfaceFlinger::internalDisplayOrientation = ui::ROTATION_0;
Peiyong Lin13effd12018-07-24 17:01:47 -0700233bool SurfaceFlinger::useColorManagement;
Peiyong Linb3839ad2018-09-05 15:37:19 -0700234bool SurfaceFlinger::useContextPriority;
Peiyong Linc6780972018-10-28 15:24:08 -0700235Dataspace SurfaceFlinger::defaultCompositionDataspace = Dataspace::V0_SRGB;
236ui::PixelFormat SurfaceFlinger::defaultCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
237Dataspace SurfaceFlinger::wideColorGamutCompositionDataspace = Dataspace::V0_SRGB;
238ui::PixelFormat SurfaceFlinger::wideColorGamutCompositionPixelFormat = ui::PixelFormat::RGBA_8888;
Ana Krulec3803b8d2020-02-03 16:35:46 -0800239bool SurfaceFlinger::useFrameRateApi;
Mathias Agopian99b49842011-06-27 16:05:52 -0700240
Kalle Raitaa099a242017-01-11 11:17:29 -0800241std::string getHwcServiceName() {
242 char value[PROPERTY_VALUE_MAX] = {};
243 property_get("debug.sf.hwc_service_name", value, "default");
244 ALOGI("Using HWComposer service: '%s'", value);
245 return std::string(value);
246}
247
248bool useTrebleTestingOverride() {
249 char value[PROPERTY_VALUE_MAX] = {};
250 property_get("debug.sf.treble_testing_override", value, "false");
251 ALOGI("Treble testing override: '%s'", value);
252 return std::string(value) == "true";
253}
254
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800255std::string decodeDisplayColorSetting(DisplayColorSetting displayColorSetting) {
256 switch(displayColorSetting) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800257 case DisplayColorSetting::kManaged:
Chia-I Wu0d711262018-05-21 15:19:35 -0700258 return std::string("Managed");
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800259 case DisplayColorSetting::kUnmanaged:
Chia-I Wu0d711262018-05-21 15:19:35 -0700260 return std::string("Unmanaged");
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800261 case DisplayColorSetting::kEnhanced:
Chia-I Wu0d711262018-05-21 15:19:35 -0700262 return std::string("Enhanced");
263 default:
264 return std::string("Unknown ") +
265 std::to_string(static_cast<int>(displayColorSetting));
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800266 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800267}
268
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700269SurfaceFlingerBE::SurfaceFlingerBE() : mHwcServiceName(getHwcServiceName()) {}
David Sodmanbc815282017-11-05 18:57:52 -0800270
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700271SurfaceFlinger::SurfaceFlinger(Factory& factory, SkipInitializationTag)
272 : mFactory(factory),
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700273 mInterceptor(mFactory.createSurfaceInterceptor(this)),
Yiwei Zhangf0229a72019-09-09 19:28:02 -0700274 mTimeStats(std::make_shared<impl::TimeStats>()),
Mikael Pessa90092f42019-08-26 17:22:04 -0700275 mFrameTracer(std::make_unique<FrameTracer>()),
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700276 mEventQueue(mFactory.createMessageQueue()),
Dominik Laskowskieddeda12019-07-19 11:54:13 -0700277 mCompositionEngine(mFactory.createCompositionEngine()),
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800278 mInternalDisplayDensity(getDensityFromProperty("ro.sf.lcd_density", true)),
279 mEmulatedDisplayDensity(getDensityFromProperty("qemu.sf.lcd_density", false)) {}
Lloyd Piqueac648ee2018-01-17 13:42:24 -0800280
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700281SurfaceFlinger::SurfaceFlinger(Factory& factory) : SurfaceFlinger(factory, SkipInitialization) {
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800282 ALOGI("SurfaceFlinger is starting");
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800283
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900284 hasSyncFramework = running_without_sync_framework(true);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800285
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900286 dispSyncPresentTimeOffset = present_time_offset_from_vsync_ns(0);
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700287
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900288 useHwcForRgbToYuv = force_hwc_copy_for_virtual_displays(false);
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700289
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900290 maxVirtualDisplaySize = max_virtual_display_dimension(0);
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800291
Steven Thomas050b2c82017-03-06 11:45:16 -0800292 // Vr flinger is only enabled on Daydream ready devices.
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900293 useVrFlinger = use_vr_flinger(false);
Steven Thomas050b2c82017-03-06 11:45:16 -0800294
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900295 maxFrameBufferAcquiredBuffers = max_frame_buffer_acquired_buffers(2);
Fabien Sanglard1971b632017-03-10 14:50:03 -0800296
Brian Lindahla13f2d52020-03-05 11:54:17 +0100297 maxGraphicsWidth = std::max(max_graphics_width(0), 0);
298 maxGraphicsHeight = std::max(max_graphics_height(0), 0);
299
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900300 hasWideColorDisplay = has_wide_color_display(false);
Peiyong Lin0256f722018-08-31 15:45:10 -0700301
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900302 useColorManagement = use_color_management(false);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600303
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900304 mDefaultCompositionDataspace =
305 static_cast<ui::Dataspace>(default_composition_dataspace(Dataspace::V0_SRGB));
Peiyong Lin8cabfc32019-06-14 14:25:43 -0700306 mWideColorGamutCompositionDataspace = static_cast<ui::Dataspace>(wcg_composition_dataspace(
307 hasWideColorDisplay ? Dataspace::DISPLAY_P3 : Dataspace::V0_SRGB));
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900308 defaultCompositionDataspace = mDefaultCompositionDataspace;
309 wideColorGamutCompositionDataspace = mWideColorGamutCompositionDataspace;
310 defaultCompositionPixelFormat = static_cast<ui::PixelFormat>(
311 default_composition_pixel_format(ui::PixelFormat::RGBA_8888));
312 wideColorGamutCompositionPixelFormat =
313 static_cast<ui::PixelFormat>(wcg_composition_pixel_format(ui::PixelFormat::RGBA_8888));
Peiyong Linb3839ad2018-09-05 15:37:19 -0700314
Yichi Chenda901bf2019-06-28 14:58:27 +0800315 mColorSpaceAgnosticDataspace =
316 static_cast<ui::Dataspace>(color_space_agnostic_dataspace(Dataspace::UNKNOWN));
317
Sundong Ahnd5e08f62018-12-12 20:27:28 +0900318 useContextPriority = use_context_priority(true);
Iris Chang7501ed62018-04-30 14:45:42 +0800319
Dominik Laskowski718f9602019-11-09 20:01:35 -0800320 using Values = SurfaceFlingerProperties::primary_display_orientation_values;
321 switch (primary_display_orientation(Values::ORIENTATION_0)) {
322 case Values::ORIENTATION_0:
Iris Chang7501ed62018-04-30 14:45:42 +0800323 break;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800324 case Values::ORIENTATION_90:
325 internalDisplayOrientation = ui::ROTATION_90;
Iris Chang7501ed62018-04-30 14:45:42 +0800326 break;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800327 case Values::ORIENTATION_180:
328 internalDisplayOrientation = ui::ROTATION_180;
Iris Chang7501ed62018-04-30 14:45:42 +0800329 break;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800330 case Values::ORIENTATION_270:
331 internalDisplayOrientation = ui::ROTATION_270;
Iris Chang7501ed62018-04-30 14:45:42 +0800332 break;
333 }
Dominik Laskowski718f9602019-11-09 20:01:35 -0800334 ALOGV("Internal Display Orientation: %s", toCString(internalDisplayOrientation));
Iris Chang7501ed62018-04-30 14:45:42 +0800335
Sundong Ahn85131bd2019-02-18 15:51:53 +0900336 mInternalDisplayPrimaries = sysprop::getDisplayNativePrimaries();
Daniel Solomon42d04562019-01-20 21:03:19 -0800337
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800338 // debugging stuff...
339 char value[PROPERTY_VALUE_MAX];
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700340
Mathias Agopianb4b17302013-03-20 18:36:41 -0700341 property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");
Mathias Agopian50210b92013-03-21 21:13:21 -0700342 mGpuToCpuSupported = !atoi(value);
Mathias Agopianb4b17302013-03-20 18:36:41 -0700343
Alec Mouri989ddbe2020-02-06 09:26:19 -0800344 property_get("ro.build.type", value, "user");
345 mIsUserBuild = strcmp(value, "user") == 0;
346
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800347 property_get("debug.sf.showupdates", value, "0");
348 mDebugRegion = atoi(value);
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700349
Mathias Agopianc1d359d2012-08-04 20:09:03 -0700350 ALOGI_IF(mDebugRegion, "showupdates enabled");
Orion Hodson34397da2019-02-04 09:36:10 +0000351
352 // DDMS debugging deprecated (b/120782499)
353 property_get("debug.sf.ddms", value, "0");
354 int debugDdms = atoi(value);
355 ALOGI_IF(debugDdms, "DDMS debugging not supported");
Dan Stozac5da2712016-07-20 15:38:12 -0700356
357 property_get("debug.sf.disable_backpressure", value, "0");
358 mPropagateBackpressure = !atoi(value);
359 ALOGI_IF(!mPropagateBackpressure, "Disabling backpressure propagation");
Dan Stoza8cf150a2016-08-02 10:27:31 -0700360
Ady Abrahamadb9a992019-09-19 21:21:55 +0000361 property_get("debug.sf.enable_gl_backpressure", value, "0");
362 mPropagateBackpressureClientComposition = atoi(value);
363 ALOGI_IF(mPropagateBackpressureClientComposition,
364 "Enabling backpressure propagation for Client Composition");
365
Fabien Sanglard642b23d2017-02-09 12:29:39 -0800366 property_get("debug.sf.enable_hwc_vds", value, "0");
367 mUseHwcVirtualDisplays = atoi(value);
Chia-I Wu11d10612018-06-21 15:41:13 +0800368 ALOGI_IF(mUseHwcVirtualDisplays, "Enabling HWC virtual displays");
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800369
Yiwei Zhangb770ed32018-12-17 17:44:28 -0800370 property_get("ro.sf.disable_triple_buffer", value, "0");
Fabien Sanglardc65dafa2017-02-07 14:06:39 -0800371 mLayerTripleBufferingDisabled = atoi(value);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800372 ALOGI_IF(mLayerTripleBufferingDisabled, "Disabling Triple Buffering");
Romain Guy3054f002017-06-05 18:38:53 -0700373
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800374 property_get("ro.surface_flinger.supports_background_blur", value, "0");
375 bool supportsBlurs = atoi(value);
Lucas Dupin00f16422020-03-11 11:33:04 -0700376 mSupportsBlur = supportsBlurs;
377 ALOGI_IF(!mSupportsBlur, "Disabling blur effects, they are not supported.");
Lucas Dupin2dd6f392020-02-18 17:43:36 -0800378 property_get("ro.sf.blurs_are_expensive", value, "0");
379 mBlursAreExpensive = atoi(value);
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800380
Ady Abraham0a525092020-03-03 12:51:24 -0800381 const size_t defaultListSize = ISurfaceComposer::MAX_LAYERS;
Dan Stoza0a0158c2018-03-16 13:38:54 -0700382 auto listSize = property_get_int32("debug.sf.max_igbp_list_size", int32_t(defaultListSize));
383 mMaxGraphicBufferProducerListSize = (listSize > 0) ? size_t(listSize) : defaultListSize;
384
Dan Stozaec460082018-12-17 15:35:09 -0800385 property_get("debug.sf.luma_sampling", value, "1");
386 mLumaSampling = atoi(value);
387
Vishnu Nairb2a999b2020-01-23 13:43:02 -0800388 property_get("debug.sf.disable_client_composition_cache", value, "0");
Vishnu Nair9b079a22020-01-21 14:36:08 -0800389 mDisableClientCompositionCache = atoi(value);
390
Romain Guy11d63f42017-07-20 12:47:14 -0700391 // We should be reading 'persist.sys.sf.color_saturation' here
392 // but since /data may be encrypted, we need to wait until after vold
393 // comes online to attempt to read the property. The property is
394 // instead read after the boot animation
Kalle Raitaa099a242017-01-11 11:17:29 -0800395
396 if (useTrebleTestingOverride()) {
397 // Without the override SurfaceFlinger cannot connect to HIDL
398 // services that are not listed in the manifests. Considered
399 // deriving the setting from the set service name, but it
400 // would be brittle if the name that's not 'default' is used
401 // for production purposes later on.
402 setenv("TREBLE_TESTING_OVERRIDE", "true", true);
403 }
Ana Krulec3803b8d2020-02-03 16:35:46 -0800404
405 useFrameRateApi = use_frame_rate_api(true);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800406}
407
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800408void SurfaceFlinger::onFirstRef()
409{
Lloyd Pique3fcdef12018-01-22 17:14:00 -0800410 mEventQueue->init(this);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800411}
412
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700413SurfaceFlinger::~SurfaceFlinger() = default;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800414
Dan Stozac7014012014-02-14 15:03:43 -0800415void SurfaceFlinger::binderDied(const wp<IBinder>& /* who */)
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800416{
417 // the window manager died on us. prepare its eulogy.
Rob Carr2aa78cb2020-03-10 14:27:49 -0700418 mBootFinished = false;
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800419
Andy McFadden13a082e2012-08-24 10:16:42 -0700420 // restore initial conditions (default device unblank, etc)
421 initializeDisplays();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800422
423 // restart the boot-animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700424 startBootAnim();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800425}
426
Robert Carr1db73f62016-12-21 12:58:51 -0800427static sp<ISurfaceComposerClient> initClient(const sp<Client>& client) {
Mathias Agopian96f08192010-06-02 23:28:45 -0700428 status_t err = client->initCheck();
429 if (err == NO_ERROR) {
Robert Carr1db73f62016-12-21 12:58:51 -0800430 return client;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800431 }
Robert Carr1db73f62016-12-21 12:58:51 -0800432 return nullptr;
433}
434
435sp<ISurfaceComposerClient> SurfaceFlinger::createConnection() {
436 return initClient(new Client(this));
437}
438
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700439sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName,
440 bool secure)
Mathias Agopiane57f2922012-08-09 16:29:12 -0700441{
442 class DisplayToken : public BBinder {
443 sp<SurfaceFlinger> flinger;
444 virtual ~DisplayToken() {
445 // no more references, this display must be terminated
446 Mutex::Autolock _l(flinger->mStateLock);
447 flinger->mCurrentState.displays.removeItem(this);
448 flinger->setTransactionFlags(eDisplayTransactionNeeded);
449 }
450 public:
Chih-Hung Hsiehc4067912016-05-03 14:03:27 -0700451 explicit DisplayToken(const sp<SurfaceFlinger>& flinger)
Mathias Agopiane57f2922012-08-09 16:29:12 -0700452 : flinger(flinger) {
453 }
454 };
455
456 sp<BBinder> token = new DisplayToken(this);
457
458 Mutex::Autolock _l(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700459 // Display ID is assigned when virtual display is allocated by HWC.
460 DisplayDeviceState state;
461 state.isSecure = secure;
462 state.displayName = displayName;
463 mCurrentState.displays.add(token, state);
464 mInterceptor->saveDisplayCreation(state);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700465 return token;
466}
467
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700468void SurfaceFlinger::destroyDisplay(const sp<IBinder>& displayToken) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700469 Mutex::Autolock lock(mStateLock);
Jesse Hall6c913be2013-08-08 12:15:49 -0700470
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700471 const ssize_t index = mCurrentState.displays.indexOfKey(displayToken);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700472 if (index < 0) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700473 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
Jesse Hall6c913be2013-08-08 12:15:49 -0700474 return;
475 }
476
Dominik Laskowski075d3172018-05-24 15:50:06 -0700477 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700478 if (state.physical) {
479 ALOGE("%s: Invalid operation on physical display", __FUNCTION__);
Jesse Hall6c913be2013-08-08 12:15:49 -0700480 return;
481 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700482 mInterceptor->saveDisplayDeletion(state.sequenceId);
483 mCurrentState.displays.removeItemsAt(index);
Jesse Hall6c913be2013-08-08 12:15:49 -0700484 setTransactionFlags(eDisplayTransactionNeeded);
485}
486
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800487std::vector<PhysicalDisplayId> SurfaceFlinger::getPhysicalDisplayIds() const {
488 Mutex::Autolock lock(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700489
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800490 const auto internalDisplayId = getInternalDisplayIdLocked();
491 if (!internalDisplayId) {
492 return {};
Dominik Laskowski075d3172018-05-24 15:50:06 -0700493 }
494
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800495 std::vector<PhysicalDisplayId> displayIds;
496 displayIds.reserve(mPhysicalDisplayTokens.size());
497 displayIds.push_back(internalDisplayId->value);
498
499 for (const auto& [id, token] : mPhysicalDisplayTokens) {
500 if (id != *internalDisplayId) {
501 displayIds.push_back(id.value);
502 }
Mathias Agopiane57f2922012-08-09 16:29:12 -0700503 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700504
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800505 return displayIds;
506}
507
508sp<IBinder> SurfaceFlinger::getPhysicalDisplayToken(PhysicalDisplayId displayId) const {
509 Mutex::Autolock lock(mStateLock);
510 return getPhysicalDisplayTokenLocked(DisplayId{displayId});
Mathias Agopiane57f2922012-08-09 16:29:12 -0700511}
512
Ady Abraham37965d42018-11-01 13:43:32 -0700513status_t SurfaceFlinger::getColorManagement(bool* outGetColorManagement) const {
514 if (!outGetColorManagement) {
515 return BAD_VALUE;
516 }
517 *outGetColorManagement = useColorManagement;
518 return NO_ERROR;
Ady Abraham2a6ab2a2018-10-26 14:25:30 -0700519}
520
Lloyd Pique441d5042018-10-18 16:49:51 -0700521HWComposer& SurfaceFlinger::getHwComposer() const {
522 return mCompositionEngine->getHwComposer();
523}
524
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700525renderengine::RenderEngine& SurfaceFlinger::getRenderEngine() const {
526 return mCompositionEngine->getRenderEngine();
527}
528
Lloyd Pique70d91362018-10-18 16:02:55 -0700529compositionengine::CompositionEngine& SurfaceFlinger::getCompositionEngine() const {
530 return *mCompositionEngine.get();
531}
532
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800533void SurfaceFlinger::bootFinished()
534{
Rob Carr2aa78cb2020-03-10 14:27:49 -0700535 if (mBootFinished == true) {
536 ALOGE("Extra call to bootFinished");
537 return;
538 }
539 mBootFinished = true;
Wei Wangf9b05ee2017-07-19 20:59:39 -0700540 if (mStartPropertySetThread->join() != NO_ERROR) {
541 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800542 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800543 const nsecs_t now = systemTime();
544 const nsecs_t duration = now - mBootTime;
Steve Blocka19954a2012-01-04 20:05:49 +0000545 ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700546
Mikael Pessa90092f42019-08-26 17:22:04 -0700547 mFrameTracer->initialize();
Alec Mouri8e2f31b2020-01-16 22:04:35 +0000548 mTimeStats->onBootFinished();
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700549
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700550 // wait patiently for the window manager death
551 const String16 name("window");
Steven Morelanda904bb92019-07-02 17:37:23 -0700552 mWindowManager = defaultServiceManager()->getService(name);
553 if (mWindowManager != 0) {
554 mWindowManager->linkToDeath(static_cast<IBinder::DeathRecipient*>(this));
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700555 }
Robert Carr720e5062018-07-30 17:45:14 -0700556 sp<IBinder> input(defaultServiceManager()->getService(
557 String16("inputflinger")));
558 if (input == nullptr) {
559 ALOGE("Failed to link to input service");
560 } else {
561 mInputFlinger = interface_cast<IInputFlinger>(input);
562 }
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700563
Steven Thomas050b2c82017-03-06 11:45:16 -0800564 if (mVrFlinger) {
565 mVrFlinger->OnBootFinished();
566 }
567
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700568 // stop boot animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700569 // formerly we would just kill the process, but we now ask it to exit so it
570 // can choose where to stop the animation.
571 property_set("service.bootanim.exit", "1");
Yusuke Sato0a688f52015-07-30 23:05:39 -0700572
573 const int LOGTAG_SF_STOP_BOOTANIM = 60110;
574 LOG_EVENT_LONG(LOGTAG_SF_STOP_BOOTANIM,
575 ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
Romain Guy11d63f42017-07-20 12:47:14 -0700576
Ana Krulecbd6654b2019-02-15 15:18:15 -0800577 postMessageAsync(new LambdaMessage([this]() NO_THREAD_SAFETY_ANALYSIS {
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800578 readPersistentProperties();
Dan Stoza29e7bdf2020-03-23 14:43:09 -0700579 mPowerAdvisor.onBootFinished();
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800580 mBootStage = BootStage::FINISHED;
Ana Krulecbd6654b2019-02-15 15:18:15 -0800581
Ady Abraham8a82ba62020-01-17 12:43:17 -0800582 if (property_get_bool("sf.debug.show_refresh_rate_overlay", false)) {
583 mRefreshRateOverlay = std::make_unique<RefreshRateOverlay>(*this);
584 mRefreshRateOverlay->changeRefreshRate(mRefreshRateConfigs->getCurrentRefreshRate());
585 }
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800586 }));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800587}
588
Dan Stoza436ccf32018-06-21 12:10:12 -0700589uint32_t SurfaceFlinger::getNewTexture() {
590 {
591 std::lock_guard lock(mTexturePoolMutex);
592 if (!mTexturePool.empty()) {
593 uint32_t name = mTexturePool.back();
594 mTexturePool.pop_back();
595 ATRACE_INT("TexturePoolSize", mTexturePool.size());
596 return name;
597 }
598
599 // The pool was too small, so increase it for the future
600 ++mTexturePoolSize;
601 }
602
603 // The pool was empty, so we need to get a new texture name directly using a
604 // blocking call to the main thread
605 uint32_t name = 0;
606 postMessageSync(new LambdaMessage([&]() { getRenderEngine().genTextures(1, &name); }));
607 return name;
608}
609
Mathias Agopian3f844832013-08-07 21:24:32 -0700610void SurfaceFlinger::deleteTextureAsync(uint32_t texture) {
Dan Stoza67765d82019-05-07 14:58:27 -0700611 std::lock_guard lock(mTexturePoolMutex);
612 // We don't change the pool size, so the fix-up logic in postComposition will decide whether
613 // to actually delete this or not based on mTexturePoolSize
614 mTexturePool.push_back(texture);
615 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700616}
617
Wei Wangf9b05ee2017-07-19 20:59:39 -0700618// Do not call property_set on main thread which will be blocked by init
619// Use StartPropertySetThread instead.
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700620void SurfaceFlinger::init() {
Mathias Agopiana4912602012-07-12 14:25:33 -0700621 ALOGI( "SurfaceFlinger's main thread ready to run. "
622 "Initializing graphics H/W...");
Steven Thomasb02664d2017-07-26 18:48:28 -0700623 Mutex::Autolock _l(mStateLock);
Kevin DuBois413287f2019-02-25 08:46:47 -0800624
Steven Thomasb02664d2017-07-26 18:48:28 -0700625 // Get a RenderEngine for the given display / config (can't fail)
Peiyong Lin0256f722018-08-31 15:45:10 -0700626 // TODO(b/77156734): We need to stop casting and use HAL types when possible.
Alec Mourida4cf3b2019-02-12 15:33:01 -0800627 // Sending maxFrameBufferAcquiredBuffers as the cache size is tightly tuned to single-display.
Peiyong Lin4137a1d72019-10-09 10:39:09 -0700628 mCompositionEngine->setRenderEngine(renderengine::RenderEngine::create(
629 renderengine::RenderEngineCreationArgs::Builder()
630 .setPixelFormat(static_cast<int32_t>(defaultCompositionPixelFormat))
631 .setImageCacheSize(maxFrameBufferAcquiredBuffers)
632 .setUseColorManagerment(useColorManagement)
633 .setEnableProtectedContext(enable_protected_contents(false))
634 .setPrecacheToneMapperShaderOnly(false)
Lucas Dupin00f16422020-03-11 11:33:04 -0700635 .setSupportsBackgroundBlur(mSupportsBlur)
Peiyong Lin4137a1d72019-10-09 10:39:09 -0700636 .setContextPriority(useContextPriority
637 ? renderengine::RenderEngine::ContextPriority::HIGH
638 : renderengine::RenderEngine::ContextPriority::MEDIUM)
639 .build()));
Alec Mourie4034bb2019-11-19 12:45:54 -0800640 mCompositionEngine->setTimeStats(mTimeStats);
Steven Thomasb02664d2017-07-26 18:48:28 -0700641
642 LOG_ALWAYS_FATAL_IF(mVrFlingerRequestsDisplay,
643 "Starting with vr flinger active is not currently supported.");
Lloyd Pique441d5042018-10-18 16:49:51 -0700644 mCompositionEngine->setHwComposer(getFactory().createHWComposer(getBE().mHwcServiceName));
Lloyd Pique4603f3c2020-02-11 12:06:56 -0800645 mCompositionEngine->getHwComposer().setConfiguration(this, getBE().mComposerSequenceId);
Lloyd Piqueba04e622017-12-14 17:11:26 -0800646 // Process any initial hotplug and resulting display changes.
647 processDisplayHotplugEventsLocked();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700648 const auto display = getDefaultDisplayDeviceLocked();
649 LOG_ALWAYS_FATAL_IF(!display, "Missing internal display after registering composer callback.");
Dominik Laskowski075d3172018-05-24 15:50:06 -0700650 LOG_ALWAYS_FATAL_IF(!getHwComposer().isConnected(*display->getId()),
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700651 "Internal display is disconnected.");
Jesse Hall692c7232012-11-08 15:41:56 -0800652
Steven Thomas050b2c82017-03-06 11:45:16 -0800653 if (useVrFlinger) {
Dominik Laskowski8c001672018-05-30 16:52:06 -0700654 auto vrFlingerRequestDisplayCallback = [this](bool requestDisplay) {
Steven Thomasbe6cbae2017-09-28 15:30:23 -0700655 // This callback is called from the vr flinger dispatch thread. We
656 // need to call signalTransaction(), which requires holding
657 // mStateLock when we're not on the main thread. Acquiring
658 // mStateLock from the vr flinger dispatch thread might trigger a
659 // deadlock in surface flinger (see b/66916578), so post a message
660 // to be handled on the main thread instead.
Dominik Laskowski8c001672018-05-30 16:52:06 -0700661 postMessageAsync(new LambdaMessage([=] {
Steven Thomasbe6cbae2017-09-28 15:30:23 -0700662 ALOGI("VR request display mode: requestDisplay=%d", requestDisplay);
663 mVrFlingerRequestsDisplay = requestDisplay;
664 signalTransaction();
Dominik Laskowski8c001672018-05-30 16:52:06 -0700665 }));
Steven Thomas050b2c82017-03-06 11:45:16 -0800666 };
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700667 mVrFlinger = dvr::VrFlinger::Create(getHwComposer().getComposer(),
668 getHwComposer()
Dominik Laskowski075d3172018-05-24 15:50:06 -0700669 .fromPhysicalDisplayId(*display->getId())
Dominik Laskowski45de9bd2018-06-11 17:44:10 -0700670 .value_or(0),
671 vrFlingerRequestDisplayCallback);
Steven Thomas050b2c82017-03-06 11:45:16 -0800672 if (!mVrFlinger) {
673 ALOGE("Failed to start vrflinger");
674 }
675 }
676
Mathias Agopian92a979a2012-08-02 18:32:23 -0700677 // initialize our drawing state
678 mDrawingState = mCurrentState;
Mathias Agopian86303202012-07-24 22:46:10 -0700679
Andy McFadden13a082e2012-08-24 10:16:42 -0700680 // set initial conditions (e.g. unblank default device)
681 initializeDisplays();
682
Steven Thomas137d4bc2019-07-25 16:55:14 -0700683 char primeShaderCache[PROPERTY_VALUE_MAX];
684 property_get("service.sf.prime_shader_cache", primeShaderCache, "1");
685 if (atoi(primeShaderCache)) {
686 getRenderEngine().primeCache();
687 }
Dan Stoza4e637772016-07-28 13:31:51 -0700688
Wei Wangf9b05ee2017-07-19 20:59:39 -0700689 // Inform native graphics APIs whether the present timestamp is supported:
Lloyd Pique90c115d2018-09-18 21:39:42 -0700690
691 const bool presentFenceReliable =
692 !getHwComposer().hasCapability(HWC2::Capability::PresentFenceIsNotReliable);
693 mStartPropertySetThread = getFactory().createStartPropertySetThread(presentFenceReliable);
Wei Wangf9b05ee2017-07-19 20:59:39 -0700694
695 if (mStartPropertySetThread->Start() != NO_ERROR) {
696 ALOGE("Run StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800697 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800698
Dan Stoza9e56aa02015-11-02 13:00:03 -0800699 ALOGV("Done initializing");
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700700}
701
Romain Guy11d63f42017-07-20 12:47:14 -0700702void SurfaceFlinger::readPersistentProperties() {
Chia-I Wu28f320b2018-05-03 11:02:56 -0700703 Mutex::Autolock _l(mStateLock);
704
Romain Guy11d63f42017-07-20 12:47:14 -0700705 char value[PROPERTY_VALUE_MAX];
706
707 property_get("persist.sys.sf.color_saturation", value, "1.0");
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800708 mGlobalSaturationFactor = atof(value);
Chia-I Wu28f320b2018-05-03 11:02:56 -0700709 updateColorMatrixLocked();
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800710 ALOGV("Saturation is set to %.2f", mGlobalSaturationFactor);
Romain Guy54f154a2017-10-24 21:40:32 +0100711
712 property_get("persist.sys.sf.native_mode", value, "0");
Chia-I Wu0d711262018-05-21 15:19:35 -0700713 mDisplayColorSetting = static_cast<DisplayColorSetting>(atoi(value));
Peiyong Lina3ea5592019-02-10 14:45:00 -0800714
715 property_get("persist.sys.sf.color_mode", value, "0");
716 mForceColorMode = static_cast<ColorMode>(atoi(value));
Lucas Dupin00f16422020-03-11 11:33:04 -0700717
718 property_get("persist.sys.sf.disable_blurs", value, "0");
719 bool disableBlurs = atoi(value);
720 mDisableBlurs = disableBlurs;
721 ALOGI_IF(disableBlurs, "Disabling blur effects, user preference.");
Romain Guy11d63f42017-07-20 12:47:14 -0700722}
723
Mathias Agopiana67e4182012-06-19 17:26:12 -0700724void SurfaceFlinger::startBootAnim() {
Wei Wangb254fa32017-01-31 17:43:23 -0800725 // Start boot animation service by setting a property mailbox
726 // if property setting thread is already running, Start() will be just a NOP
Wei Wangf9b05ee2017-07-19 20:59:39 -0700727 mStartPropertySetThread->Start();
Wei Wangb254fa32017-01-31 17:43:23 -0800728 // Wait until property was set
Wei Wangf9b05ee2017-07-19 20:59:39 -0700729 if (mStartPropertySetThread->join() != NO_ERROR) {
730 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800731 }
Mathias Agopiana67e4182012-06-19 17:26:12 -0700732}
733
Mathias Agopian875d8e12013-06-07 15:35:48 -0700734size_t SurfaceFlinger::getMaxTextureSize() const {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700735 return getRenderEngine().getMaxTextureSize();
Mathias Agopiana4912602012-07-12 14:25:33 -0700736}
737
Mathias Agopian875d8e12013-06-07 15:35:48 -0700738size_t SurfaceFlinger::getMaxViewportDims() const {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700739 return getRenderEngine().getMaxViewportDims();
Mathias Agopiana4912602012-07-12 14:25:33 -0700740}
741
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800742// ----------------------------------------------------------------------------
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800743
Jamie Gennis582270d2011-08-17 18:19:00 -0700744bool SurfaceFlinger::authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800745 const sp<IGraphicBufferProducer>& bufferProducer) const {
Jamie Gennis134f0422011-03-08 12:18:54 -0800746 Mutex::Autolock _l(mStateLock);
Robert Carr0d480722017-01-10 16:42:54 -0800747 return authenticateSurfaceTextureLocked(bufferProducer);
748}
749
750bool SurfaceFlinger::authenticateSurfaceTextureLocked(
751 const sp<IGraphicBufferProducer>& bufferProducer) const {
Marco Nelissen097ca272014-11-14 08:01:01 -0800752 sp<IBinder> surfaceTextureBinder(IInterface::asBinder(bufferProducer));
Dan Stoza101d8dc2018-02-27 15:42:25 -0800753 return mGraphicBufferProducerList.count(surfaceTextureBinder.get()) > 0;
Jamie Gennis134f0422011-03-08 12:18:54 -0800754}
755
Brian Anderson6b376712017-04-04 10:51:39 -0700756status_t SurfaceFlinger::getSupportedFrameTimestamps(
757 std::vector<FrameEvent>* outSupported) const {
758 *outSupported = {
759 FrameEvent::REQUESTED_PRESENT,
760 FrameEvent::ACQUIRE,
761 FrameEvent::LATCH,
762 FrameEvent::FIRST_REFRESH_START,
763 FrameEvent::LAST_REFRESH_START,
764 FrameEvent::GPU_COMPOSITION_DONE,
765 FrameEvent::DEQUEUE_READY,
766 FrameEvent::RELEASE,
767 };
Steven Thomas6d8110b2017-08-31 18:24:21 -0700768 ConditionalLock _l(mStateLock,
769 std::this_thread::get_id() != mMainThreadId);
Brian Anderson6b376712017-04-04 10:51:39 -0700770 if (!getHwComposer().hasCapability(
771 HWC2::Capability::PresentFenceIsNotReliable)) {
772 outSupported->push_back(FrameEvent::DISPLAY_PRESENT);
773 }
774 return NO_ERROR;
775}
776
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800777status_t SurfaceFlinger::getDisplayState(const sp<IBinder>& displayToken, ui::DisplayState* state) {
778 if (!displayToken || !state) {
779 return BAD_VALUE;
780 }
781
782 Mutex::Autolock lock(mStateLock);
783
784 const auto display = getDisplayDeviceLocked(displayToken);
785 if (!display) {
786 return NAME_NOT_FOUND;
787 }
788
789 state->layerStack = display->getLayerStack();
790 state->orientation = display->getOrientation();
791
792 const Rect viewport = display->getViewport();
793 state->viewport = viewport.isValid() ? viewport.getSize() : display->getSize();
794
795 return NO_ERROR;
796}
797
798status_t SurfaceFlinger::getDisplayInfo(const sp<IBinder>& displayToken, DisplayInfo* info) {
799 if (!displayToken || !info) {
800 return BAD_VALUE;
801 }
802
803 Mutex::Autolock lock(mStateLock);
804
805 const auto display = getDisplayDeviceLocked(displayToken);
806 if (!display) {
807 return NAME_NOT_FOUND;
808 }
809
Dominik Laskowski55c85402020-01-21 16:25:47 -0800810 if (const auto connectionType = display->getConnectionType())
811 info->connectionType = *connectionType;
812 else {
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800813 return INVALID_OPERATION;
814 }
815
816 if (mEmulatedDisplayDensity) {
817 info->density = mEmulatedDisplayDensity;
818 } else {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800819 info->density = info->connectionType == DisplayConnectionType::Internal
820 ? mInternalDisplayDensity
821 : FALLBACK_DENSITY;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800822 }
823
824 info->secure = display->isSecure();
Marin Shalamanovf5de90d2019-10-08 10:57:25 +0200825 info->deviceProductInfo = getDeviceProductInfoLocked(*display);
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800826
827 return NO_ERROR;
828}
829
Dominik Laskowski22488f62019-03-28 09:53:04 -0700830status_t SurfaceFlinger::getDisplayConfigs(const sp<IBinder>& displayToken,
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800831 Vector<DisplayConfig>* configs) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700832 if (!displayToken || !configs) {
Dan Stoza7f7da322014-05-02 15:26:25 -0700833 return BAD_VALUE;
834 }
835
Dominik Laskowski22488f62019-03-28 09:53:04 -0700836 Mutex::Autolock lock(mStateLock);
837
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800838 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700839 if (!displayId) {
840 return NAME_NOT_FOUND;
Mathias Agopianc666cae2012-07-25 18:56:13 -0700841 }
Mathias Agopian8b736f12012-08-13 17:54:26 -0700842
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800843 const bool isInternal = (displayId == getInternalDisplayIdLocked());
Mathias Agopian1604f772012-09-18 21:54:42 -0700844
Dan Stoza7f7da322014-05-02 15:26:25 -0700845 configs->clear();
Mathias Agopian1604f772012-09-18 21:54:42 -0700846
Dominik Laskowski075d3172018-05-24 15:50:06 -0700847 for (const auto& hwConfig : getHwComposer().getConfigs(*displayId)) {
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800848 DisplayConfig config;
Dan Stoza7f7da322014-05-02 15:26:25 -0700849
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800850 auto width = hwConfig->getWidth();
851 auto height = hwConfig->getHeight();
Dan Stoza7f7da322014-05-02 15:26:25 -0700852
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800853 auto xDpi = hwConfig->getDpiX();
854 auto yDpi = hwConfig->getDpiY();
Yiwei Zhang27de5df2018-08-23 17:04:51 -0700855
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800856 if (isInternal &&
857 (internalDisplayOrientation == ui::ROTATION_90 ||
858 internalDisplayOrientation == ui::ROTATION_270)) {
859 std::swap(width, height);
860 std::swap(xDpi, yDpi);
Dan Stoza7f7da322014-05-02 15:26:25 -0700861 }
862
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800863 config.resolution = ui::Size(width, height);
Ady Abraham2139f732019-11-13 18:56:40 -0800864
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800865 if (mEmulatedDisplayDensity) {
866 config.xDpi = mEmulatedDisplayDensity;
867 config.yDpi = mEmulatedDisplayDensity;
868 } else {
869 config.xDpi = xDpi;
870 config.yDpi = yDpi;
871 }
872
873 const nsecs_t period = hwConfig->getVsyncPeriod();
874 config.refreshRate = 1e9f / period;
875
876 const auto offsets = mPhaseConfiguration->getOffsetsForRefreshRate(config.refreshRate);
877 config.appVsyncOffset = offsets.late.app;
878 config.sfVsyncOffset = offsets.late.sf;
Ady Abrahamff731d82020-02-18 17:22:46 -0800879 config.configGroup = hwConfig->getConfigGroup();
Dan Stoza9e56aa02015-11-02 13:00:03 -0800880
Andy McFadden91b2ca82014-06-13 14:04:23 -0700881 // This is how far in advance a buffer must be queued for
882 // presentation at a given time. If you want a buffer to appear
883 // on the screen at time N, you must submit the buffer before
884 // (N - presentationDeadline).
885 //
886 // Normally it's one full refresh period (to give SF a chance to
887 // latch the buffer), but this can be reduced by configuring a
888 // DispSync offset. Any additional delays introduced by the hardware
889 // composer or panel must be accounted for here.
890 //
891 // We add an additional 1ms to allow for processing time and
892 // differences between the ideal and actual refresh rate.
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800893 config.presentationDeadline = period - config.sfVsyncOffset + 1000000;
Dan Stoza7f7da322014-05-02 15:26:25 -0700894
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800895 configs->push_back(config);
Mathias Agopian8b736f12012-08-13 17:54:26 -0700896 }
897
Dan Stoza7f7da322014-05-02 15:26:25 -0700898 return NO_ERROR;
899}
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700900
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700901status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>&, DisplayStatInfo* stats) {
902 if (!stats) {
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700903 return BAD_VALUE;
904 }
905
Ana Krulecc2870422019-01-29 19:00:58 -0800906 mScheduler->getDisplayStatInfo(stats);
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700907 return NO_ERROR;
908}
909
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700910int SurfaceFlinger::getActiveConfig(const sp<IBinder>& displayToken) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700911 int activeConfig;
912 bool isPrimary;
913
914 {
915 Mutex::Autolock lock(mStateLock);
916
917 if (const auto display = getDisplayDeviceLocked(displayToken)) {
918 activeConfig = display->getActiveConfig().value();
919 isPrimary = display->isPrimary();
920 } else {
921 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
922 return NAME_NOT_FOUND;
923 }
Jinguang Dong9f8b9ae2016-11-29 13:55:57 +0800924 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700925
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700926 if (isPrimary) {
Steven Thomasc9098452019-09-30 17:15:05 -0700927 std::lock_guard<std::mutex> lock(mActiveConfigLock);
928 if (mDesiredActiveConfigChanged) {
Ady Abraham2139f732019-11-13 18:56:40 -0800929 return mDesiredActiveConfig.configId.value();
Steven Thomasc9098452019-09-30 17:15:05 -0700930 }
Steven Thomasc9098452019-09-30 17:15:05 -0700931 }
Ady Abraham2139f732019-11-13 18:56:40 -0800932
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700933 return activeConfig;
Dan Stoza7f7da322014-05-02 15:26:25 -0700934}
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700935
Ady Abraham03b02dd2019-03-21 15:40:11 -0700936void SurfaceFlinger::setDesiredActiveConfig(const ActiveConfigInfo& info) {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800937 ATRACE_CALL();
Ady Abraham2e1dd892020-03-05 13:48:36 -0800938 auto& refreshRate = mRefreshRateConfigs->getRefreshRateFromConfigId(info.configId);
Ady Abrahamabc27602020-04-08 17:20:29 -0700939 ALOGV("setDesiredActiveConfig(%s)", refreshRate.getName().c_str());
Ana Krulec7d1d6832018-12-27 11:10:09 -0800940
Ady Abrahamb838aed2019-02-12 15:30:16 -0800941 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Ady Abraham59db0a32020-03-02 18:04:20 -0800942 if (mDesiredActiveConfigChanged) {
943 // If a config change is pending, just cache the latest request in
944 // mDesiredActiveConfig
945 const Scheduler::ConfigEvent prevConfig = mDesiredActiveConfig.event;
946 mDesiredActiveConfig = info;
947 mDesiredActiveConfig.event = mDesiredActiveConfig.event | prevConfig;
948 } else {
949 // Check is we are already at the desired config
950 const auto display = getDefaultDisplayDeviceLocked();
Ady Abrahamabc27602020-04-08 17:20:29 -0700951 if (!display || display->getActiveConfig() == refreshRate.getConfigId()) {
Ady Abraham59db0a32020-03-02 18:04:20 -0800952 return;
953 }
Ady Abrahamb838aed2019-02-12 15:30:16 -0800954
Ady Abraham59db0a32020-03-02 18:04:20 -0800955 // Initiate a config change.
956 mDesiredActiveConfigChanged = true;
957 mDesiredActiveConfig = info;
958
Ady Abrahamb838aed2019-02-12 15:30:16 -0800959 // This will trigger HWC refresh without resetting the idle timer.
960 repaintEverythingForHWC();
Alec Mouri754c98a2019-03-18 18:53:42 -0700961 // Start receiving vsync samples now, so that we can detect a period
962 // switch.
Ady Abrahamabc27602020-04-08 17:20:29 -0700963 mScheduler->resyncToHardwareVsync(true, refreshRate.getVsyncPeriod());
Ady Abraham53852a52019-05-28 18:07:44 -0700964 // As we called to set period, we will call to onRefreshRateChangeCompleted once
965 // DispSync model is locked.
Dominik Laskowskieddeda12019-07-19 11:54:13 -0700966 mVSyncModulator->onRefreshRateChangeInitiated();
Ady Abraham2139f732019-11-13 18:56:40 -0800967
Ady Abrahamabc27602020-04-08 17:20:29 -0700968 mPhaseConfiguration->setRefreshRateFps(refreshRate.getFps());
Ady Abraham9e16a482019-12-03 17:19:41 -0800969 mVSyncModulator->setPhaseOffsets(mPhaseConfiguration->getCurrentOffsets());
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800970 }
Ady Abraham03b02dd2019-03-21 15:40:11 -0700971
972 if (mRefreshRateOverlay) {
Ady Abraham2139f732019-11-13 18:56:40 -0800973 mRefreshRateOverlay->changeRefreshRate(refreshRate);
Ady Abraham03b02dd2019-03-21 15:40:11 -0700974 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800975}
976
977status_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& displayToken, int mode) {
978 ATRACE_CALL();
Ady Abraham838de062019-02-04 10:24:03 -0800979
Ana Kruleced3a8cc2019-11-14 00:55:07 +0100980 if (!displayToken) {
981 return BAD_VALUE;
982 }
Ady Abraham838de062019-02-04 10:24:03 -0800983
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700984 status_t result = NAME_NOT_FOUND;
Ana Kruleced3a8cc2019-11-14 00:55:07 +0100985
986 postMessageSync(new LambdaMessage([&]() {
987 const auto display = getDisplayDeviceLocked(displayToken);
988 if (!display) {
989 ALOGE("Attempt to set allowed display configs for invalid display token %p",
990 displayToken.get());
Ana Kruleced3a8cc2019-11-14 00:55:07 +0100991 } else if (display->isVirtual()) {
992 ALOGW("Attempt to set allowed display configs for virtual display");
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700993 result = INVALID_OPERATION;
Ana Kruleced3a8cc2019-11-14 00:55:07 +0100994 } else {
995 HwcConfigIndexType config(mode);
996 const auto& refreshRate = mRefreshRateConfigs->getRefreshRateFromConfigId(config);
Steven Thomasd4071902020-03-24 16:02:53 -0700997 result = setDesiredDisplayConfigSpecsInternal(display,
998 scheduler::RefreshRateConfigs::
Ady Abrahamabc27602020-04-08 17:20:29 -0700999 Policy{config,
1000 refreshRate.getFps(),
1001 refreshRate.getFps()},
Steven Thomasd4071902020-03-24 16:02:53 -07001002 /*overridePolicy=*/false);
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001003 }
1004 }));
1005
1006 return result;
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001007}
1008
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001009void SurfaceFlinger::setActiveConfigInternal() {
1010 ATRACE_CALL();
1011
Dominik Laskowski22488f62019-03-28 09:53:04 -07001012 const auto display = getDefaultDisplayDeviceLocked();
1013 if (!display) {
1014 return;
1015 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001016
Alec Mouri8de697e2020-03-19 10:52:01 -07001017 auto& oldRefreshRate =
1018 mRefreshRateConfigs->getRefreshRateFromConfigId(display->getActiveConfig());
1019
Dominik Laskowski22488f62019-03-28 09:53:04 -07001020 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Ady Abraham2139f732019-11-13 18:56:40 -08001021 mRefreshRateConfigs->setCurrentConfigId(mUpcomingActiveConfig.configId);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07001022 mRefreshRateStats->setConfigMode(mUpcomingActiveConfig.configId);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001023 display->setActiveConfig(mUpcomingActiveConfig.configId);
1024
Ady Abraham2e1dd892020-03-05 13:48:36 -08001025 auto& refreshRate =
Ady Abraham2139f732019-11-13 18:56:40 -08001026 mRefreshRateConfigs->getRefreshRateFromConfigId(mUpcomingActiveConfig.configId);
Ady Abrahamabc27602020-04-08 17:20:29 -07001027 if (refreshRate.getVsyncPeriod() != oldRefreshRate.getVsyncPeriod()) {
Alec Mouri8de697e2020-03-19 10:52:01 -07001028 mTimeStats->incrementRefreshRateSwitches();
1029 }
Ady Abrahamabc27602020-04-08 17:20:29 -07001030 mPhaseConfiguration->setRefreshRateFps(refreshRate.getFps());
Ady Abraham9e16a482019-12-03 17:19:41 -08001031 mVSyncModulator->setPhaseOffsets(mPhaseConfiguration->getCurrentOffsets());
Ady Abrahamabc27602020-04-08 17:20:29 -07001032 ATRACE_INT("ActiveConfigFPS", refreshRate.getFps());
Dominik Laskowski22488f62019-03-28 09:53:04 -07001033
Ana Krulec8d3e4f32019-03-05 10:40:33 -08001034 if (mUpcomingActiveConfig.event != Scheduler::ConfigEvent::None) {
Alec Mouri60aee1c2019-10-28 16:18:59 -07001035 const nsecs_t vsyncPeriod =
1036 mRefreshRateConfigs->getRefreshRateFromConfigId(mUpcomingActiveConfig.configId)
Ady Abrahamabc27602020-04-08 17:20:29 -07001037 .getVsyncPeriod();
Ady Abraham447052e2019-02-13 16:07:27 -08001038 mScheduler->onConfigChanged(mAppConnectionHandle, display->getId()->value,
Alec Mouri60aee1c2019-10-28 16:18:59 -07001039 mUpcomingActiveConfig.configId, vsyncPeriod);
Ady Abraham447052e2019-02-13 16:07:27 -08001040 }
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001041}
1042
Ady Abraham53852a52019-05-28 18:07:44 -07001043void SurfaceFlinger::desiredActiveConfigChangeDone() {
1044 std::lock_guard<std::mutex> lock(mActiveConfigLock);
1045 mDesiredActiveConfig.event = Scheduler::ConfigEvent::None;
1046 mDesiredActiveConfigChanged = false;
Ady Abraham53852a52019-05-28 18:07:44 -07001047
Ady Abraham2e1dd892020-03-05 13:48:36 -08001048 const auto& refreshRate =
Ady Abraham2139f732019-11-13 18:56:40 -08001049 mRefreshRateConfigs->getRefreshRateFromConfigId(mDesiredActiveConfig.configId);
Ady Abrahamabc27602020-04-08 17:20:29 -07001050 mScheduler->resyncToHardwareVsync(true, refreshRate.getVsyncPeriod());
1051 mPhaseConfiguration->setRefreshRateFps(refreshRate.getFps());
Ady Abraham9e16a482019-12-03 17:19:41 -08001052 mVSyncModulator->setPhaseOffsets(mPhaseConfiguration->getCurrentOffsets());
Ady Abraham53852a52019-05-28 18:07:44 -07001053}
1054
Ady Abraham27cbed72020-04-10 12:56:59 -07001055void SurfaceFlinger::performSetActiveConfig() {
Alec Mourife3dc942019-02-12 14:19:18 -08001056 ATRACE_CALL();
Ady Abraham2139f732019-11-13 18:56:40 -08001057 ALOGV("performSetActiveConfig");
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001058 // Store the local variable to release the lock.
Ady Abraham27cbed72020-04-10 12:56:59 -07001059 const auto desiredActiveConfig = [&]() -> std::optional<ActiveConfigInfo> {
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001060 std::lock_guard<std::mutex> lock(mActiveConfigLock);
Ady Abraham27cbed72020-04-10 12:56:59 -07001061 if (mDesiredActiveConfigChanged) {
1062 return mDesiredActiveConfig;
Ady Abrahamb838aed2019-02-12 15:30:16 -08001063 }
Ady Abraham27cbed72020-04-10 12:56:59 -07001064 return std::nullopt;
1065 }();
1066
1067 if (!desiredActiveConfig) {
1068 // No desired active config pending to be applied
1069 return;
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001070 }
1071
Ady Abraham2e1dd892020-03-05 13:48:36 -08001072 auto& refreshRate =
Ady Abraham27cbed72020-04-10 12:56:59 -07001073 mRefreshRateConfigs->getRefreshRateFromConfigId(desiredActiveConfig->configId);
Ady Abrahamabc27602020-04-08 17:20:29 -07001074 ALOGV("performSetActiveConfig changing active config to %d(%s)",
1075 refreshRate.getConfigId().value(), refreshRate.getName().c_str());
Dominik Laskowski22488f62019-03-28 09:53:04 -07001076 const auto display = getDefaultDisplayDeviceLocked();
Ady Abraham27cbed72020-04-10 12:56:59 -07001077 if (!display || display->getActiveConfig() == desiredActiveConfig->configId) {
Ady Abrahamb838aed2019-02-12 15:30:16 -08001078 // display is not valid or we are already in the requested mode
1079 // on both cases there is nothing left to do
Ady Abraham53852a52019-05-28 18:07:44 -07001080 desiredActiveConfigChangeDone();
Ady Abraham27cbed72020-04-10 12:56:59 -07001081 return;
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001082 }
Ady Abrahamb838aed2019-02-12 15:30:16 -08001083
Ady Abraham838de062019-02-04 10:24:03 -08001084 // Desired active config was set, it is different than the config currently in use, however
1085 // allowed configs might have change by the time we process the refresh.
1086 // Make sure the desired config is still allowed
Ady Abraham27cbed72020-04-10 12:56:59 -07001087 if (!isDisplayConfigAllowed(desiredActiveConfig->configId)) {
Ady Abraham53852a52019-05-28 18:07:44 -07001088 desiredActiveConfigChangeDone();
Ady Abraham27cbed72020-04-10 12:56:59 -07001089 return;
Ady Abraham838de062019-02-04 10:24:03 -08001090 }
Alec Mouri7f015182019-07-11 13:56:22 -07001091
Ady Abraham27cbed72020-04-10 12:56:59 -07001092 mUpcomingActiveConfig = *desiredActiveConfig;
Ady Abrahamb838aed2019-02-12 15:30:16 -08001093 const auto displayId = display->getId();
1094 LOG_ALWAYS_FATAL_IF(!displayId);
1095
Ady Abrahamabc27602020-04-08 17:20:29 -07001096 ATRACE_INT("ActiveConfigFPS_HWC", refreshRate.getFps());
Ady Abrahamb838aed2019-02-12 15:30:16 -08001097
Ady Abraham3a77a7b2019-12-02 18:46:59 -08001098 // TODO(b/142753666) use constrains
1099 HWC2::VsyncPeriodChangeConstraints constraints;
1100 constraints.desiredTimeNanos = systemTime();
1101 constraints.seamlessRequired = false;
1102
1103 HWC2::VsyncPeriodChangeTimeline outTimeline;
1104 auto status =
1105 getHwComposer().setActiveConfigWithConstraints(*displayId,
1106 mUpcomingActiveConfig.configId.value(),
1107 constraints, &outTimeline);
1108 if (status != NO_ERROR) {
Ady Abraham5e95aa22020-03-04 10:26:05 -08001109 // setActiveConfigWithConstraints may fail if a hotplug event is just about
1110 // to be sent. We just log the error in this case.
1111 ALOGW("setActiveConfigWithConstraints failed: %d", status);
Ady Abraham27cbed72020-04-10 12:56:59 -07001112 return;
Ady Abraham3a77a7b2019-12-02 18:46:59 -08001113 }
1114
1115 mScheduler->onNewVsyncPeriodChangeTimeline(outTimeline);
1116 // Scheduler will submit an empty frame to HWC if needed.
Ady Abraham27cbed72020-04-10 12:56:59 -07001117 mSetActiveConfigPending = true;
Mathias Agopianc666cae2012-07-25 18:56:13 -07001118}
Dominik Laskowski075d3172018-05-24 15:50:06 -07001119
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001120status_t SurfaceFlinger::getDisplayColorModes(const sp<IBinder>& displayToken,
1121 Vector<ColorMode>* outColorModes) {
1122 if (!displayToken || !outColorModes) {
Michael Wright28f24d02016-07-12 13:30:53 -07001123 return BAD_VALUE;
1124 }
1125
Peiyong Lina52f0292018-03-14 17:26:31 -07001126 std::vector<ColorMode> modes;
Peiyong Linff84a152019-05-17 18:36:19 -07001127 bool isInternalDisplay = false;
Steven Thomas6d8110b2017-08-31 18:24:21 -07001128 {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001129 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
1130
1131 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1132 if (!displayId) {
1133 return NAME_NOT_FOUND;
1134 }
1135
Dominik Laskowski075d3172018-05-24 15:50:06 -07001136 modes = getHwComposer().getColorModes(*displayId);
Peiyong Linff84a152019-05-17 18:36:19 -07001137 isInternalDisplay = displayId == getInternalDisplayIdLocked();
Steven Thomas6d8110b2017-08-31 18:24:21 -07001138 }
Michael Wright28f24d02016-07-12 13:30:53 -07001139 outColorModes->clear();
Peiyong Linff84a152019-05-17 18:36:19 -07001140
1141 // If it's built-in display and the configuration claims it's not wide color capable,
1142 // filter out all wide color modes. The typical reason why this happens is that the
1143 // hardware is not good enough to support GPU composition of wide color, and thus the
1144 // OEMs choose to disable this capability.
1145 if (isInternalDisplay && !hasWideColorDisplay) {
1146 std::remove_copy_if(modes.cbegin(), modes.cend(), std::back_inserter(*outColorModes),
1147 isWideColorMode);
1148 } else {
1149 std::copy(modes.cbegin(), modes.cend(), std::back_inserter(*outColorModes));
1150 }
Michael Wright28f24d02016-07-12 13:30:53 -07001151
1152 return NO_ERROR;
1153}
1154
Daniel Solomon42d04562019-01-20 21:03:19 -08001155status_t SurfaceFlinger::getDisplayNativePrimaries(const sp<IBinder>& displayToken,
1156 ui::DisplayPrimaries &primaries) {
1157 if (!displayToken) {
1158 return BAD_VALUE;
1159 }
1160
1161 // Currently we only support this API for a single internal display.
1162 if (getInternalDisplayToken() != displayToken) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001163 return NAME_NOT_FOUND;
Daniel Solomon42d04562019-01-20 21:03:19 -08001164 }
1165
1166 memcpy(&primaries, &mInternalDisplayPrimaries, sizeof(ui::DisplayPrimaries));
1167 return NO_ERROR;
1168}
1169
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001170ColorMode SurfaceFlinger::getActiveColorMode(const sp<IBinder>& displayToken) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001171 Mutex::Autolock lock(mStateLock);
1172
1173 if (const auto display = getDisplayDeviceLocked(displayToken)) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07001174 return display->getCompositionDisplay()->getState().colorMode;
Michael Wright28f24d02016-07-12 13:30:53 -07001175 }
Peiyong Lina52f0292018-03-14 17:26:31 -07001176 return static_cast<ColorMode>(BAD_VALUE);
Michael Wright28f24d02016-07-12 13:30:53 -07001177}
1178
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001179status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& displayToken, ColorMode mode) {
Dominik Laskowski8c001672018-05-30 16:52:06 -07001180 postMessageSync(new LambdaMessage([&] {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001181 Vector<ColorMode> modes;
1182 getDisplayColorModes(displayToken, &modes);
1183 bool exists = std::find(std::begin(modes), std::end(modes), mode) != std::end(modes);
1184 if (mode < ColorMode::NATIVE || !exists) {
1185 ALOGE("Attempt to set invalid active color mode %s (%d) for display token %p",
1186 decodeColorMode(mode).c_str(), mode, displayToken.get());
1187 return;
Michael Wright28f24d02016-07-12 13:30:53 -07001188 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001189 const auto display = getDisplayDeviceLocked(displayToken);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001190 if (!display) {
1191 ALOGE("Attempt to set active color mode %s (%d) for invalid display token %p",
1192 decodeColorMode(mode).c_str(), mode, displayToken.get());
1193 } else if (display->isVirtual()) {
1194 ALOGW("Attempt to set active color mode %s (%d) for virtual display",
1195 decodeColorMode(mode).c_str(), mode);
1196 } else {
Lloyd Pique6a3b4462019-03-07 20:58:12 -08001197 display->getCompositionDisplay()->setColorProfile(
1198 compositionengine::Output::ColorProfile{mode, Dataspace::UNKNOWN,
1199 RenderIntent::COLORIMETRIC,
1200 Dataspace::UNKNOWN});
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001201 }
1202 }));
1203
Michael Wright28f24d02016-07-12 13:30:53 -07001204 return NO_ERROR;
1205}
Mathias Agopianc666cae2012-07-25 18:56:13 -07001206
Galia Peycheva5492cb52019-10-30 14:13:16 +01001207status_t SurfaceFlinger::getAutoLowLatencyModeSupport(const sp<IBinder>& displayToken,
1208 bool* outSupport) const {
Galia Peycheva5492cb52019-10-30 14:13:16 +01001209 if (!displayToken) {
Galia Peycheva5492cb52019-10-30 14:13:16 +01001210 return BAD_VALUE;
1211 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001212
1213 Mutex::Autolock lock(mStateLock);
1214
Galia Peycheva5492cb52019-10-30 14:13:16 +01001215 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1216 if (!displayId) {
Galia Peycheva5492cb52019-10-30 14:13:16 +01001217 return NAME_NOT_FOUND;
1218 }
Dominik Laskowski1162e472020-04-02 19:02:47 -07001219 *outSupport = getHwComposer().hasDisplayCapability(*displayId,
Galia Peycheva5492cb52019-10-30 14:13:16 +01001220 HWC2::DisplayCapability::AutoLowLatencyMode);
1221 return NO_ERROR;
1222}
1223
1224void SurfaceFlinger::setAutoLowLatencyMode(const sp<IBinder>& displayToken, bool on) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001225 postMessageAsync(new LambdaMessage([=] {
1226 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
1227 getHwComposer().setAutoLowLatencyMode(*displayId, on);
1228 } else {
1229 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
1230 }
1231 }));
Galia Peycheva5492cb52019-10-30 14:13:16 +01001232}
1233
1234status_t SurfaceFlinger::getGameContentTypeSupport(const sp<IBinder>& displayToken,
1235 bool* outSupport) const {
Galia Peycheva5492cb52019-10-30 14:13:16 +01001236 if (!displayToken) {
Galia Peycheva5492cb52019-10-30 14:13:16 +01001237 return BAD_VALUE;
1238 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001239
1240 Mutex::Autolock lock(mStateLock);
1241
Galia Peycheva5492cb52019-10-30 14:13:16 +01001242 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1243 if (!displayId) {
Galia Peycheva5492cb52019-10-30 14:13:16 +01001244 return NAME_NOT_FOUND;
1245 }
1246
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001247 std::vector<HWC2::ContentType> types;
1248 getHwComposer().getSupportedContentTypes(*displayId, &types);
1249
1250 *outSupport = std::any_of(types.begin(), types.end(),
1251 [](auto type) { return type == HWC2::ContentType::Game; });
Galia Peycheva5492cb52019-10-30 14:13:16 +01001252 return NO_ERROR;
1253}
1254
1255void SurfaceFlinger::setGameContentType(const sp<IBinder>& displayToken, bool on) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001256 postMessageAsync(new LambdaMessage([=] {
1257 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
1258 const auto type = on ? HWC2::ContentType::Game : HWC2::ContentType::None;
1259 getHwComposer().setContentType(*displayId, type);
1260 } else {
1261 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
1262 }
1263 }));
Galia Peycheva5492cb52019-10-30 14:13:16 +01001264}
1265
Svetoslavd85084b2014-03-20 10:28:31 -07001266status_t SurfaceFlinger::clearAnimationFrameStats() {
1267 Mutex::Autolock _l(mStateLock);
1268 mAnimFrameTracker.clearStats();
1269 return NO_ERROR;
1270}
1271
1272status_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const {
1273 Mutex::Autolock _l(mStateLock);
1274 mAnimFrameTracker.getStats(outStats);
1275 return NO_ERROR;
1276}
1277
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001278status_t SurfaceFlinger::getHdrCapabilities(const sp<IBinder>& displayToken,
1279 HdrCapabilities* outCapabilities) const {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001280 Mutex::Autolock lock(mStateLock);
Dan Stozac4f471e2016-03-24 09:31:08 -07001281
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001282 const auto display = getDisplayDeviceLocked(displayToken);
1283 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001284 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
1285 return NAME_NOT_FOUND;
Dan Stozac4f471e2016-03-24 09:31:08 -07001286 }
1287
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001288 // At this point the DisplayDevice should already be set up,
Peiyong Linfb069302018-04-25 14:34:31 -07001289 // meaning the luminance information is already queried from
1290 // hardware composer and stored properly.
Dominik Laskowskieecd6592018-05-29 10:25:41 -07001291 const HdrCapabilities& capabilities = display->getHdrCapabilities();
Peiyong Linfb069302018-04-25 14:34:31 -07001292 *outCapabilities = HdrCapabilities(capabilities.getSupportedHdrTypes(),
1293 capabilities.getDesiredMaxLuminance(),
1294 capabilities.getDesiredMaxAverageLuminance(),
1295 capabilities.getDesiredMinLuminance());
Dan Stozac4f471e2016-03-24 09:31:08 -07001296
1297 return NO_ERROR;
1298}
1299
Marin Shalamanovf5de90d2019-10-08 10:57:25 +02001300std::optional<DeviceProductInfo> SurfaceFlinger::getDeviceProductInfoLocked(
1301 const DisplayDevice& display) const {
1302 // TODO(b/149075047): Populate DeviceProductInfo on hotplug and store it in DisplayDevice to
1303 // avoid repetitive HAL IPC and EDID parsing.
1304 const auto displayId = display.getId();
1305 LOG_FATAL_IF(!displayId);
1306
1307 const auto hwcDisplayId = getHwComposer().fromPhysicalDisplayId(*displayId);
1308 LOG_FATAL_IF(!hwcDisplayId);
1309
1310 uint8_t port;
1311 DisplayIdentificationData data;
1312 if (!getHwComposer().getDisplayIdentificationData(*hwcDisplayId, &port, &data)) {
1313 ALOGV("%s: No identification data.", __FUNCTION__);
1314 return {};
1315 }
1316
1317 const auto info = parseDisplayIdentificationData(port, data);
1318 if (!info) {
1319 return {};
1320 }
1321 return info->deviceProductInfo;
1322}
1323
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001324status_t SurfaceFlinger::getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
1325 ui::PixelFormat* outFormat,
1326 ui::Dataspace* outDataspace,
1327 uint8_t* outComponentMask) const {
1328 if (!outFormat || !outDataspace || !outComponentMask) {
1329 return BAD_VALUE;
1330 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001331
1332 Mutex::Autolock lock(mStateLock);
1333
1334 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1335 if (!displayId) {
1336 return NAME_NOT_FOUND;
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001337 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001338
1339 return getHwComposer().getDisplayedContentSamplingAttributes(*displayId, outFormat,
Kevin DuBois9c0a1762018-10-16 13:32:31 -07001340 outDataspace, outComponentMask);
1341}
1342
Kevin DuBois74e53772018-11-19 10:52:38 -08001343status_t SurfaceFlinger::setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken,
1344 bool enable, uint8_t componentMask,
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001345 uint64_t maxFrames) {
1346 status_t result = NAME_NOT_FOUND;
Kevin DuBois74e53772018-11-19 10:52:38 -08001347
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001348 postMessageSync(new LambdaMessage([&] {
1349 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
1350 result = getHwComposer().setDisplayContentSamplingEnabled(*displayId, enable,
1351 componentMask, maxFrames);
1352 } else {
1353 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
1354 }
1355 }));
1356
1357 return result;
Kevin DuBois74e53772018-11-19 10:52:38 -08001358}
1359
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001360status_t SurfaceFlinger::getDisplayedContentSample(const sp<IBinder>& displayToken,
1361 uint64_t maxFrames, uint64_t timestamp,
1362 DisplayedFrameStats* outStats) const {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001363 Mutex::Autolock lock(mStateLock);
1364
1365 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1366 if (!displayId) {
1367 return NAME_NOT_FOUND;
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001368 }
1369
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001370 return getHwComposer().getDisplayedContentSample(*displayId, maxFrames, timestamp, outStats);
Kevin DuBois1d4249a2018-08-29 10:45:14 -07001371}
1372
Peiyong Lin3c2791e2019-01-14 17:05:18 -08001373status_t SurfaceFlinger::getProtectedContentSupport(bool* outSupported) const {
1374 if (!outSupported) {
1375 return BAD_VALUE;
1376 }
1377 *outSupported = getRenderEngine().supportsProtectedContent();
1378 return NO_ERROR;
1379}
1380
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001381status_t SurfaceFlinger::isWideColorDisplay(const sp<IBinder>& displayToken,
1382 bool* outIsWideColorDisplay) const {
1383 if (!displayToken || !outIsWideColorDisplay) {
1384 return BAD_VALUE;
1385 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001386
1387 Mutex::Autolock lock(mStateLock);
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001388 const auto display = getDisplayDeviceLocked(displayToken);
1389 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001390 return NAME_NOT_FOUND;
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001391 }
Peiyong Linff84a152019-05-17 18:36:19 -07001392
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001393 *outIsWideColorDisplay =
1394 display->isPrimary() ? hasWideColorDisplay : display->hasWideColorGamut();
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08001395 return NO_ERROR;
1396}
1397
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001398status_t SurfaceFlinger::enableVSyncInjections(bool enable) {
Dominik Laskowski8c001672018-05-30 16:52:06 -07001399 postMessageSync(new LambdaMessage([&] {
Dominik Laskowski6505f792019-09-18 11:10:05 -07001400 Mutex::Autolock lock(mStateLock);
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001401
Dominik Laskowski6505f792019-09-18 11:10:05 -07001402 if (const auto handle = mScheduler->enableVSyncInjection(enable)) {
1403 mEventQueue->setEventConnection(
1404 mScheduler->getEventConnection(enable ? handle : mSfConnectionHandle));
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001405 }
Dominik Laskowski8c001672018-05-30 16:52:06 -07001406 }));
1407
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001408 return NO_ERROR;
1409}
1410
1411status_t SurfaceFlinger::injectVSync(nsecs_t when) {
Dominik Laskowski6505f792019-09-18 11:10:05 -07001412 Mutex::Autolock lock(mStateLock);
1413 return mScheduler->injectVSync(when) ? NO_ERROR : BAD_VALUE;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -07001414}
1415
Lloyd Pique755e3192018-01-31 16:46:15 -08001416status_t SurfaceFlinger::getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const
1417 NO_THREAD_SAFETY_ANALYSIS {
Kalle Raitaa099a242017-01-11 11:17:29 -08001418 // Try to acquire a lock for 1s, fail gracefully
1419 const status_t err = mStateLock.timedLock(s2ns(1));
1420 const bool locked = (err == NO_ERROR);
1421 if (!locked) {
1422 ALOGE("LayerDebugInfo: SurfaceFlinger unresponsive (%s [%d]) - exit", strerror(-err), err);
1423 return TIMED_OUT;
1424 }
1425
1426 outLayers->clear();
1427 mCurrentState.traverseInZOrder([&](Layer* layer) {
1428 outLayers->push_back(layer->getLayerDebugInfo());
1429 });
1430
1431 mStateLock.unlock();
1432 return NO_ERROR;
1433}
1434
Peiyong Linc6780972018-10-28 15:24:08 -07001435status_t SurfaceFlinger::getCompositionPreference(
1436 Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
1437 Dataspace* outWideColorGamutDataspace,
1438 ui::PixelFormat* outWideColorGamutPixelFormat) const {
Peiyong Lin9d846a52018-11-05 13:18:20 -08001439 *outDataspace = mDefaultCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001440 *outPixelFormat = defaultCompositionPixelFormat;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001441 *outWideColorGamutDataspace = mWideColorGamutCompositionDataspace;
Peiyong Linc6780972018-10-28 15:24:08 -07001442 *outWideColorGamutPixelFormat = wideColorGamutCompositionPixelFormat;
Peiyong Lin0256f722018-08-31 15:45:10 -07001443 return NO_ERROR;
1444}
1445
Dan Stozaec460082018-12-17 15:35:09 -08001446status_t SurfaceFlinger::addRegionSamplingListener(const Rect& samplingArea,
1447 const sp<IBinder>& stopLayerHandle,
1448 const sp<IRegionSamplingListener>& listener) {
tangrobinaf45f012019-02-26 18:10:10 +08001449 if (!listener || samplingArea == Rect::INVALID_RECT) {
Dan Stozaec460082018-12-17 15:35:09 -08001450 return BAD_VALUE;
1451 }
1452 mRegionSamplingThread->addListener(samplingArea, stopLayerHandle, listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001453 return NO_ERROR;
1454}
1455
Dan Stozaec460082018-12-17 15:35:09 -08001456status_t SurfaceFlinger::removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) {
tangrobinaf45f012019-02-26 18:10:10 +08001457 if (!listener) {
1458 return BAD_VALUE;
1459 }
Dan Stozaec460082018-12-17 15:35:09 -08001460 mRegionSamplingThread->removeListener(listener);
Dan Stoza84ab9372018-12-17 15:27:57 -08001461 return NO_ERROR;
1462}
Dan Gittik57e63c52019-01-18 16:37:54 +00001463
1464status_t SurfaceFlinger::getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
1465 bool* outSupport) const {
1466 if (!displayToken || !outSupport) {
1467 return BAD_VALUE;
1468 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001469
1470 Mutex::Autolock lock(mStateLock);
1471
Dan Gittik57e63c52019-01-18 16:37:54 +00001472 const auto displayId = getPhysicalDisplayIdLocked(displayToken);
1473 if (!displayId) {
1474 return NAME_NOT_FOUND;
1475 }
1476 *outSupport =
Dominik Laskowski1162e472020-04-02 19:02:47 -07001477 getHwComposer().hasDisplayCapability(*displayId, HWC2::DisplayCapability::Brightness);
Dan Gittik57e63c52019-01-18 16:37:54 +00001478 return NO_ERROR;
1479}
1480
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001481status_t SurfaceFlinger::setDisplayBrightness(const sp<IBinder>& displayToken, float brightness) {
Dan Gittik57e63c52019-01-18 16:37:54 +00001482 if (!displayToken) {
1483 return BAD_VALUE;
1484 }
Dominik Laskowski470df5f2020-04-02 22:27:42 -07001485
1486 status_t result = NAME_NOT_FOUND;
1487
1488 postMessageSync(new LambdaMessage([&] {
1489 if (const auto displayId = getPhysicalDisplayIdLocked(displayToken)) {
1490 result = getHwComposer().setDisplayBrightness(*displayId, brightness);
1491 } else {
1492 ALOGE("%s: Invalid display token %p", __FUNCTION__, displayToken.get());
1493 }
1494 }));
1495
1496 return result;
Dan Gittik57e63c52019-01-18 16:37:54 +00001497}
1498
Ady Abraham8532d012019-05-08 14:50:56 -07001499status_t SurfaceFlinger::notifyPowerHint(int32_t hintId) {
1500 PowerHint powerHint = static_cast<PowerHint>(hintId);
1501
1502 if (powerHint == PowerHint::INTERACTION) {
1503 mScheduler->notifyTouchEvent();
1504 }
1505
1506 return NO_ERROR;
1507}
1508
Mathias Agopiand0566bc2011-11-17 17:49:17 -08001509// ----------------------------------------------------------------------------
1510
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -07001511sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection(
Ady Abraham0f4a1b12019-06-04 16:04:04 -07001512 ISurfaceComposer::VsyncSource vsyncSource, ISurfaceComposer::ConfigChanged configChanged) {
Ana Krulecc2870422019-01-29 19:00:58 -08001513 const auto& handle =
1514 vsyncSource == eVsyncSourceSurfaceFlinger ? mSfConnectionHandle : mAppConnectionHandle;
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001515
Steven Thomas2bbaabe2019-08-28 16:08:35 -07001516 return mScheduler->createDisplayEventConnection(handle, configChanged);
Mathias Agopianbb641242010-05-18 17:06:55 -07001517}
1518
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001519// ----------------------------------------------------------------------------
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001520
1521void SurfaceFlinger::waitForEvent() {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001522 mEventQueue->waitMessage();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001523}
1524
1525void SurfaceFlinger::signalTransaction() {
Ady Abraham8532d012019-05-08 14:50:56 -07001526 mScheduler->resetIdleTimer();
Dan Stoza030fbc12020-02-19 15:32:01 -08001527 mPowerAdvisor.notifyDisplayUpdateImminent();
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001528 mEventQueue->invalidate();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001529}
1530
1531void SurfaceFlinger::signalLayerUpdate() {
Ady Abraham8532d012019-05-08 14:50:56 -07001532 mScheduler->resetIdleTimer();
Dan Stoza030fbc12020-02-19 15:32:01 -08001533 mPowerAdvisor.notifyDisplayUpdateImminent();
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001534 mEventQueue->invalidate();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001535}
1536
1537void SurfaceFlinger::signalRefresh() {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07001538 mRefreshPending = true;
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001539 mEventQueue->refresh();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001540}
1541
1542status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,
Dan Stozac7014012014-02-14 15:03:43 -08001543 nsecs_t reltime, uint32_t /* flags */) {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001544 return mEventQueue->postMessage(msg, reltime);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001545}
1546
1547status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
Dan Stozac7014012014-02-14 15:03:43 -08001548 nsecs_t reltime, uint32_t /* flags */) {
Lloyd Pique3fcdef12018-01-22 17:14:00 -08001549 status_t res = mEventQueue->postMessage(msg, reltime);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001550 if (res == NO_ERROR) {
1551 msg->wait();
1552 }
1553 return res;
1554}
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001555
Mathias Agopian4f4f0942013-08-19 17:26:18 -07001556void SurfaceFlinger::run() {
Mathias Agopian4f4f0942013-08-19 17:26:18 -07001557 do {
1558 waitForEvent();
1559 } while (true);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001560}
1561
Dominik Laskowski83b88212018-12-11 13:34:06 -08001562nsecs_t SurfaceFlinger::getVsyncPeriod() const {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001563 const auto displayId = getInternalDisplayIdLocked();
Dominik Laskowski83b88212018-12-11 13:34:06 -08001564 if (!displayId || !getHwComposer().isConnected(*displayId)) {
1565 return 0;
1566 }
1567
Ady Abraham3a77a7b2019-12-02 18:46:59 -08001568 return getHwComposer().getDisplayVsyncPeriod(*displayId);
Dominik Laskowski83b88212018-12-11 13:34:06 -08001569}
1570
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001571void SurfaceFlinger::onVsyncReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId,
Ady Abraham7159f572019-10-11 11:10:18 -07001572 int64_t timestamp,
Ady Abraham5dee2f12020-02-05 17:49:47 -08001573 std::optional<hwc2_vsync_period_t> vsyncPeriod) {
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001574 ATRACE_NAME("SF onVsync");
1575
Steven Thomas3cfac282017-02-06 12:29:30 -08001576 Mutex::Autolock lock(mStateLock);
Steven Thomasb02664d2017-07-26 18:48:28 -07001577 // Ignore any vsyncs from a previous hardware composer.
David Sodman105b7dc2017-11-04 20:28:14 -07001578 if (sequenceId != getBE().mComposerSequenceId) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001579 return;
1580 }
1581
Dominik Laskowski075d3172018-05-24 15:50:06 -07001582 if (!getHwComposer().onVsync(hwcDisplayId, timestamp)) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001583 return;
1584 }
1585
Dominik Laskowski075d3172018-05-24 15:50:06 -07001586 if (hwcDisplayId != getHwComposer().getInternalHwcDisplayId()) {
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001587 // For now, we don't do anything with external display vsyncs.
1588 return;
1589 }
1590
Alec Mourif8e689c2019-05-20 18:32:22 -07001591 bool periodFlushed = false;
Ady Abraham5dee2f12020-02-05 17:49:47 -08001592 mScheduler->addResyncSample(timestamp, vsyncPeriod, &periodFlushed);
Alec Mourif8e689c2019-05-20 18:32:22 -07001593 if (periodFlushed) {
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001594 mVSyncModulator->onRefreshRateChangeCompleted();
Alec Mouri754c98a2019-03-18 18:53:42 -07001595 }
Mathias Agopian148994e2012-09-19 17:31:36 -07001596}
1597
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001598void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
David Sodman99974d22017-11-28 12:04:33 -08001599 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
1600 *compositorTiming = getBE().mCompositorTiming;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001601}
1602
Ady Abraham2139f732019-11-13 18:56:40 -08001603bool SurfaceFlinger::isDisplayConfigAllowed(HwcConfigIndexType configId) const {
Ana Kruleced3a8cc2019-11-14 00:55:07 +01001604 return mRefreshRateConfigs->isConfigAllowed(configId);
Ady Abraham838de062019-02-04 10:24:03 -08001605}
1606
Ady Abraham2139f732019-11-13 18:56:40 -08001607void SurfaceFlinger::changeRefreshRateLocked(const RefreshRate& refreshRate,
1608 Scheduler::ConfigEvent event) {
Dominik Laskowski22488f62019-03-28 09:53:04 -07001609 const auto display = getDefaultDisplayDeviceLocked();
1610 if (!display || mBootStage != BootStage::FINISHED) {
Ana Krulec7d1d6832018-12-27 11:10:09 -08001611 return;
1612 }
Alec Mouri1c9e82b2019-03-07 12:24:05 -08001613 ATRACE_CALL();
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08001614
Ana Krulec7d1d6832018-12-27 11:10:09 -08001615 // Don't do any updating if the current fps is the same as the new one.
Ady Abrahamabc27602020-04-08 17:20:29 -07001616 if (!isDisplayConfigAllowed(refreshRate.getConfigId())) {
Ady Abraham2139f732019-11-13 18:56:40 -08001617 ALOGV("Skipping config %d as it is not part of allowed configs",
Ady Abrahamabc27602020-04-08 17:20:29 -07001618 refreshRate.getConfigId().value());
Ady Abraham1902d072019-03-01 17:18:59 -08001619 return;
1620 }
1621
Ady Abrahamabc27602020-04-08 17:20:29 -07001622 setDesiredActiveConfig({refreshRate.getConfigId(), event});
Ana Krulec7d1d6832018-12-27 11:10:09 -08001623}
1624
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001625void SurfaceFlinger::onHotplugReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId,
Lloyd Pique715a2c12017-12-14 17:18:08 -08001626 HWC2::Connection connection) {
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001627 ALOGV("%s(%d, %" PRIu64 ", %s)", __FUNCTION__, sequenceId, hwcDisplayId,
Lloyd Pique715a2c12017-12-14 17:18:08 -08001628 connection == HWC2::Connection::Connected ? "connected" : "disconnected");
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001629
Lloyd Piqueba04e622017-12-14 17:11:26 -08001630 // Ignore events that do not have the right sequenceId.
1631 if (sequenceId != getBE().mComposerSequenceId) {
1632 return;
1633 }
1634
Steven Thomasb02664d2017-07-26 18:48:28 -07001635 // Only lock if we're not on the main thread. This function is normally
1636 // called on a hwbinder thread, but for the primary display it's called on
1637 // the main thread with the state lock already held, so don't attempt to
1638 // acquire it here.
Lloyd Piqueba04e622017-12-14 17:11:26 -08001639 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
Steven Thomasb02664d2017-07-26 18:48:28 -07001640
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001641 mPendingHotplugEvents.emplace_back(HotplugEvent{hwcDisplayId, connection});
Mathias Agopian9e2463e2012-09-21 18:26:16 -07001642
Jiwen 'Steve' Caiccfd6822018-02-21 16:15:58 -08001643 if (std::this_thread::get_id() == mMainThreadId) {
1644 // Process all pending hot plug events immediately if we are on the main thread.
1645 processDisplayHotplugEventsLocked();
1646 }
1647
Lloyd Piqueba04e622017-12-14 17:11:26 -08001648 setTransactionFlags(eDisplayTransactionNeeded);
Mathias Agopian86303202012-07-24 22:46:10 -07001649}
1650
Ady Abraham7159f572019-10-11 11:10:18 -07001651void SurfaceFlinger::onVsyncPeriodTimingChangedReceived(
Ady Abraham3a77a7b2019-12-02 18:46:59 -08001652 int32_t sequenceId, hwc2_display_t /*display*/,
1653 const hwc_vsync_period_change_timeline_t& updatedTimeline) {
1654 Mutex::Autolock lock(mStateLock);
1655 if (sequenceId != getBE().mComposerSequenceId) {
1656 return;
1657 }
1658 mScheduler->onNewVsyncPeriodChangeTimeline(updatedTimeline);
Ady Abraham7159f572019-10-11 11:10:18 -07001659}
1660
Ady Abrahamb0433bc2020-01-08 17:31:06 -08001661void SurfaceFlinger::onSeamlessPossible(int32_t /*sequenceId*/, hwc2_display_t /*display*/) {
1662 // TODO(b/142753666): use constraints when calling to setActiveConfigWithConstrains and
1663 // use this callback to know when to retry in case of SEAMLESS_NOT_POSSIBLE.
1664}
1665
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001666void SurfaceFlinger::onRefreshReceived(int sequenceId, hwc2_display_t /*hwcDisplayId*/) {
Steven Thomas3cfac282017-02-06 12:29:30 -08001667 Mutex::Autolock lock(mStateLock);
David Sodman105b7dc2017-11-04 20:28:14 -07001668 if (sequenceId != getBE().mComposerSequenceId) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001669 return;
Steven Thomas3cfac282017-02-06 12:29:30 -08001670 }
Ana Krulec7d1d6832018-12-27 11:10:09 -08001671 repaintEverythingForHWC();
Steven Thomas3cfac282017-02-06 12:29:30 -08001672}
1673
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001674void SurfaceFlinger::setPrimaryVsyncEnabled(bool enabled) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001675 ATRACE_CALL();
Ady Abraham9ba25122019-06-03 17:10:55 -07001676
1677 // Enable / Disable HWVsync from the main thread to avoid race conditions with
1678 // display power state.
1679 postMessageAsync(new LambdaMessage(
1680 [=]() NO_THREAD_SAFETY_ANALYSIS { setPrimaryVsyncEnabledInternal(enabled); }));
1681}
1682
1683void SurfaceFlinger::setPrimaryVsyncEnabledInternal(bool enabled) {
1684 ATRACE_CALL();
1685
Ady Abraham27c70212019-06-11 10:52:26 -07001686 mHWCVsyncPendingState = enabled ? HWC2::Vsync::Enable : HWC2::Vsync::Disable;
1687
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001688 if (const auto displayId = getInternalDisplayIdLocked()) {
Ady Abraham9ba25122019-06-03 17:10:55 -07001689 sp<DisplayDevice> display = getDefaultDisplayDeviceLocked();
1690 if (display && display->isPoweredOn()) {
Ady Abraham27c70212019-06-11 10:52:26 -07001691 setVsyncEnabledInHWC(*displayId, mHWCVsyncPendingState);
Ady Abraham9ba25122019-06-03 17:10:55 -07001692 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07001693 }
Mathias Agopian86303202012-07-24 22:46:10 -07001694}
1695
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001696// Note: it is assumed the caller holds |mStateLock| when this is called
Steven Thomasb02664d2017-07-26 18:48:28 -07001697void SurfaceFlinger::resetDisplayState() {
Ana Krulecc2870422019-01-29 19:00:58 -08001698 mScheduler->disableHardwareVsync(true);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001699 // Clear the drawing state so that the logic inside of
1700 // handleTransactionLocked will fire. It will determine the delta between
1701 // mCurrentState and mDrawingState and re-apply all changes when we make the
1702 // transition.
1703 mDrawingState.displays.clear();
1704 mDisplays.clear();
1705}
1706
Steven Thomas050b2c82017-03-06 11:45:16 -08001707void SurfaceFlinger::updateVrFlinger() {
Alec Mourife3dc942019-02-12 14:19:18 -08001708 ATRACE_CALL();
Steven Thomas050b2c82017-03-06 11:45:16 -08001709 if (!mVrFlinger)
1710 return;
1711 bool vrFlingerRequestsDisplay = mVrFlingerRequestsDisplay;
Lloyd Pique441d5042018-10-18 16:49:51 -07001712 if (vrFlingerRequestsDisplay == getHwComposer().isUsingVrComposer()) {
Mark Urbanus209beca2017-02-23 11:16:04 -08001713 return;
1714 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001715
Lloyd Pique441d5042018-10-18 16:49:51 -07001716 if (vrFlingerRequestsDisplay && !getHwComposer().getComposer()->isRemote()) {
Steven Thomasb02664d2017-07-26 18:48:28 -07001717 ALOGE("Vr flinger is only supported for remote hardware composer"
1718 " service connections. Ignoring request to transition to vr"
1719 " flinger.");
1720 mVrFlingerRequestsDisplay = false;
1721 return;
Mark Urbanus209beca2017-02-23 11:16:04 -08001722 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001723
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001724 Mutex::Autolock _l(mStateLock);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001725
Steven Thomas0123ac62018-07-12 11:32:34 -07001726 sp<DisplayDevice> display = getDefaultDisplayDeviceLocked();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07001727 LOG_ALWAYS_FATAL_IF(!display);
Lloyd Pique07e33212018-12-18 16:33:37 -08001728
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07001729 const int currentDisplayPowerMode = display->getPowerMode();
Lloyd Pique07e33212018-12-18 16:33:37 -08001730
1731 // Clear out all the output layers from the composition engine for all
1732 // displays before destroying the hardware composer interface. This ensures
1733 // any HWC layers are destroyed through that interface before it becomes
1734 // invalid.
1735 for (const auto& [token, displayDevice] : mDisplays) {
Lloyd Pique01c77c12019-04-17 12:48:32 -07001736 displayDevice->getCompositionDisplay()->clearOutputLayers();
Lloyd Pique07e33212018-12-18 16:33:37 -08001737 }
1738
Steven Thomas0123ac62018-07-12 11:32:34 -07001739 // This DisplayDevice will no longer be relevant once resetDisplayState() is
1740 // called below. Clear the reference now so we don't accidentally use it
1741 // later.
1742 display.clear();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001743
Steven Thomasb02664d2017-07-26 18:48:28 -07001744 if (!vrFlingerRequestsDisplay) {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001745 mVrFlinger->SeizeDisplayOwnership();
Steven Thomasb02664d2017-07-26 18:48:28 -07001746 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001747
Steven Thomasb02664d2017-07-26 18:48:28 -07001748 resetDisplayState();
Lloyd Pique441d5042018-10-18 16:49:51 -07001749 // Delete the current instance before creating the new one
1750 mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
1751 mCompositionEngine->setHwComposer(getFactory().createHWComposer(
1752 vrFlingerRequestsDisplay ? "vr" : getBE().mHwcServiceName));
Lloyd Pique4603f3c2020-02-11 12:06:56 -08001753 mCompositionEngine->getHwComposer().setConfiguration(this, ++getBE().mComposerSequenceId);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001754
Lloyd Pique441d5042018-10-18 16:49:51 -07001755 LOG_ALWAYS_FATAL_IF(!getHwComposer().getComposer()->isRemote(),
David Sodman105b7dc2017-11-04 20:28:14 -07001756 "Switched to non-remote hardware composer");
Steven Thomasb02664d2017-07-26 18:48:28 -07001757
1758 if (vrFlingerRequestsDisplay) {
1759 mVrFlinger->GrantDisplayOwnership();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001760 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001761
1762 mVisibleRegionsDirty = true;
1763 invalidateHwcGeometry();
1764
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001765 // Re-enable default display.
Steven Thomas0123ac62018-07-12 11:32:34 -07001766 display = getDefaultDisplayDeviceLocked();
1767 LOG_ALWAYS_FATAL_IF(!display);
Dominik Laskowskie9774092018-12-11 10:04:24 -08001768 setPowerModeInternal(display, currentDisplayPowerMode);
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001769
Steven Thomasb02664d2017-07-26 18:48:28 -07001770 // Reset the timing values to account for the period of the swapped in HWC
Dominik Laskowski83b88212018-12-11 13:34:06 -08001771 const nsecs_t vsyncPeriod = getVsyncPeriod();
1772 mAnimFrameTracker.setDisplayRefreshPeriod(vsyncPeriod);
Alex Sakhartchouk096cb992017-06-05 10:37:57 -04001773
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001774 // The present fences returned from vr_hwc are not an accurate
1775 // representation of vsync times.
Ana Krulecc2870422019-01-29 19:00:58 -08001776 mScheduler->setIgnorePresentFences(getHwComposer().isUsingVrComposer() || !hasSyncFramework);
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001777
Steven Thomasb02664d2017-07-26 18:48:28 -07001778 // Use phase of 0 since phase is not known.
1779 // Use latency of 0, which will snap to the ideal latency.
Dominik Laskowski83b88212018-12-11 13:34:06 -08001780 DisplayStatInfo stats{0 /* vsyncTime */, vsyncPeriod};
Ana Krulece588e312018-09-18 12:32:24 -07001781 setCompositorTimingSnapped(stats, 0);
Stephen Kiazyk82386cd2017-04-14 13:43:29 -07001782
Ana Krulecc2870422019-01-29 19:00:58 -08001783 mScheduler->resyncToHardwareVsync(false, vsyncPeriod);
Steven Thomasdfde8fa2018-04-19 16:00:58 -07001784
Lloyd Piquef1c675b2018-09-12 20:45:39 -07001785 mRepaintEverything = true;
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001786 setTransactionFlags(eDisplayTransactionNeeded);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001787}
1788
Alec Mouri6d414b52020-03-17 11:18:05 -07001789sp<Fence> SurfaceFlinger::previousFrameFence() NO_THREAD_SAFETY_ANALYSIS {
Ady Abrahambe0f9482019-04-24 15:41:53 -07001790 // We are storing the last 2 present fences. If sf's phase offset is to be
1791 // woken up before the actual vsync but targeting the next vsync, we need to check
1792 // fence N-2
Alec Mouri6d414b52020-03-17 11:18:05 -07001793 return mVSyncModulator->getOffsets().sf > 0 ? mPreviousPresentFences[0]
1794 : mPreviousPresentFences[1];
1795}
1796
1797bool SurfaceFlinger::previousFramePending(int graceTimeMs) NO_THREAD_SAFETY_ANALYSIS {
1798 ATRACE_CALL();
1799 const sp<Fence>& fence = previousFrameFence();
Ady Abrahambe0f9482019-04-24 15:41:53 -07001800
Ady Abraham11579302019-09-19 12:35:58 -07001801 if (fence == Fence::NO_FENCE) {
1802 return false;
1803 }
1804
1805 if (graceTimeMs > 0 && fence->getStatus() == Fence::Status::Unsignaled) {
1806 fence->wait(graceTimeMs);
1807 }
1808
1809 return (fence->getStatus() == Fence::Status::Unsignaled);
Ady Abrahambe0f9482019-04-24 15:41:53 -07001810}
1811
Alec Mouri6d414b52020-03-17 11:18:05 -07001812nsecs_t SurfaceFlinger::previousFramePresentTime() NO_THREAD_SAFETY_ANALYSIS {
1813 const sp<Fence>& fence = previousFrameFence();
1814
1815 if (fence == Fence::NO_FENCE) {
1816 return Fence::SIGNAL_TIME_INVALID;
1817 }
1818
1819 return fence->getSignalTime();
1820}
1821
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07001822void SurfaceFlinger::populateExpectedPresentTime() {
Alec Mouriaa614192019-06-06 13:28:34 -07001823 DisplayStatInfo stats;
1824 mScheduler->getDisplayStatInfo(&stats);
Ady Abraham8fe11022019-06-12 17:11:12 -07001825 const nsecs_t presentTime = mScheduler->getDispSyncExpectedPresentTime();
Alec Mouriaa614192019-06-06 13:28:34 -07001826 // Inflate the expected present time if we're targetting the next vsync.
Ady Abraham9e16a482019-12-03 17:19:41 -08001827 mExpectedPresentTime.store(
1828 mVSyncModulator->getOffsets().sf > 0 ? presentTime : presentTime + stats.vsyncPeriod);
Alec Mouriaa614192019-06-06 13:28:34 -07001829}
1830
Dominik Laskowski22488f62019-03-28 09:53:04 -07001831void SurfaceFlinger::onMessageReceived(int32_t what) NO_THREAD_SAFETY_ANALYSIS {
Jamie Gennis1c8e95c2012-02-23 19:27:23 -08001832 ATRACE_CALL();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001833 switch (what) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08001834 case MessageQueue::INVALIDATE: {
Alec Mouri9519bf12019-11-15 16:54:44 -08001835 const nsecs_t frameStart = systemTime();
Ady Abraham7c03ce62019-07-19 10:59:45 -07001836 // calculate the expected present time once and use the cached
1837 // value throughout this frame to make sure all layers are
1838 // seeing this same value.
Alec Mouri6d414b52020-03-17 11:18:05 -07001839 const nsecs_t lastExpectedPresentTime = mExpectedPresentTime.load();
Ady Abraham7c03ce62019-07-19 10:59:45 -07001840 populateExpectedPresentTime();
1841
Ady Abraham11579302019-09-19 12:35:58 -07001842 // When Backpressure propagation is enabled we want to give a small grace period
1843 // for the present fence to fire instead of just giving up on this frame to handle cases
1844 // where present fence is just about to get signaled.
1845 const int graceTimeForPresentFenceMs =
1846 (mPropagateBackpressure &&
1847 (mPropagateBackpressureClientComposition || !mHadClientComposition))
1848 ? 1
1849 : 0;
Alec Mouri6d414b52020-03-17 11:18:05 -07001850
1851 // Pending frames may trigger backpressure propagation.
1852 const TracedOrdinal<bool> framePending = {"PrevFramePending",
1853 previousFramePending(
1854 graceTimeForPresentFenceMs)};
1855
1856 // Frame missed counts for metrics tracking.
1857 // A frame is missed if the prior frame is still pending. If no longer pending,
1858 // then we still count the frame as missed if the predicted present time
1859 // was further in the past than when the fence actually fired.
1860
1861 // Add some slop to correct for drift. This should generally be
1862 // smaller than a typical frame duration, but should not be so small
1863 // that it reports reasonable drift as a missed frame.
1864 DisplayStatInfo stats;
1865 mScheduler->getDisplayStatInfo(&stats);
1866 const nsecs_t frameMissedSlop = stats.vsyncPeriod / 2;
1867 const nsecs_t previousPresentTime = previousFramePresentTime();
1868 const TracedOrdinal<bool> frameMissed =
1869 {"PrevFrameMissed",
1870 framePending ||
1871 (previousPresentTime >= 0 &&
1872 (lastExpectedPresentTime < previousPresentTime - frameMissedSlop))};
1873 const TracedOrdinal<bool> hwcFrameMissed = {"PrevHwcFrameMissed",
Ady Abraham50204dd2019-07-19 15:47:11 -07001874 mHadDeviceComposition && frameMissed};
Alec Mouri6d414b52020-03-17 11:18:05 -07001875 const TracedOrdinal<bool> gpuFrameMissed = {"PrevGpuFrameMissed",
Ady Abraham50204dd2019-07-19 15:47:11 -07001876 mHadClientComposition && frameMissed};
1877
Alec Mouricc0fc602019-02-26 21:45:19 -08001878 if (frameMissed) {
1879 mFrameMissedCount++;
1880 mTimeStats->incrementMissedFrames();
Alec Mouri989ddbe2020-02-06 09:26:19 -08001881 if (mMissedFrameJankCount == 0) {
1882 mMissedFrameJankStart = systemTime();
1883 }
1884 mMissedFrameJankCount++;
Alec Mouricc0fc602019-02-26 21:45:19 -08001885 }
1886
Alec Mouri40189b02019-03-05 15:07:54 -08001887 if (hwcFrameMissed) {
1888 mHwcFrameMissedCount++;
1889 }
1890
1891 if (gpuFrameMissed) {
1892 mGpuFrameMissedCount++;
1893 }
1894
Ady Abraham27cbed72020-04-10 12:56:59 -07001895 // If we are in the middle of a config change and the fence hasn't
1896 // fired yet just wait for the next invalidate
1897 if (mSetActiveConfigPending) {
1898 if (framePending) {
1899 mEventQueue->invalidate();
1900 break;
1901 }
1902
1903 // We received the present fence from the HWC, so we assume it successfully updated
1904 // the config, hence we update SF.
1905 mSetActiveConfigPending = false;
1906 setActiveConfigInternal();
1907 }
1908
Alec Mouri6d414b52020-03-17 11:18:05 -07001909 if (framePending && mPropagateBackpressure) {
Ady Abrahamadb9a992019-09-19 21:21:55 +00001910 if ((hwcFrameMissed && !gpuFrameMissed) ||
1911 mPropagateBackpressureClientComposition) {
Yiwei Zhang621f9d42018-05-07 10:40:55 -07001912 signalLayerUpdate();
1913 break;
1914 }
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07001915 }
Dan Stoza50182882016-07-08 12:02:20 -07001916
Alec Mouri989ddbe2020-02-06 09:26:19 -08001917 // Our jank window is always at least 100ms since we missed a
1918 // frame...
1919 static constexpr nsecs_t kMinJankyDuration =
1920 std::chrono::duration_cast<std::chrono::nanoseconds>(100ms).count();
1921 // ...but if it's larger than 1s then we missed the trace cutoff.
1922 static constexpr nsecs_t kMaxJankyDuration =
1923 std::chrono::duration_cast<std::chrono::nanoseconds>(1s).count();
1924 // If we're in a user build then don't push any atoms
1925 if (!mIsUserBuild && mMissedFrameJankCount > 0) {
1926 const auto displayDevice = getDefaultDisplayDeviceLocked();
1927 // Only report jank when the display is on, as displays in DOZE
1928 // power mode may operate at a different frame rate than is
1929 // reported in their config, which causes noticeable (but less
1930 // severe) jank.
1931 if (displayDevice && displayDevice->getPowerMode() == HWC_POWER_MODE_NORMAL) {
1932 const nsecs_t currentTime = systemTime();
1933 const nsecs_t jankDuration = currentTime - mMissedFrameJankStart;
1934 if (jankDuration > kMinJankyDuration && jankDuration < kMaxJankyDuration) {
1935 ATRACE_NAME("Jank detected");
1936 ALOGD("Detected janky event. Missed frames: %d", mMissedFrameJankCount);
1937 const int32_t jankyDurationMillis = jankDuration / (1000 * 1000);
1938 android::util::stats_write(android::util::DISPLAY_JANK_REPORTED,
1939 jankyDurationMillis, mMissedFrameJankCount);
1940 }
1941
1942 // We either reported a jank event or we missed the trace
1943 // window, so clear counters here.
1944 if (jankDuration > kMinJankyDuration) {
1945 mMissedFrameJankCount = 0;
1946 mMissedFrameJankStart = 0;
1947 }
1948 }
1949 }
1950
Steven Thomas050b2c82017-03-06 11:45:16 -08001951 // Now that we're going to make it to the handleMessageTransaction()
1952 // call below it's safe to call updateVrFlinger(), which will
1953 // potentially trigger a display handoff.
1954 updateVrFlinger();
1955
Vishnu Nair60db8c02020-04-02 11:55:16 -07001956 bool refreshNeeded;
1957 withTracingLock([&]() {
1958 refreshNeeded = handleMessageTransaction();
1959 refreshNeeded |= handleMessageInvalidate();
1960 if (mTracingEnabled) {
1961 mAddCompositionStateToTrace =
1962 mTracing.flagIsSetLocked(SurfaceTracing::TRACE_COMPOSITION);
1963 if (mVisibleRegionsDirty && !mAddCompositionStateToTrace) {
1964 mTracing.notifyLocked("visibleRegionsDirty");
1965 }
1966 }
1967 });
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001968
Ana Krulecc84d09b2019-11-02 23:10:29 +01001969 // Layers need to get updated (in the previous line) before we can use them for
1970 // choosing the refresh rate.
Ady Abraham8a82ba62020-01-17 12:43:17 -08001971 // Hold mStateLock as chooseRefreshRateForContent promotes wp<Layer> to sp<Layer>
1972 // and may eventually call to ~Layer() if it holds the last reference
1973 {
1974 Mutex::Autolock _l(mStateLock);
1975 mScheduler->chooseRefreshRateForContent();
1976 }
1977
Ady Abraham27cbed72020-04-10 12:56:59 -07001978 performSetActiveConfig();
Ana Krulecc84d09b2019-11-02 23:10:29 +01001979
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001980 updateCursorAsync();
1981 updateInputFlinger();
1982
Dan Stoza58784442014-12-02 16:58:17 -08001983 refreshNeeded |= mRepaintEverything;
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08001984 if (refreshNeeded && CC_LIKELY(mBootStage != BootStage::BOOTLOADER)) {
Dan Stoza58784442014-12-02 16:58:17 -08001985 // Signal a refresh if a transaction modified the window state,
1986 // a new buffer was latched, or if HWC has requested a full
1987 // repaint
Alec Mouri9519bf12019-11-15 16:54:44 -08001988 if (mFrameStartTime <= 0) {
1989 // We should only use the time of the first invalidate
1990 // message that signals a refresh as the beginning of the
1991 // frame. Otherwise the real frame time will be
1992 // underestimated.
1993 mFrameStartTime = frameStart;
1994 }
Dan Stoza6b9454d2014-11-07 16:00:59 -08001995 signalRefresh();
1996 }
1997 break;
1998 }
1999 case MessageQueue::REFRESH: {
2000 handleMessageRefresh();
2001 break;
2002 }
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08002003 }
2004}
2005
Dan Stoza6b9454d2014-11-07 16:00:59 -08002006bool SurfaceFlinger::handleMessageTransaction() {
Alec Mourife3dc942019-02-12 14:19:18 -08002007 ATRACE_CALL();
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08002008 uint32_t transactionFlags = peekTransactionFlags();
Marissa Wall713b63f2018-10-17 15:42:43 -07002009
Marissa Walle6e3c0d2019-03-29 10:28:30 -07002010 bool flushedATransaction = flushTransactionQueues();
2011
2012 bool runHandleTransaction = transactionFlags &&
2013 ((transactionFlags != eTransactionFlushNeeded) || flushedATransaction);
2014
2015 if (runHandleTransaction) {
2016 handleTransaction(eTransactionMask);
2017 } else {
2018 getTransactionFlags(eTransactionFlushNeeded);
Marissa Wall713b63f2018-10-17 15:42:43 -07002019 }
2020
Marissa Walle6e3c0d2019-03-29 10:28:30 -07002021 if (transactionFlushNeeded()) {
2022 setTransactionFlags(eTransactionFlushNeeded);
Mathias Agopian4fec8732012-06-29 14:12:52 -07002023 }
Marissa Wall713b63f2018-10-17 15:42:43 -07002024
Marissa Walle6e3c0d2019-03-29 10:28:30 -07002025 return runHandleTransaction;
Mathias Agopian4fec8732012-06-29 14:12:52 -07002026}
2027
Mathias Agopian4fec8732012-06-29 14:12:52 -07002028void SurfaceFlinger::handleMessageRefresh() {
Mathias Agopiancd60f992012-08-16 16:28:27 -07002029 ATRACE_CALL();
Dan Stoza14cd37c2015-07-09 12:43:33 -07002030
Dan Stoza2b6d38e2017-06-01 16:40:30 -07002031 mRefreshPending = false;
2032
Lloyd Piqueab039b52019-02-13 14:22:42 -08002033 compositionengine::CompositionRefreshArgs refreshArgs;
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002034 refreshArgs.outputs.reserve(mDisplays.size());
Lloyd Piqueab039b52019-02-13 14:22:42 -08002035 for (const auto& [_, display] : mDisplays) {
2036 refreshArgs.outputs.push_back(display->getCompositionDisplay());
2037 }
2038 mDrawingState.traverseInZOrder([&refreshArgs](Layer* layer) {
Lloyd Piquede196652020-01-22 17:29:58 -08002039 if (auto layerFE = layer->getCompositionEngineLayerFE())
2040 refreshArgs.layers.push_back(layerFE);
Lloyd Piqueab039b52019-02-13 14:22:42 -08002041 });
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002042 refreshArgs.layersWithQueuedFrames.reserve(mLayersWithQueuedFrames.size());
2043 for (sp<Layer> layer : mLayersWithQueuedFrames) {
Lloyd Piquede196652020-01-22 17:29:58 -08002044 if (auto layerFE = layer->getCompositionEngineLayerFE())
2045 refreshArgs.layersWithQueuedFrames.push_back(layerFE);
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002046 }
2047
Lloyd Piquef8cf14d2019-02-28 16:03:12 -08002048 refreshArgs.repaintEverything = mRepaintEverything.exchange(false);
Lloyd Pique6a3b4462019-03-07 20:58:12 -08002049 refreshArgs.outputColorSetting = useColorManagement
2050 ? mDisplayColorSetting
2051 : compositionengine::OutputColorSetting::kUnmanaged;
2052 refreshArgs.colorSpaceAgnosticDataspace = mColorSpaceAgnosticDataspace;
2053 refreshArgs.forceOutputColorMode = mForceColorMode;
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002054
2055 refreshArgs.updatingOutputGeometryThisFrame = mVisibleRegionsDirty;
2056 refreshArgs.updatingGeometryThisFrame = mGeometryInvalid || mVisibleRegionsDirty;
Lucas Dupin2dd6f392020-02-18 17:43:36 -08002057 refreshArgs.blursAreExpensive = mBlursAreExpensive;
Lloyd Pique3eb1b212019-03-07 21:15:40 -08002058
2059 if (CC_UNLIKELY(mDrawingState.colorMatrixChanged)) {
2060 refreshArgs.colorTransformMatrix = mDrawingState.colorMatrix;
2061 mDrawingState.colorMatrixChanged = false;
2062 }
2063
2064 refreshArgs.devOptForceClientComposition = mDebugDisableHWC || mDebugRegion;
2065
Lloyd Piquef8cf14d2019-02-28 16:03:12 -08002066 if (mDebugRegion != 0) {
2067 refreshArgs.devOptFlashDirtyRegionsDelay =
2068 std::chrono::milliseconds(mDebugRegion > 1 ? mDebugRegion : 0);
2069 }
Lloyd Piqueab039b52019-02-13 14:22:42 -08002070
Lloyd Pique3eb1b212019-03-07 21:15:40 -08002071 mGeometryInvalid = false;
2072
Ady Abraham3a77a7b2019-12-02 18:46:59 -08002073 // Store the present time just before calling to the composition engine so we could notify
2074 // the scheduler.
2075 const auto presentTime = systemTime();
2076
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002077 mCompositionEngine->present(refreshArgs);
Alec Mouri9519bf12019-11-15 16:54:44 -08002078 mTimeStats->recordFrameDuration(mFrameStartTime, systemTime());
2079 // Reset the frame start time now that we've recorded this frame.
2080 mFrameStartTime = 0;
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002081
Ady Abraham3a77a7b2019-12-02 18:46:59 -08002082 mScheduler->onDisplayRefreshed(presentTime);
2083
David Sodmanfa9b2af2017-12-24 13:28:59 -08002084 postFrame();
David Sodman2b406362017-12-15 13:33:47 -08002085 postComposition();
Dan Stoza05dacfb2016-07-01 13:33:38 -07002086
Lloyd Pique66d68602019-02-13 14:23:31 -08002087 mHadClientComposition =
2088 std::any_of(mDisplays.cbegin(), mDisplays.cend(), [](const auto& tokenDisplayPair) {
2089 auto& displayDevice = tokenDisplayPair.second;
Vishnu Nair9b079a22020-01-21 14:36:08 -08002090 return displayDevice->getCompositionDisplay()->getState().usesClientComposition &&
2091 !displayDevice->getCompositionDisplay()->getState().reusedClientComposition;
Lloyd Pique66d68602019-02-13 14:23:31 -08002092 });
2093 mHadDeviceComposition =
2094 std::any_of(mDisplays.cbegin(), mDisplays.cend(), [](const auto& tokenDisplayPair) {
2095 auto& displayDevice = tokenDisplayPair.second;
2096 return displayDevice->getCompositionDisplay()->getState().usesDeviceComposition;
2097 });
Vishnu Nair9b079a22020-01-21 14:36:08 -08002098 mReusedClientComposition =
2099 std::any_of(mDisplays.cbegin(), mDisplays.cend(), [](const auto& tokenDisplayPair) {
2100 auto& displayDevice = tokenDisplayPair.second;
2101 return displayDevice->getCompositionDisplay()->getState().reusedClientComposition;
2102 });
David Sodmanfa9b2af2017-12-24 13:28:59 -08002103
Dominik Laskowskieddeda12019-07-19 11:54:13 -07002104 mVSyncModulator->onRefreshed(mHadClientComposition);
Dan Stoza14cd37c2015-07-09 12:43:33 -07002105
David Sodman7e4ae112018-02-09 15:02:28 -08002106 mLayersWithQueuedFrames.clear();
Vishnu Nairdf529052019-06-07 14:53:14 -07002107 if (mVisibleRegionsDirty) {
2108 mVisibleRegionsDirty = false;
Vishnu Nair60db8c02020-04-02 11:55:16 -07002109 if (mTracingEnabled && mAddCompositionStateToTrace) {
Vishnu Nairdf529052019-06-07 14:53:14 -07002110 mTracing.notify("visibleRegionsDirty");
2111 }
2112 }
Lloyd Piqueab039b52019-02-13 14:22:42 -08002113
2114 if (mCompositionEngine->needsAnotherUpdate()) {
2115 signalLayerUpdate();
2116 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07002117}
Mathias Agopian4fec8732012-06-29 14:12:52 -07002118
David Sodmanfa9b2af2017-12-24 13:28:59 -08002119
2120bool SurfaceFlinger::handleMessageInvalidate() {
2121 ATRACE_CALL();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002122 bool refreshNeeded = handlePageFlip();
2123
Vishnu Nair4351ad52019-02-11 14:13:02 -08002124 if (mVisibleRegionsDirty) {
2125 computeLayerBounds();
2126 }
2127
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002128 for (auto& layer : mLayersPendingRefresh) {
2129 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002130 visibleReg.set(layer->getScreenBounds());
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002131 invalidateLayerStack(layer, visibleReg);
2132 }
2133 mLayersPendingRefresh.clear();
2134 return refreshNeeded;
Mathias Agopian4fec8732012-06-29 14:12:52 -07002135}
2136
Ana Krulece588e312018-09-18 12:32:24 -07002137void SurfaceFlinger::updateCompositorTiming(const DisplayStatInfo& stats, nsecs_t compositeTime,
2138 std::shared_ptr<FenceTime>& presentFenceTime) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002139 // Update queue of past composite+present times and determine the
2140 // most recently known composite to present latency.
David Sodman99974d22017-11-28 12:04:33 -08002141 getBE().mCompositePresentTimes.push({compositeTime, presentFenceTime});
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002142 nsecs_t compositeToPresentLatency = -1;
David Sodman99974d22017-11-28 12:04:33 -08002143 while (!getBE().mCompositePresentTimes.empty()) {
2144 SurfaceFlingerBE::CompositePresentTime& cpt = getBE().mCompositePresentTimes.front();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002145 // Cached values should have been updated before calling this method,
2146 // which helps avoid duplicate syscalls.
2147 nsecs_t displayTime = cpt.display->getCachedSignalTime();
2148 if (displayTime == Fence::SIGNAL_TIME_PENDING) {
2149 break;
2150 }
2151 compositeToPresentLatency = displayTime - cpt.composite;
David Sodman99974d22017-11-28 12:04:33 -08002152 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002153 }
2154
2155 // Don't let mCompositePresentTimes grow unbounded, just in case.
David Sodman99974d22017-11-28 12:04:33 -08002156 while (getBE().mCompositePresentTimes.size() > 16) {
2157 getBE().mCompositePresentTimes.pop();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002158 }
2159
Ana Krulece588e312018-09-18 12:32:24 -07002160 setCompositorTimingSnapped(stats, compositeToPresentLatency);
Brian Andersond0010582017-03-07 13:20:31 -08002161}
2162
Ana Krulece588e312018-09-18 12:32:24 -07002163void SurfaceFlinger::setCompositorTimingSnapped(const DisplayStatInfo& stats,
2164 nsecs_t compositeToPresentLatency) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002165 // Integer division and modulo round toward 0 not -inf, so we need to
2166 // treat negative and positive offsets differently.
Ady Abraham9e16a482019-12-03 17:19:41 -08002167 nsecs_t idealLatency = (mPhaseConfiguration->getCurrentOffsets().late.sf > 0)
2168 ? (stats.vsyncPeriod -
2169 (mPhaseConfiguration->getCurrentOffsets().late.sf % stats.vsyncPeriod))
2170 : ((-mPhaseConfiguration->getCurrentOffsets().late.sf) % stats.vsyncPeriod);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002171
Ady Abraham9e16a482019-12-03 17:19:41 -08002172 // Just in case mPhaseConfiguration->getCurrentOffsets().late.sf == -vsyncInterval.
Brian Andersond0010582017-03-07 13:20:31 -08002173 if (idealLatency <= 0) {
Ana Krulece588e312018-09-18 12:32:24 -07002174 idealLatency = stats.vsyncPeriod;
Brian Andersond0010582017-03-07 13:20:31 -08002175 }
2176
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002177 // Snap the latency to a value that removes scheduling jitter from the
2178 // composition and present times, which often have >1ms of jitter.
2179 // Reducing jitter is important if an app attempts to extrapolate
2180 // something (such as user input) to an accurate diasplay time.
Ady Abraham9e16a482019-12-03 17:19:41 -08002181 // Snapping also allows an app to precisely calculate
2182 // mPhaseConfiguration->getCurrentOffsets().late.sf with (presentLatency % interval).
Ana Krulece588e312018-09-18 12:32:24 -07002183 nsecs_t bias = stats.vsyncPeriod / 2;
2184 int64_t extraVsyncs = (compositeToPresentLatency - idealLatency + bias) / stats.vsyncPeriod;
2185 nsecs_t snappedCompositeToPresentLatency =
2186 (extraVsyncs > 0) ? idealLatency + (extraVsyncs * stats.vsyncPeriod) : idealLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002187
David Sodman99974d22017-11-28 12:04:33 -08002188 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
Ana Krulece588e312018-09-18 12:32:24 -07002189 getBE().mCompositorTiming.deadline = stats.vsyncTime - idealLatency;
2190 getBE().mCompositorTiming.interval = stats.vsyncPeriod;
David Sodman99974d22017-11-28 12:04:33 -08002191 getBE().mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002192}
2193
David Sodman2b406362017-12-15 13:33:47 -08002194void SurfaceFlinger::postComposition()
Mathias Agopiancd60f992012-08-16 16:28:27 -07002195{
Dan Stoza9e56aa02015-11-02 13:00:03 -08002196 ATRACE_CALL();
2197 ALOGV("postComposition");
2198
Brian Andersonf6386862016-10-31 16:34:13 -07002199 nsecs_t dequeueReadyTime = systemTime();
Brian Anderson3546a3f2016-07-14 11:51:14 -07002200 for (auto& layer : mLayersWithQueuedFrames) {
Brian Andersonf6386862016-10-31 16:34:13 -07002201 layer->releasePendingBuffer(dequeueReadyTime);
Brian Anderson3546a3f2016-07-14 11:51:14 -07002202 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07002203 // |mStateLock| not needed as we are on the main thread
Lloyd Pique32cbe282018-10-19 13:09:22 -07002204 const auto displayDevice = getDefaultDisplayDeviceLocked();
Brian Anderson3d4039d2016-09-23 16:31:30 -07002205
David Sodman73beded2017-11-15 11:56:06 -08002206 getBE().mGlCompositionDoneTimeline.updateSignalTimes();
Brian Anderson3d4039d2016-09-23 16:31:30 -07002207 std::shared_ptr<FenceTime> glCompositionDoneFenceTime;
Lloyd Pique66d68602019-02-13 14:23:31 -08002208 if (displayDevice && displayDevice->getCompositionDisplay()->getState().usesClientComposition) {
Brian Anderson3d4039d2016-09-23 16:31:30 -07002209 glCompositionDoneFenceTime =
Lloyd Pique31cb2942018-10-19 17:23:03 -07002210 std::make_shared<FenceTime>(displayDevice->getCompositionDisplay()
2211 ->getRenderSurface()
2212 ->getClientTargetAcquireFence());
David Sodman73beded2017-11-15 11:56:06 -08002213 getBE().mGlCompositionDoneTimeline.push(glCompositionDoneFenceTime);
Brian Anderson3d4039d2016-09-23 16:31:30 -07002214 } else {
2215 glCompositionDoneFenceTime = FenceTime::NO_FENCE;
2216 }
Brian Anderson3d4039d2016-09-23 16:31:30 -07002217
David Sodman73beded2017-11-15 11:56:06 -08002218 getBE().mDisplayTimeline.updateSignalTimes();
Ady Abrahambe0f9482019-04-24 15:41:53 -07002219 mPreviousPresentFences[1] = mPreviousPresentFences[0];
2220 mPreviousPresentFences[0] = displayDevice
2221 ? getHwComposer().getPresentFence(*displayDevice->getId())
2222 : Fence::NO_FENCE;
2223 auto presentFenceTime = std::make_shared<FenceTime>(mPreviousPresentFences[0]);
David Sodman73beded2017-11-15 11:56:06 -08002224 getBE().mDisplayTimeline.push(presentFenceTime);
Brian Anderson3d4039d2016-09-23 16:31:30 -07002225
Ana Krulece588e312018-09-18 12:32:24 -07002226 DisplayStatInfo stats;
Ana Krulecc2870422019-01-29 19:00:58 -08002227 mScheduler->getDisplayStatInfo(&stats);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002228
Lloyd Piqueab039b52019-02-13 14:22:42 -08002229 // We use the CompositionEngine::getLastFrameRefreshTimestamp() which might
2230 // be sampled a little later than when we started doing work for this frame,
2231 // but that should be okay since updateCompositorTiming has snapping logic.
2232 updateCompositorTiming(stats, mCompositionEngine->getLastFrameRefreshTimestamp(),
2233 presentFenceTime);
Brian Andersond0010582017-03-07 13:20:31 -08002234 CompositorTiming compositorTiming;
2235 {
David Sodman99974d22017-11-28 12:04:33 -08002236 std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);
2237 compositorTiming = getBE().mCompositorTiming;
Brian Andersond0010582017-03-07 13:20:31 -08002238 }
Brian Anderson0a61b0c2016-12-07 14:55:56 -08002239
Edgar Arriaga844fa672020-01-16 14:21:42 -08002240 mDrawingState.traverse([&](Layer* layer) {
Adithya Srinivasanb69e0762019-11-11 18:39:53 -08002241 bool frameLatched = layer->onPostComposition(displayDevice, glCompositionDoneFenceTime,
2242 presentFenceTime, compositorTiming);
Dan Stozae77c7662016-05-13 11:37:28 -07002243 if (frameLatched) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07002244 recordBufferingStats(layer->getName(), layer->getOccupancyHistory(false));
Dan Stozae77c7662016-05-13 11:37:28 -07002245 }
Robert Carr2047fae2016-11-28 14:09:09 -08002246 });
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002247
Valerie Hau4b678442020-04-14 10:50:42 -07002248 mTransactionCompletedThread.addPresentFence(mPreviousPresentFences[0]);
2249 mTransactionCompletedThread.sendCallbacks();
2250
Ady Abraham92fa2f42020-02-11 15:33:56 -08002251 if (displayDevice && displayDevice->isPrimary() &&
2252 displayDevice->getPowerMode() == HWC_POWER_MODE_NORMAL && presentFenceTime->isValid()) {
Ana Krulecc2870422019-01-29 19:00:58 -08002253 mScheduler->addPresentFence(presentFenceTime);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07002254 }
2255
Fabien Sanglardcbf153b2017-03-10 17:57:12 -08002256 if (!hasSyncFramework) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07002257 if (displayDevice && getHwComposer().isConnected(*displayDevice->getId()) &&
2258 displayDevice->isPoweredOn()) {
Ana Krulecc2870422019-01-29 19:00:58 -08002259 mScheduler->enableHardwareVsync();
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07002260 }
2261 }
2262
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002263 if (mAnimCompositionPending) {
2264 mAnimCompositionPending = false;
2265
Brian Anderson4e606e32017-03-16 15:34:57 -07002266 if (presentFenceTime->isValid()) {
Brian Anderson3d4039d2016-09-23 16:31:30 -07002267 mAnimFrameTracker.setActualPresentFence(
Brian Anderson4e606e32017-03-16 15:34:57 -07002268 std::move(presentFenceTime));
Lloyd Pique32cbe282018-10-19 13:09:22 -07002269 } else if (displayDevice && getHwComposer().isConnected(*displayDevice->getId())) {
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002270 // The HWC doesn't support present fences, so use the refresh
2271 // timestamp instead.
Lloyd Pique32cbe282018-10-19 13:09:22 -07002272 const nsecs_t presentTime =
2273 getHwComposer().getRefreshTimestamp(*displayDevice->getId());
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002274 mAnimFrameTracker.setActualPresentTime(presentTime);
2275 }
2276 mAnimFrameTracker.advanceFrame();
2277 }
Dan Stozab90cf072015-03-05 11:05:59 -08002278
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002279 mTimeStats->incrementTotalFrames();
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07002280 if (mHadClientComposition) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002281 mTimeStats->incrementClientCompositionFrames();
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07002282 }
2283
Vishnu Nair9b079a22020-01-21 14:36:08 -08002284 if (mReusedClientComposition) {
2285 mTimeStats->incrementClientCompositionReusedFrames();
2286 }
2287
Yiwei Zhang7e666a52018-11-15 13:33:42 -08002288 mTimeStats->setPresentFenceGlobal(presentFenceTime);
Yiwei Zhangce6ebc02018-10-20 12:42:38 -07002289
Alec Mouri717bcb62020-02-10 17:07:19 -08002290 const size_t sfConnections = mScheduler->getEventThreadConnectionCount(mSfConnectionHandle);
2291 const size_t appConnections = mScheduler->getEventThreadConnectionCount(mAppConnectionHandle);
2292 mTimeStats->recordDisplayEventConnectionCount(sfConnections + appConnections);
2293
Lloyd Pique32cbe282018-10-19 13:09:22 -07002294 if (displayDevice && getHwComposer().isConnected(*displayDevice->getId()) &&
2295 !displayDevice->isPoweredOn()) {
Dan Stozab90cf072015-03-05 11:05:59 -08002296 return;
2297 }
2298
2299 nsecs_t currentTime = systemTime();
2300 if (mHasPoweredOff) {
2301 mHasPoweredOff = false;
2302 } else {
David Sodman4a36e932017-11-07 14:29:47 -08002303 nsecs_t elapsedTime = currentTime - getBE().mLastSwapTime;
Ana Krulece588e312018-09-18 12:32:24 -07002304 size_t numPeriods = static_cast<size_t>(elapsedTime / stats.vsyncPeriod);
David Sodman4a36e932017-11-07 14:29:47 -08002305 if (numPeriods < SurfaceFlingerBE::NUM_BUCKETS - 1) {
2306 getBE().mFrameBuckets[numPeriods] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002307 } else {
David Sodman4a36e932017-11-07 14:29:47 -08002308 getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002309 }
David Sodman4a36e932017-11-07 14:29:47 -08002310 getBE().mTotalTime += elapsedTime;
Dan Stozab90cf072015-03-05 11:05:59 -08002311 }
David Sodman4a36e932017-11-07 14:29:47 -08002312 getBE().mLastSwapTime = currentTime;
Dan Stoza436ccf32018-06-21 12:10:12 -07002313
Alec Mouri4dde1782019-09-30 17:27:13 -07002314 // Cleanup any outstanding resources due to rendering a prior frame.
2315 getRenderEngine().cleanupPostRender();
2316
Dan Stoza436ccf32018-06-21 12:10:12 -07002317 {
2318 std::lock_guard lock(mTexturePoolMutex);
Dan Stoza67765d82019-05-07 14:58:27 -07002319 if (mTexturePool.size() < mTexturePoolSize) {
2320 const size_t refillCount = mTexturePoolSize - mTexturePool.size();
Dan Stoza436ccf32018-06-21 12:10:12 -07002321 const size_t offset = mTexturePool.size();
2322 mTexturePool.resize(mTexturePoolSize);
2323 getRenderEngine().genTextures(refillCount, mTexturePool.data() + offset);
2324 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Dan Stoza67765d82019-05-07 14:58:27 -07002325 } else if (mTexturePool.size() > mTexturePoolSize) {
2326 const size_t deleteCount = mTexturePool.size() - mTexturePoolSize;
2327 const size_t offset = mTexturePoolSize;
2328 getRenderEngine().deleteTextures(deleteCount, mTexturePool.data() + offset);
2329 mTexturePool.resize(mTexturePoolSize);
2330 ATRACE_INT("TexturePoolSize", mTexturePool.size());
Dan Stoza436ccf32018-06-21 12:10:12 -07002331 }
2332 }
Marissa Walle2ffb422018-10-12 11:33:52 -07002333
Kevin DuBois413287f2019-02-25 08:46:47 -08002334 if (mLumaSampling && mRegionSamplingThread) {
2335 mRegionSamplingThread->notifyNewContent();
Dan Stozaec460082018-12-17 15:35:09 -08002336 }
Dan Stoza45de5ba2019-04-25 14:12:09 -07002337
2338 // Even though ATRACE_INT64 already checks if tracing is enabled, it doesn't prevent the
2339 // side-effect of getTotalSize(), so we check that again here
2340 if (ATRACE_ENABLED()) {
Marissa Wall22b2de12019-12-02 18:11:43 -08002341 // getTotalSize returns the total number of buffers that were allocated by SurfaceFlinger
Dan Stoza45de5ba2019-04-25 14:12:09 -07002342 ATRACE_INT64("Total Buffer Size", GraphicBufferAllocator::get().getTotalSize());
2343 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07002344}
2345
Vishnu Nair4351ad52019-02-11 14:13:02 -08002346void SurfaceFlinger::computeLayerBounds() {
2347 for (const auto& pair : mDisplays) {
2348 const auto& displayDevice = pair.second;
2349 const auto display = displayDevice->getCompositionDisplay();
2350 for (const auto& layer : mDrawingState.layersSortedByZ) {
2351 // only consider the layers on the given layer stack
2352 if (!display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
Vishnu Nair01ace762019-02-12 14:25:24 -08002353 continue;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002354 }
2355
Vishnu Nairc97b8db2019-10-29 18:19:35 -07002356 layer->computeBounds(displayDevice->getViewport().toFloatRect(), ui::Transform(),
2357 0.f /* shadowRadius */);
Vishnu Nair4351ad52019-02-11 14:13:02 -08002358 }
2359 }
2360}
2361
David Sodmanfa9b2af2017-12-24 13:28:59 -08002362void SurfaceFlinger::postFrame()
2363{
2364 // |mStateLock| not needed as we are on the main thread
Dominik Laskowski075d3172018-05-24 15:50:06 -07002365 const auto display = getDefaultDisplayDeviceLocked();
2366 if (display && getHwComposer().isConnected(*display->getId())) {
2367 uint32_t flipCount = display->getPageFlipCount();
David Sodmanfa9b2af2017-12-24 13:28:59 -08002368 if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
2369 logFrameStats();
2370 }
2371 }
2372}
2373
Mathias Agopian87baae12012-07-31 12:38:26 -07002374void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002375{
Mathias Agopian841cde52012-03-01 15:44:37 -08002376 ATRACE_CALL();
2377
Mathias Agopian7cc6df52013-06-05 14:30:54 -07002378 // here we keep a copy of the drawing state (that is the state that's
2379 // going to be overwritten by handleTransactionLocked()) outside of
2380 // mStateLock so that the side-effects of the State assignment
2381 // don't happen with mStateLock held (which can cause deadlocks).
2382 State drawingState(mDrawingState);
2383
Mathias Agopianca4d3602011-05-19 15:38:14 -07002384 Mutex::Autolock _l(mStateLock);
Dominik Laskowski9dab3432019-03-27 13:21:10 -07002385 mDebugInTransaction = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002386
Mathias Agopianca4d3602011-05-19 15:38:14 -07002387 // Here we're guaranteed that some transaction flags are set
2388 // so we can call handleTransactionLocked() unconditionally.
2389 // We call getTransactionFlags(), which will also clear the flags,
2390 // with mStateLock held to guarantee that mCurrentState won't change
2391 // until the transaction is committed.
Mathias Agopian4da75192010-08-10 17:19:56 -07002392
Dominik Laskowskieddeda12019-07-19 11:54:13 -07002393 mVSyncModulator->onTransactionHandled();
Mathias Agopiane57f2922012-08-09 16:29:12 -07002394 transactionFlags = getTransactionFlags(eTransactionMask);
Mathias Agopian87baae12012-07-31 12:38:26 -07002395 handleTransactionLocked(transactionFlags);
Mathias Agopiandea20b12011-05-03 17:04:02 -07002396
Mathias Agopianca4d3602011-05-19 15:38:14 -07002397 mDebugInTransaction = 0;
2398 invalidateHwcGeometry();
2399 // here the transaction has been committed
Mathias Agopian3d579642009-06-04 18:46:21 -07002400}
2401
Lloyd Piqueba04e622017-12-14 17:11:26 -08002402void SurfaceFlinger::processDisplayHotplugEventsLocked() {
2403 for (const auto& event : mPendingHotplugEvents) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07002404 const std::optional<DisplayIdentificationInfo> info =
2405 getHwComposer().onHotplug(event.hwcDisplayId, event.connection);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002406
Dominik Laskowski075d3172018-05-24 15:50:06 -07002407 if (!info) {
Lloyd Piqueba04e622017-12-14 17:11:26 -08002408 continue;
2409 }
2410
Dominik Laskowski55c85402020-01-21 16:25:47 -08002411 const DisplayId displayId = info->id;
2412 const auto it = mPhysicalDisplayTokens.find(displayId);
2413
Lloyd Piqueba04e622017-12-14 17:11:26 -08002414 if (event.connection == HWC2::Connection::Connected) {
Dominik Laskowski55c85402020-01-21 16:25:47 -08002415 if (it == mPhysicalDisplayTokens.end()) {
2416 ALOGV("Creating display %s", to_string(displayId).c_str());
2417
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002418 if (event.hwcDisplayId == getHwComposer().getInternalHwcDisplayId()) {
Dominik Laskowski55c85402020-01-21 16:25:47 -08002419 initScheduler(displayId);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002420 }
Dominik Laskowski55c85402020-01-21 16:25:47 -08002421
Dominik Laskowski075d3172018-05-24 15:50:06 -07002422 DisplayDeviceState state;
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002423 state.physical = {displayId, getHwComposer().getDisplayConnectionType(displayId),
2424 event.hwcDisplayId};
Dominik Laskowski075d3172018-05-24 15:50:06 -07002425 state.isSecure = true; // All physical displays are currently considered secure.
2426 state.displayName = info->name;
Dominik Laskowski55c85402020-01-21 16:25:47 -08002427
2428 sp<IBinder> token = new BBinder();
2429 mCurrentState.displays.add(token, state);
2430 mPhysicalDisplayTokens.emplace(displayId, std::move(token));
2431
Dominik Laskowski075d3172018-05-24 15:50:06 -07002432 mInterceptor->saveDisplayCreation(state);
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002433 } else {
2434 ALOGV("Recreating display %s", to_string(displayId).c_str());
2435
2436 const auto token = it->second;
2437 auto& state = mCurrentState.displays.editValueFor(token);
2438 state.sequenceId = DisplayDeviceState{}.sequenceId;
Steven Thomaseb6d2052018-03-20 15:40:48 -07002439 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08002440 } else {
Dominik Laskowski55c85402020-01-21 16:25:47 -08002441 ALOGV("Removing display %s", to_string(displayId).c_str());
Lloyd Piqueba04e622017-12-14 17:11:26 -08002442
Dominik Laskowski55c85402020-01-21 16:25:47 -08002443 const ssize_t index = mCurrentState.displays.indexOfKey(it->second);
Dominik Laskowski075d3172018-05-24 15:50:06 -07002444 if (index >= 0) {
2445 const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
2446 mInterceptor->saveDisplayDeletion(state.sequenceId);
2447 mCurrentState.displays.removeItemsAt(index);
Lloyd Piquefcd86612017-12-14 17:15:36 -08002448 }
Dominik Laskowski55c85402020-01-21 16:25:47 -08002449 mPhysicalDisplayTokens.erase(it);
Lloyd Piqueba04e622017-12-14 17:11:26 -08002450 }
2451
2452 processDisplayChangesLocked();
2453 }
2454
2455 mPendingHotplugEvents.clear();
2456}
2457
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002458void SurfaceFlinger::dispatchDisplayHotplugEvent(PhysicalDisplayId displayId, bool connected) {
Dominik Laskowski98041832019-08-01 18:35:59 -07002459 mScheduler->onHotplugReceived(mAppConnectionHandle, displayId, connected);
2460 mScheduler->onHotplugReceived(mSfConnectionHandle, displayId, connected);
Dominik Laskowski1eba0202019-01-24 09:14:40 -08002461}
2462
Lloyd Pique99d3da52018-01-22 17:48:03 -08002463sp<DisplayDevice> SurfaceFlinger::setupNewDisplayDeviceInternal(
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -07002464 const wp<IBinder>& displayToken,
2465 std::shared_ptr<compositionengine::Display> compositionDisplay,
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002466 const DisplayDeviceState& state,
2467 const sp<compositionengine::DisplaySurface>& displaySurface,
Dominik Laskowski075d3172018-05-24 15:50:06 -07002468 const sp<IGraphicBufferProducer>& producer) {
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -07002469 auto displayId = compositionDisplay->getDisplayId();
2470 DisplayDeviceCreationArgs creationArgs(this, displayToken, compositionDisplay);
Dominik Laskowskie9774092018-12-11 10:04:24 -08002471 creationArgs.sequenceId = state.sequenceId;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002472 creationArgs.isSecure = state.isSecure;
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002473 creationArgs.displaySurface = displaySurface;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002474 creationArgs.hasWideColorGamut = false;
2475 creationArgs.supportedPerFrameMetadata = 0;
Peiyong Lin136fbbc2018-04-17 15:09:44 -07002476
Dominik Laskowski55c85402020-01-21 16:25:47 -08002477 if (const auto& physical = state.physical) {
2478 creationArgs.connectionType = physical->type;
2479 }
2480
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08002481 const bool isInternalDisplay = displayId && displayId == getInternalDisplayIdLocked();
Dominik Laskowski075d3172018-05-24 15:50:06 -07002482 creationArgs.isPrimary = isInternalDisplay;
2483
2484 if (useColorManagement && displayId) {
2485 std::vector<ColorMode> modes = getHwComposer().getColorModes(*displayId);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002486 for (ColorMode colorMode : modes) {
Peiyong Linfca547f2018-07-09 13:03:33 -07002487 if (isWideColorMode(colorMode)) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002488 creationArgs.hasWideColorGamut = true;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002489 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002490
Dominik Laskowski7e045462018-05-30 13:02:02 -07002491 std::vector<RenderIntent> renderIntents =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002492 getHwComposer().getRenderIntents(*displayId, colorMode);
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002493 creationArgs.hwcColorModes.emplace(colorMode, renderIntents);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002494 }
tangrobin6753a022018-08-10 10:58:54 +08002495 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002496
Dominik Laskowski075d3172018-05-24 15:50:06 -07002497 if (displayId) {
2498 getHwComposer().getHdrCapabilities(*displayId, &creationArgs.hdrCapabilities);
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002499 creationArgs.supportedPerFrameMetadata =
Dominik Laskowski075d3172018-05-24 15:50:06 -07002500 getHwComposer().getSupportedPerFrameMetadata(*displayId);
Chia-I Wu0f509fb2018-06-21 15:52:50 +08002501 }
Lloyd Pique99d3da52018-01-22 17:48:03 -08002502
Lloyd Pique90c115d2018-09-18 21:39:42 -07002503 auto nativeWindowSurface = getFactory().createNativeWindowSurface(producer);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002504 auto nativeWindow = nativeWindowSurface->getNativeWindow();
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002505 creationArgs.nativeWindow = nativeWindow;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002506
Lloyd Pique99d3da52018-01-22 17:48:03 -08002507 // Make sure that composition can never be stalled by a virtual display
2508 // consumer that isn't processing buffers fast enough. We have to do this
Alec Mouri0a9c7b82018-11-16 13:05:25 -08002509 // here, in case the display is composed entirely by HWC.
Dominik Laskowski281644e2018-04-19 15:47:35 -07002510 if (state.isVirtual()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002511 nativeWindow->setSwapInterval(nativeWindow.get(), 0);
2512 }
2513
Dominik Laskowski718f9602019-11-09 20:01:35 -08002514 creationArgs.physicalOrientation =
2515 isInternalDisplay ? internalDisplayOrientation : ui::ROTATION_0;
Chia-I Wua02871c2018-08-27 14:38:23 -07002516
Lloyd Pique99d3da52018-01-22 17:48:03 -08002517 // virtual displays are always considered enabled
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002518 creationArgs.initialPowerMode = state.isVirtual() ? HWC_POWER_MODE_NORMAL : HWC_POWER_MODE_OFF;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002519
Lloyd Piqueaad4ebf2019-10-03 17:58:30 -07002520 sp<DisplayDevice> display = getFactory().createDisplayDevice(creationArgs);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002521
2522 if (maxFrameBufferAcquiredBuffers >= 3) {
2523 nativeWindowSurface->preallocateBuffers();
2524 }
2525
2526 ColorMode defaultColorMode = ColorMode::NATIVE;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002527 Dataspace defaultDataSpace = Dataspace::UNKNOWN;
Lloyd Pique2eef1d22018-09-18 21:30:04 -07002528 if (display->hasWideColorGamut()) {
Lloyd Pique99d3da52018-01-22 17:48:03 -08002529 defaultColorMode = ColorMode::SRGB;
Peiyong Lin14724e62018-12-05 07:27:30 -08002530 defaultDataSpace = Dataspace::V0_SRGB;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002531 }
Lloyd Pique6a3b4462019-03-07 20:58:12 -08002532 display->getCompositionDisplay()->setColorProfile(
2533 compositionengine::Output::ColorProfile{defaultColorMode, defaultDataSpace,
2534 RenderIntent::COLORIMETRIC,
2535 Dataspace::UNKNOWN});
Dominik Laskowski075d3172018-05-24 15:50:06 -07002536 if (!state.isVirtual()) {
2537 LOG_ALWAYS_FATAL_IF(!displayId);
Ady Abraham2139f732019-11-13 18:56:40 -08002538 auto activeConfigId = HwcConfigIndexType(getHwComposer().getActiveConfigIndex(*displayId));
2539 display->setActiveConfig(activeConfigId);
Lloyd Pique3c085a02018-05-09 19:38:32 -07002540 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07002541
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002542 display->setLayerStack(state.layerStack);
2543 display->setProjection(state.orientation, state.viewport, state.frame);
2544 display->setDisplayName(state.displayName);
Lloyd Pique99d3da52018-01-22 17:48:03 -08002545
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002546 return display;
Lloyd Pique99d3da52018-01-22 17:48:03 -08002547}
2548
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002549void SurfaceFlinger::processDisplayAdded(const wp<IBinder>& displayToken,
2550 const DisplayDeviceState& state) {
2551 int width = 0;
2552 int height = 0;
2553 ui::PixelFormat pixelFormat = static_cast<ui::PixelFormat>(PIXEL_FORMAT_UNKNOWN);
2554 if (state.physical) {
2555 const auto& activeConfig =
2556 getCompositionEngine().getHwComposer().getActiveConfig(state.physical->id);
2557 width = activeConfig->getWidth();
2558 height = activeConfig->getHeight();
2559 pixelFormat = static_cast<ui::PixelFormat>(PIXEL_FORMAT_RGBA_8888);
2560 } else if (state.surface != nullptr) {
2561 int status = state.surface->query(NATIVE_WINDOW_WIDTH, &width);
2562 ALOGE_IF(status != NO_ERROR, "Unable to query width (%d)", status);
2563 status = state.surface->query(NATIVE_WINDOW_HEIGHT, &height);
2564 ALOGE_IF(status != NO_ERROR, "Unable to query height (%d)", status);
2565 int intPixelFormat;
2566 status = state.surface->query(NATIVE_WINDOW_FORMAT, &intPixelFormat);
2567 ALOGE_IF(status != NO_ERROR, "Unable to query format (%d)", status);
2568 pixelFormat = static_cast<ui::PixelFormat>(intPixelFormat);
2569 } else {
2570 // Virtual displays without a surface are dormant:
2571 // they have external state (layer stack, projection,
2572 // etc.) but no internal state (i.e. a DisplayDevice).
2573 return;
2574 }
2575
2576 compositionengine::DisplayCreationArgsBuilder builder;
2577 if (const auto& physical = state.physical) {
2578 builder.setPhysical({physical->id, physical->type});
2579 }
2580 builder.setPixels(ui::Size(width, height));
2581 builder.setPixelFormat(pixelFormat);
2582 builder.setIsSecure(state.isSecure);
2583 builder.setLayerStackId(state.layerStack);
2584 builder.setPowerAdvisor(&mPowerAdvisor);
2585 builder.setUseHwcVirtualDisplays(mUseHwcVirtualDisplays || getHwComposer().isUsingVrComposer());
2586 builder.setName(state.displayName);
2587 const auto compositionDisplay = getCompositionEngine().createDisplay(builder.build());
2588
2589 sp<compositionengine::DisplaySurface> displaySurface;
2590 sp<IGraphicBufferProducer> producer;
2591 sp<IGraphicBufferProducer> bqProducer;
2592 sp<IGraphicBufferConsumer> bqConsumer;
2593 getFactory().createBufferQueue(&bqProducer, &bqConsumer, /*consumerIsSurfaceFlinger =*/false);
2594
2595 std::optional<DisplayId> displayId = compositionDisplay->getId();
2596
2597 if (state.isVirtual()) {
2598 sp<VirtualDisplaySurface> vds =
2599 new VirtualDisplaySurface(getHwComposer(), displayId, state.surface, bqProducer,
2600 bqConsumer, state.displayName);
2601
2602 displaySurface = vds;
2603 producer = vds;
2604 } else {
2605 ALOGE_IF(state.surface != nullptr,
2606 "adding a supported display, but rendering "
2607 "surface is provided (%p), ignoring it",
2608 state.surface.get());
2609
2610 LOG_ALWAYS_FATAL_IF(!displayId);
2611 displaySurface = new FramebufferSurface(getHwComposer(), *displayId, bqConsumer,
2612 maxGraphicsWidth, maxGraphicsHeight);
2613 producer = bqProducer;
2614 }
2615
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002616 LOG_FATAL_IF(!displaySurface);
2617 const auto display = setupNewDisplayDeviceInternal(displayToken, compositionDisplay, state,
2618 displaySurface, producer);
2619 mDisplays.emplace(displayToken, display);
2620 if (!state.isVirtual()) {
2621 LOG_FATAL_IF(!displayId);
2622 dispatchDisplayHotplugEvent(displayId->value, true);
2623 }
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002624
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002625 if (display->isPrimary()) {
2626 mScheduler->onPrimaryDisplayAreaChanged(display->getWidth() * display->getHeight());
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002627 }
2628}
2629
2630void SurfaceFlinger::processDisplayRemoved(const wp<IBinder>& displayToken) {
2631 if (const auto display = getDisplayDeviceLocked(displayToken)) {
2632 // Save display ID before disconnecting.
2633 const auto displayId = display->getId();
2634 display->disconnect();
2635
2636 if (!display->isVirtual()) {
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002637 LOG_FATAL_IF(!displayId);
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002638 dispatchDisplayHotplugEvent(displayId->value, false);
2639 }
2640 }
2641
2642 mDisplays.erase(displayToken);
2643}
2644
2645void SurfaceFlinger::processDisplayChanged(const wp<IBinder>& displayToken,
2646 const DisplayDeviceState& currentState,
2647 const DisplayDeviceState& drawingState) {
2648 const sp<IBinder> currentBinder = IInterface::asBinder(currentState.surface);
2649 const sp<IBinder> drawingBinder = IInterface::asBinder(drawingState.surface);
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002650 if (currentBinder != drawingBinder || currentState.sequenceId != drawingState.sequenceId) {
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002651 // changing the surface is like destroying and recreating the DisplayDevice
2652 if (const auto display = getDisplayDeviceLocked(displayToken)) {
2653 display->disconnect();
2654 }
2655 mDisplays.erase(displayToken);
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002656 if (const auto& physical = currentState.physical) {
2657 getHwComposer().allocatePhysicalDisplay(physical->hwcDisplayId, physical->id);
2658 }
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002659 processDisplayAdded(displayToken, currentState);
Marin Shalamanov4a42d432020-02-12 20:22:26 +01002660 if (currentState.physical) {
2661 initializeDisplays();
2662 }
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002663 return;
2664 }
2665
2666 if (const auto display = getDisplayDeviceLocked(displayToken)) {
2667 if (currentState.layerStack != drawingState.layerStack) {
2668 display->setLayerStack(currentState.layerStack);
2669 }
2670 if ((currentState.orientation != drawingState.orientation) ||
2671 (currentState.viewport != drawingState.viewport) ||
2672 (currentState.frame != drawingState.frame)) {
2673 display->setProjection(currentState.orientation, currentState.viewport,
2674 currentState.frame);
2675 }
2676 if (currentState.width != drawingState.width ||
2677 currentState.height != drawingState.height) {
2678 display->setDisplaySize(currentState.width, currentState.height);
2679 if (display->isPrimary()) {
2680 mScheduler->onPrimaryDisplayAreaChanged(currentState.width * currentState.height);
2681 }
2682 }
2683 }
2684}
2685
Lloyd Pique347200f2017-12-14 17:00:15 -08002686void SurfaceFlinger::processDisplayChangesLocked() {
2687 // here we take advantage of Vector's copy-on-write semantics to
2688 // improve performance by skipping the transaction entirely when
2689 // know that the lists are identical
2690 const KeyedVector<wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
2691 const KeyedVector<wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
2692 if (!curr.isIdenticalTo(draw)) {
2693 mVisibleRegionsDirty = true;
Lloyd Pique347200f2017-12-14 17:00:15 -08002694
2695 // find the displays that were removed
2696 // (ie: in drawing state but not in current state)
2697 // also handle displays that changed
2698 // (ie: displays that are in both lists)
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002699 for (size_t i = 0; i < draw.size(); i++) {
2700 const wp<IBinder>& displayToken = draw.keyAt(i);
2701 const ssize_t j = curr.indexOfKey(displayToken);
Lloyd Pique347200f2017-12-14 17:00:15 -08002702 if (j < 0) {
2703 // in drawing state but not in current state
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002704 processDisplayRemoved(displayToken);
Lloyd Pique347200f2017-12-14 17:00:15 -08002705 } else {
2706 // this display is in both lists. see if something changed.
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002707 const DisplayDeviceState& currentState = curr[j];
2708 const DisplayDeviceState& drawingState = draw[i];
2709 processDisplayChanged(displayToken, currentState, drawingState);
Lloyd Pique347200f2017-12-14 17:00:15 -08002710 }
Lloyd Pique347200f2017-12-14 17:00:15 -08002711 }
2712
2713 // find displays that were added
2714 // (ie: in current state but not in drawing state)
Marin Shalamanov4ef04252020-02-12 17:12:22 +01002715 for (size_t i = 0; i < curr.size(); i++) {
2716 const wp<IBinder>& displayToken = curr.keyAt(i);
2717 if (draw.indexOfKey(displayToken) < 0) {
2718 processDisplayAdded(displayToken, curr[i]);
Lloyd Pique347200f2017-12-14 17:00:15 -08002719 }
2720 }
2721 }
Lloyd Piqueba04e622017-12-14 17:11:26 -08002722
2723 mDrawingState.displays = mCurrentState.displays;
Lloyd Pique347200f2017-12-14 17:00:15 -08002724}
2725
Mathias Agopian87baae12012-07-31 12:38:26 -07002726void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
Mathias Agopian3d579642009-06-04 18:46:21 -07002727{
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07002728 const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
2729
Dan Stoza7dde5992015-05-22 09:51:44 -07002730 // Notify all layers of available frames
Edgar Arriaga844fa672020-01-16 14:21:42 -08002731 mCurrentState.traverse([expectedPresentTime](Layer* layer) {
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07002732 layer->notifyAvailableFrames(expectedPresentTime);
Robert Carr2047fae2016-11-28 14:09:09 -08002733 });
Dan Stoza7dde5992015-05-22 09:51:44 -07002734
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002735 /*
2736 * Traversal of the children
2737 * (perform the transaction for each of them if needed)
2738 */
2739
Marissa Wall06255332019-03-27 13:48:27 -07002740 if ((transactionFlags & eTraversalNeeded) || mTraversalNeededMainThread) {
Edgar Arriaga844fa672020-01-16 14:21:42 -08002741 mCurrentState.traverse([&](Layer* layer) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002742 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
Robert Carr2047fae2016-11-28 14:09:09 -08002743 if (!trFlags) return;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002744
2745 const uint32_t flags = layer->doTransaction(0);
2746 if (flags & Layer::eVisibleRegion)
2747 mVisibleRegionsDirty = true;
Robert Carr720e5062018-07-30 17:45:14 -07002748
2749 if (flags & Layer::eInputInfoChanged) {
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002750 mInputInfoChanged = true;
Robert Carr720e5062018-07-30 17:45:14 -07002751 }
Robert Carr2047fae2016-11-28 14:09:09 -08002752 });
Marissa Wall06255332019-03-27 13:48:27 -07002753 mTraversalNeededMainThread = false;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002754 }
2755
2756 /*
Mathias Agopian3559b072012-08-15 13:46:03 -07002757 * Perform display own transactions if needed
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002758 */
2759
Mathias Agopiane57f2922012-08-09 16:29:12 -07002760 if (transactionFlags & eDisplayTransactionNeeded) {
Lloyd Pique347200f2017-12-14 17:00:15 -08002761 processDisplayChangesLocked();
Lloyd Piqueba04e622017-12-14 17:11:26 -08002762 processDisplayHotplugEventsLocked();
Mathias Agopian3559b072012-08-15 13:46:03 -07002763 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002764
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002765 if (transactionFlags & (eDisplayLayerStackChanged|eDisplayTransactionNeeded)) {
Mathias Agopian84300952012-11-21 16:02:13 -08002766 // The transform hint might have changed for some layers
2767 // (either because a display has changed, or because a layer
2768 // as changed).
2769 //
2770 // Walk through all the layers in currentLayers,
2771 // and update their transform hint.
2772 //
2773 // If a layer is visible only on a single display, then that
2774 // display is used to calculate the hint, otherwise we use the
2775 // default display.
2776 //
Lloyd Piquec29e4c62019-03-07 21:48:19 -08002777 // NOTE: we do this here, rather than when presenting the display so that
Mathias Agopian84300952012-11-21 16:02:13 -08002778 // the hint is set before we acquire a buffer from the surface texture.
2779 //
2780 // NOTE: layer transactions have taken place already, so we use their
2781 // drawing state. However, SurfaceFlinger's own transaction has not
2782 // happened yet, so we must use the current state layer list
2783 // (soon to become the drawing state list).
2784 //
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002785 sp<const DisplayDevice> hintDisplay;
Mathias Agopian84300952012-11-21 16:02:13 -08002786 uint32_t currentlayerStack = 0;
Robert Carr2047fae2016-11-28 14:09:09 -08002787 bool first = true;
Edgar Arriaga844fa672020-01-16 14:21:42 -08002788 mCurrentState.traverse([&](Layer* layer) {
Mathias Agopian84300952012-11-21 16:02:13 -08002789 // NOTE: we rely on the fact that layers are sorted by
2790 // layerStack first (so we don't have to traverse the list
2791 // of displays for every layer).
Robert Carr1f0a16a2016-10-24 16:27:39 -07002792 uint32_t layerStack = layer->getLayerStack();
Robert Carr2047fae2016-11-28 14:09:09 -08002793 if (first || currentlayerStack != layerStack) {
Mathias Agopian84300952012-11-21 16:02:13 -08002794 currentlayerStack = layerStack;
2795 // figure out if this layerstack is mirrored
2796 // (more than one display) if so, pick the default display,
2797 // if not, pick the only display it's on.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002798 hintDisplay = nullptr;
2799 for (const auto& [token, display] : mDisplays) {
Lloyd Piqueef36b002019-01-23 17:52:04 -08002800 if (display->getCompositionDisplay()
2801 ->belongsInOutput(layer->getLayerStack(),
2802 layer->getPrimaryDisplayOnly())) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002803 if (hintDisplay) {
2804 hintDisplay = nullptr;
Mathias Agopian84300952012-11-21 16:02:13 -08002805 break;
Dominik Laskowskieecd6592018-05-29 10:25:41 -07002806 } else {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002807 hintDisplay = display;
Mathias Agopian84300952012-11-21 16:02:13 -08002808 }
2809 }
2810 }
2811 }
Chet Haase91d25932013-04-11 15:24:55 -07002812
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002813 if (!hintDisplay) {
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002814 // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
2815 // redraw after transform hint changes. See bug 8508397.
Robert Carr56a0b9a2017-12-04 16:06:13 -08002816
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002817 // could be null when this layer is using a layerStack
2818 // that is not visible on any display. Also can occur at
2819 // screen off/on times.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002820 hintDisplay = getDefaultDisplayDeviceLocked();
Mathias Agopian84300952012-11-21 16:02:13 -08002821 }
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002822
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002823 // could be null if there is no display available at all to get
Lloyd Piqued432a7c2018-03-23 16:05:31 -07002824 // the transform hint from.
Dominik Laskowski9fae1022018-05-29 13:17:40 -07002825 if (hintDisplay) {
2826 layer->updateTransformHint(hintDisplay);
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08002827 }
Robert Carr2047fae2016-11-28 14:09:09 -08002828
2829 first = false;
2830 });
Mathias Agopian84300952012-11-21 16:02:13 -08002831 }
2832
2833
Mathias Agopian3559b072012-08-15 13:46:03 -07002834 /*
2835 * Perform our own transaction if needed
2836 */
Robert Carr1f0a16a2016-10-24 16:27:39 -07002837
2838 if (mLayersAdded) {
2839 mLayersAdded = false;
2840 // Layers have been added.
Mathias Agopian3559b072012-08-15 13:46:03 -07002841 mVisibleRegionsDirty = true;
2842 }
2843
2844 // some layers might have been removed, so
2845 // we need to update the regions they're exposing.
2846 if (mLayersRemoved) {
2847 mLayersRemoved = false;
2848 mVisibleRegionsDirty = true;
Robert Carr2047fae2016-11-28 14:09:09 -08002849 mDrawingState.traverseInZOrder([&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07002850 if (mLayersPendingRemoval.indexOf(layer) >= 0) {
Mathias Agopian3559b072012-08-15 13:46:03 -07002851 // this layer is not visible anymore
Robert Carr1f0a16a2016-10-24 16:27:39 -07002852 Region visibleReg;
Vishnu Nair4351ad52019-02-11 14:13:02 -08002853 visibleReg.set(layer->getScreenBounds());
Chia-I Wuab0c3192017-08-01 11:29:00 -07002854 invalidateLayerStack(layer, visibleReg);
Mathias Agopian0aa758d2009-04-22 15:23:34 -07002855 }
Robert Carr2047fae2016-11-28 14:09:09 -08002856 });
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002857 }
2858
Vishnu Nairec0ab382019-02-13 15:32:56 -08002859 commitInputWindowCommands();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002860 commitTransaction();
Riley Andrews03414a12014-07-01 14:22:59 -07002861}
2862
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002863void SurfaceFlinger::updateInputFlinger() {
Robert Carr720e5062018-07-30 17:45:14 -07002864 ATRACE_CALL();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002865 if (!mInputFlinger) {
Vishnu Nairde19f852018-12-18 16:11:53 -08002866 return;
2867 }
2868
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002869 if (mVisibleRegionsDirty || mInputInfoChanged) {
2870 mInputInfoChanged = false;
2871 updateInputWindowInfo();
chaviw95ef3c42019-02-14 10:55:09 -08002872 } else if (mInputWindowCommands.syncInputWindows) {
2873 // If the caller requested to sync input windows, but there are no
2874 // changes to input windows, notify immediately.
2875 setInputWindowsFinished();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002876 }
2877
Arthur Hung6cbb9752019-09-05 16:38:18 +08002878 mInputWindowCommands.clear();
Vishnu Nair6194e2e2019-02-06 12:58:39 -08002879}
2880
2881void SurfaceFlinger::updateInputWindowInfo() {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002882 std::vector<InputWindowInfo> inputHandles;
Robert Carr720e5062018-07-30 17:45:14 -07002883
Robert Carra1257842020-01-31 13:48:28 -08002884 // We use a simple caching algorithm here. mInputDirty begins as true,
2885 // after we call setInputWindows we set it to false, so
2886 // in the future we wont call it again.. We set input dirty to true again
2887 // when any layer that hasInput() has a transaction performed on it
2888 // or when any parent or relative parent of such a layer has a transaction
2889 // performed on it. Not all of these transactions will really result in
2890 // input changes but all input changes will spring from these transactions
2891 // so the cache is safe but not optimal. It seems like it might be annoyingly
2892 // costly to cache and comapre the actual InputWindowHandle vector though.
Robert Carr0854b992020-03-11 12:09:42 -07002893 if (!mInputDirty && !mInputWindowCommands.syncInputWindows) {
Robert Carra1257842020-01-31 13:48:28 -08002894 return;
2895 }
2896
Robert Carr720e5062018-07-30 17:45:14 -07002897 mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
2898 if (layer->hasInput()) {
Vishnu Nair51625fa2018-12-06 13:54:33 -08002899 // When calculating the screen bounds we ignore the transparent region since it may
2900 // result in an unwanted offset.
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08002901 inputHandles.push_back(layer->fillInputInfo());
Robert Carr720e5062018-07-30 17:45:14 -07002902 }
2903 });
chaviw291d88a2019-02-14 10:33:58 -08002904
2905 mInputFlinger->setInputWindows(inputHandles,
2906 mInputWindowCommands.syncInputWindows ? mSetInputWindowsListener
2907 : nullptr);
Robert Carra1257842020-01-31 13:48:28 -08002908
2909 mInputDirty = false;
Robert Carr720e5062018-07-30 17:45:14 -07002910}
2911
Vishnu Nairec0ab382019-02-13 15:32:56 -08002912void SurfaceFlinger::commitInputWindowCommands() {
Rob Carr9a2cc992020-03-06 12:44:45 -08002913 mInputWindowCommands.merge(mPendingInputWindowCommands);
Vishnu Nairec0ab382019-02-13 15:32:56 -08002914 mPendingInputWindowCommands.clear();
2915}
2916
Riley Andrews03414a12014-07-01 14:22:59 -07002917void SurfaceFlinger::updateCursorAsync()
2918{
Lloyd Piquec7b0c752019-03-07 20:59:59 -08002919 compositionengine::CompositionRefreshArgs refreshArgs;
2920 for (const auto& [_, display] : mDisplays) {
2921 if (display->getId()) {
2922 refreshArgs.outputs.push_back(display->getCompositionDisplay());
Riley Andrews03414a12014-07-01 14:22:59 -07002923 }
2924 }
Lloyd Piquec7b0c752019-03-07 20:59:59 -08002925
2926 mCompositionEngine->updateCursorAsync(refreshArgs);
Mathias Agopian4fec8732012-06-29 14:12:52 -07002927}
2928
Ady Abraham2139f732019-11-13 18:56:40 -08002929void SurfaceFlinger::changeRefreshRate(const RefreshRate& refreshRate,
Ady Abraham8a82ba62020-01-17 12:43:17 -08002930 Scheduler::ConfigEvent event) NO_THREAD_SAFETY_ANALYSIS {
2931 // If this is called from the main thread mStateLock must be locked before
2932 // Currently the only way to call this function from the main thread is from
2933 // Sheduler::chooseRefreshRateForContent
2934
2935 ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
Ady Abraham2139f732019-11-13 18:56:40 -08002936 changeRefreshRateLocked(refreshRate, event);
2937}
2938
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002939void SurfaceFlinger::initScheduler(DisplayId primaryDisplayId) {
2940 if (mScheduler) {
2941 // In practice it's not allowed to hotplug in/out the primary display once it's been
2942 // connected during startup, but some tests do it, so just warn and return.
2943 ALOGW("Can't re-init scheduler");
2944 return;
2945 }
2946
Ady Abraham2139f732019-11-13 18:56:40 -08002947 auto currentConfig = HwcConfigIndexType(getHwComposer().getActiveConfigIndex(primaryDisplayId));
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002948 mRefreshRateConfigs =
Ana Krulec3f6a2062020-01-23 15:48:01 -08002949 std::make_unique<scheduler::RefreshRateConfigs>(getHwComposer().getConfigs(
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002950 primaryDisplayId),
2951 currentConfig);
2952 mRefreshRateStats =
2953 std::make_unique<scheduler::RefreshRateStats>(*mRefreshRateConfigs, *mTimeStats,
2954 currentConfig, HWC_POWER_MODE_OFF);
2955 mRefreshRateStats->setConfigMode(currentConfig);
2956
Ady Abraham9e16a482019-12-03 17:19:41 -08002957 mPhaseConfiguration = getFactory().createPhaseConfiguration(*mRefreshRateConfigs);
2958
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002959 // start the EventThread
2960 mScheduler =
2961 getFactory().createScheduler([this](bool enabled) { setPrimaryVsyncEnabled(enabled); },
Ady Abraham3a77a7b2019-12-02 18:46:59 -08002962 *mRefreshRateConfigs, *this);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002963 mAppConnectionHandle =
Ady Abraham9e16a482019-12-03 17:19:41 -08002964 mScheduler->createConnection("app", mPhaseConfiguration->getCurrentOffsets().late.app,
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002965 impl::EventThread::InterceptVSyncsCallback());
2966 mSfConnectionHandle =
Ady Abraham9e16a482019-12-03 17:19:41 -08002967 mScheduler->createConnection("sf", mPhaseConfiguration->getCurrentOffsets().late.sf,
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002968 [this](nsecs_t timestamp) {
2969 mInterceptor->saveVSyncEvent(timestamp);
2970 });
2971
2972 mEventQueue->setEventConnection(mScheduler->getEventConnection(mSfConnectionHandle));
2973 mVSyncModulator.emplace(*mScheduler, mAppConnectionHandle, mSfConnectionHandle,
Ady Abraham9e16a482019-12-03 17:19:41 -08002974 mPhaseConfiguration->getCurrentOffsets());
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002975
2976 mRegionSamplingThread =
2977 new RegionSamplingThread(*this, *mScheduler,
2978 RegionSamplingThread::EnvironmentTimingTunables());
Alec Mouri60aee1c2019-10-28 16:18:59 -07002979 // Dispatch a config change request for the primary display on scheduler
2980 // initialization, so that the EventThreads always contain a reference to a
2981 // prior configuration.
2982 //
2983 // This is a bit hacky, but this avoids a back-pointer into the main SF
2984 // classes from EventThread, and there should be no run-time binder cost
2985 // anyway since there are no connected apps at this point.
2986 const nsecs_t vsyncPeriod =
Ady Abrahamabc27602020-04-08 17:20:29 -07002987 mRefreshRateConfigs->getRefreshRateFromConfigId(currentConfig).getVsyncPeriod();
Alec Mouri60aee1c2019-10-28 16:18:59 -07002988 mScheduler->onConfigChanged(mAppConnectionHandle, primaryDisplayId.value, currentConfig,
2989 vsyncPeriod);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07002990}
2991
Mathias Agopian4fec8732012-06-29 14:12:52 -07002992void SurfaceFlinger::commitTransaction()
2993{
Vishnu Nair60db8c02020-04-02 11:55:16 -07002994 commitTransactionLocked();
Jamie Gennis2d5e2302012-10-15 18:24:43 -07002995 mTransactionPending = false;
2996 mAnimTransactionPending = false;
Mathias Agopian4fec8732012-06-29 14:12:52 -07002997 mTransactionCV.broadcast();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002998}
2999
Lloyd Pique58e24a32019-08-01 15:50:14 -07003000void SurfaceFlinger::commitTransactionLocked() {
3001 if (!mLayersPendingRemoval.isEmpty()) {
3002 // Notify removed layers now that they can't be drawn from
3003 for (const auto& l : mLayersPendingRemoval) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003004 recordBufferingStats(l->getName(), l->getOccupancyHistory(true));
Lloyd Pique58e24a32019-08-01 15:50:14 -07003005
3006 // Ensure any buffers set to display on any children are released.
3007 if (l->isRemovedFromCurrentState()) {
3008 l->latchAndReleaseBuffer();
3009 }
3010
3011 // If the layer has been removed and has no parent, then it will not be reachable
3012 // when traversing layers on screen. Add the layer to the offscreenLayers set to
3013 // ensure we can copy its current to drawing state.
3014 if (!l->getParent()) {
3015 mOffscreenLayers.emplace(l.get());
3016 }
3017 }
3018 mLayersPendingRemoval.clear();
3019 }
3020
3021 // If this transaction is part of a window animation then the next frame
3022 // we composite should be considered an animation as well.
3023 mAnimCompositionPending = mAnimTransactionPending;
3024
3025 mDrawingState = mCurrentState;
3026 // clear the "changed" flags in current state
3027 mCurrentState.colorMatrixChanged = false;
3028
Edgar Arriaga844fa672020-01-16 14:21:42 -08003029 mDrawingState.traverse([&](Layer* layer) {
Lloyd Pique58e24a32019-08-01 15:50:14 -07003030 layer->commitChildList();
3031
3032 // If the layer can be reached when traversing mDrawingState, then the layer is no
3033 // longer offscreen. Remove the layer from the offscreenLayer set.
3034 if (mOffscreenLayers.count(layer)) {
3035 mOffscreenLayers.erase(layer);
3036 }
3037 });
3038
3039 commitOffscreenLayers();
Edgar Arriaga844fa672020-01-16 14:21:42 -08003040 mDrawingState.traverse([&](Layer* layer) { layer->updateMirrorInfo(); });
Lloyd Pique58e24a32019-08-01 15:50:14 -07003041}
3042
Nataniel Borges2b796da2019-02-15 13:32:18 -08003043void SurfaceFlinger::withTracingLock(std::function<void()> lockedOperation) {
3044 if (mTracingEnabledChanged) {
3045 mTracingEnabled = mTracing.isEnabled();
3046 mTracingEnabledChanged = false;
3047 }
3048
3049 // Synchronize with Tracing thread
3050 std::unique_lock<std::mutex> lock;
3051 if (mTracingEnabled) {
3052 lock = std::unique_lock<std::mutex>(mDrawingStateLock);
3053 }
3054
3055 lockedOperation();
3056
3057 // Synchronize with Tracing thread
3058 if (mTracingEnabled) {
3059 lock.unlock();
3060 }
3061}
3062
chaviw74d90ad2019-04-26 14:45:26 -07003063void SurfaceFlinger::commitOffscreenLayers() {
3064 for (Layer* offscreenLayer : mOffscreenLayers) {
Edgar Arriaga844fa672020-01-16 14:21:42 -08003065 offscreenLayer->traverse(LayerVector::StateSet::Drawing, [](Layer* layer) {
chaviw74d90ad2019-04-26 14:45:26 -07003066 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
3067 if (!trFlags) return;
3068
3069 layer->doTransaction(0);
3070 layer->commitChildList();
3071 });
3072 }
3073}
3074
Chia-I Wuab0c3192017-08-01 11:29:00 -07003075void SurfaceFlinger::invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003076 for (const auto& [token, displayDevice] : mDisplays) {
3077 auto display = displayDevice->getCompositionDisplay();
Lloyd Piqueef36b002019-01-23 17:52:04 -08003078 if (display->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07003079 display->editState().dirtyRegion.orSelf(dirty);
Mathias Agopian92a979a2012-08-02 18:32:23 -07003080 }
3081 }
Mathias Agopian87baae12012-07-31 12:38:26 -07003082}
3083
Dan Stoza6b9454d2014-11-07 16:00:59 -08003084bool SurfaceFlinger::handlePageFlip()
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003085{
Ady Abraham09bd3922019-04-08 10:44:56 -07003086 ATRACE_CALL();
Dan Stoza9e56aa02015-11-02 13:00:03 -08003087 ALOGV("handlePageFlip");
3088
Brian Andersond6927fb2016-07-23 23:37:30 -07003089 nsecs_t latchTime = systemTime();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003090
Mathias Agopian4fec8732012-06-29 14:12:52 -07003091 bool visibleRegions = false;
Dan Stoza6b9454d2014-11-07 16:00:59 -08003092 bool frameQueued = false;
Mike Stroyan0cd76192017-04-20 12:10:48 -06003093 bool newDataLatched = false;
Eric Penner51c59cd2014-07-28 19:51:58 -07003094
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003095 const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
3096
Eric Penner51c59cd2014-07-28 19:51:58 -07003097 // Store the set of layers that need updates. This set must not change as
3098 // buffers are being latched, as this could result in a deadlock.
3099 // Example: Two producers share the same command stream and:
3100 // 1.) Layer 0 is latched
3101 // 2.) Layer 0 gets a new frame
3102 // 2.) Layer 1 gets a new frame
3103 // 3.) Layer 1 is latched.
3104 // Display is now waiting on Layer 1's frame, which is behind layer 0's
3105 // second frame. But layer 0's second frame could be waiting on display.
Edgar Arriaga844fa672020-01-16 14:21:42 -08003106 mDrawingState.traverse([&](Layer* layer) {
Marissa Wallfd668622018-05-10 10:21:13 -07003107 if (layer->hasReadyFrame()) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08003108 frameQueued = true;
Ana Krulec010d2192018-10-08 06:29:54 -07003109 if (layer->shouldPresentNow(expectedPresentTime)) {
Robert Carr2047fae2016-11-28 14:09:09 -08003110 mLayersWithQueuedFrames.push_back(layer);
Dan Stozaee44edd2015-03-23 15:50:23 -07003111 } else {
Ady Abraham09bd3922019-04-08 10:44:56 -07003112 ATRACE_NAME("!layer->shouldPresentNow()");
Dan Stozaee44edd2015-03-23 15:50:23 -07003113 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08003114 }
Dan Stozaee44edd2015-03-23 15:50:23 -07003115 } else {
3116 layer->useEmptyDamage();
Dan Stoza6b9454d2014-11-07 16:00:59 -08003117 }
Robert Carr2047fae2016-11-28 14:09:09 -08003118 });
3119
chaviw49a108c2019-08-12 11:23:06 -07003120 // The client can continue submitting buffers for offscreen layers, but they will not
3121 // be shown on screen. Therefore, we need to latch and release buffers of offscreen
3122 // layers to ensure dequeueBuffer doesn't block indefinitely.
3123 for (Layer* offscreenLayer : mOffscreenLayers) {
Edgar Arriaga844fa672020-01-16 14:21:42 -08003124 offscreenLayer->traverse(LayerVector::StateSet::Drawing,
chaviw49a108c2019-08-12 11:23:06 -07003125 [&](Layer* l) { l->latchAndReleaseBuffer(); });
3126 }
3127
Lloyd Piquef2c79392018-12-20 16:23:33 -08003128 if (!mLayersWithQueuedFrames.empty()) {
3129 // mStateLock is needed for latchBuffer as LayerRejecter::reject()
3130 // writes to Layer current state. See also b/119481871
3131 Mutex::Autolock lock(mStateLock);
3132
3133 for (auto& layer : mLayersWithQueuedFrames) {
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003134 if (layer->latchBuffer(visibleRegions, latchTime, expectedPresentTime)) {
Vishnu Nair6194e2e2019-02-06 12:58:39 -08003135 mLayersPendingRefresh.push_back(layer);
3136 }
Lloyd Piquef2c79392018-12-20 16:23:33 -08003137 layer->useSurfaceDamage();
Lloyd Piquef2c79392018-12-20 16:23:33 -08003138 if (layer->isBufferLatched()) {
3139 newDataLatched = true;
3140 }
Mike Stroyan0cd76192017-04-20 12:10:48 -06003141 }
Mathias Agopian4fec8732012-06-29 14:12:52 -07003142 }
Mathias Agopian4da75192010-08-10 17:19:56 -07003143
Mathias Agopian3b1d2b62012-07-11 13:48:17 -07003144 mVisibleRegionsDirty |= visibleRegions;
Dan Stoza6b9454d2014-11-07 16:00:59 -08003145
3146 // If we will need to wake up at some time in the future to deal with a
3147 // queued frame that shouldn't be displayed during this vsync period, wake
3148 // up during the next vsync period to check again.
Chia-I Wua36bf922017-06-30 12:51:05 -07003149 if (frameQueued && (mLayersWithQueuedFrames.empty() || !newDataLatched)) {
Dan Stoza6b9454d2014-11-07 16:00:59 -08003150 signalLayerUpdate();
3151 }
3152
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08003153 // enter boot animation on first buffer latch
3154 if (CC_UNLIKELY(mBootStage == BootStage::BOOTLOADER && newDataLatched)) {
3155 ALOGI("Enter boot animation");
3156 mBootStage = BootStage::BOOTANIMATION;
3157 }
3158
Edgar Arriaga844fa672020-01-16 14:21:42 -08003159 mDrawingState.traverse([&](Layer* layer) { layer->updateCloneBufferInfo(); });
chaviw74b03172019-08-19 11:09:03 -07003160
Dan Stoza6b9454d2014-11-07 16:00:59 -08003161 // Only continue with the refresh if there is actually new work to do
Mike Stroyan0cd76192017-04-20 12:10:48 -06003162 return !mLayersWithQueuedFrames.empty() && newDataLatched;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003163}
3164
Mathias Agopianad456f92011-01-13 17:53:01 -08003165void SurfaceFlinger::invalidateHwcGeometry()
3166{
Dan Stoza9e56aa02015-11-02 13:00:03 -08003167 mGeometryInvalid = true;
Mathias Agopianad456f92011-01-13 17:53:01 -08003168}
3169
Robert Carrc0df3122019-04-11 13:18:21 -07003170status_t SurfaceFlinger::addClientLayer(const sp<Client>& client, const sp<IBinder>& handle,
3171 const sp<IGraphicBufferProducer>& gbc, const sp<Layer>& lbc,
3172 const sp<IBinder>& parentHandle,
3173 const sp<Layer>& parentLayer, bool addToCurrentState) {
Dan Stoza7d89d062015-04-30 13:29:25 -07003174 // add this layer to the current state list
3175 {
3176 Mutex::Autolock _l(mStateLock);
Robert Carrc0df3122019-04-11 13:18:21 -07003177 sp<Layer> parent;
3178 if (parentHandle != nullptr) {
3179 parent = fromHandle(parentHandle);
3180 if (parent == nullptr) {
3181 return NAME_NOT_FOUND;
3182 }
3183 } else {
3184 parent = parentLayer;
3185 }
3186
Ady Abraham0a525092020-03-03 12:51:24 -08003187 if (mNumLayers >= ISurfaceComposer::MAX_LAYERS) {
chaviweadf0d42019-08-12 13:28:29 -07003188 ALOGE("AddClientLayer failed, mNumLayers (%zu) >= MAX_LAYERS (%zu)", mNumLayers.load(),
Ady Abraham0a525092020-03-03 12:51:24 -08003189 ISurfaceComposer::MAX_LAYERS);
Dan Stoza7d89d062015-04-30 13:29:25 -07003190 return NO_MEMORY;
3191 }
Robert Carrc0df3122019-04-11 13:18:21 -07003192
3193 mLayersByLocalBinderToken.emplace(handle->localBinder(), lbc);
3194
Robert Carrb89ea9d2018-12-10 13:01:14 -08003195 if (parent == nullptr && addToCurrentState) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003196 mCurrentState.layersSortedByZ.add(lbc);
chaviwac841852019-01-16 16:04:43 -08003197 } else if (parent == nullptr) {
3198 lbc->onRemovedFromCurrentState();
3199 } else if (parent->isRemovedFromCurrentState()) {
3200 parent->addChild(lbc);
3201 lbc->onRemovedFromCurrentState();
Robert Carrb89ea9d2018-12-10 13:01:14 -08003202 } else {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003203 parent->addChild(lbc);
3204 }
Chia-I Wu98f1c102017-05-30 14:54:08 -07003205
Yiwei Zhang243b3782018-05-15 17:40:04 -07003206 if (gbc != nullptr) {
3207 mGraphicBufferProducerList.insert(IInterface::asBinder(gbc).get());
3208 LOG_ALWAYS_FATAL_IF(mGraphicBufferProducerList.size() >
3209 mMaxGraphicBufferProducerListSize,
3210 "Suspected IGBP leak: %zu IGBPs (%zu max), %zu Layers",
3211 mGraphicBufferProducerList.size(),
chaviweadf0d42019-08-12 13:28:29 -07003212 mMaxGraphicBufferProducerListSize, mNumLayers.load());
Yiwei Zhang243b3782018-05-15 17:40:04 -07003213 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07003214 mLayersAdded = true;
Dan Stoza7d89d062015-04-30 13:29:25 -07003215 }
3216
Mathias Agopian96f08192010-06-02 23:28:45 -07003217 // attach this layer to the client
Mathias Agopianac9fa422013-02-11 16:40:36 -08003218 client->attachLayer(handle, lbc);
Mathias Agopian4f113742011-05-03 16:21:41 -07003219
Dan Stoza7d89d062015-04-30 13:29:25 -07003220 return NO_ERROR;
Mathias Agopian96f08192010-06-02 23:28:45 -07003221}
3222
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08003223uint32_t SurfaceFlinger::peekTransactionFlags() {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003224 return mTransactionFlags;
Mathias Agopiandea20b12011-05-03 17:04:02 -07003225}
3226
Mathias Agopian3f844832013-08-07 21:24:32 -07003227uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003228 return mTransactionFlags.fetch_and(~flags) & flags;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003229}
3230
Mathias Agopian3f844832013-08-07 21:24:32 -07003231uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) {
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003232 return setTransactionFlags(flags, Scheduler::TransactionStart::NORMAL);
Dan Stoza84d619e2018-03-28 17:07:36 -07003233}
3234
3235uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags,
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003236 Scheduler::TransactionStart transactionStart) {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07003237 uint32_t old = mTransactionFlags.fetch_or(flags);
Dominik Laskowskieddeda12019-07-19 11:54:13 -07003238 mVSyncModulator->setTransactionStart(transactionStart);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003239 if ((old & flags)==0) { // wake the server up
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08003240 signalTransaction();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003241 }
3242 return old;
3243}
3244
Marissa Wall713b63f2018-10-17 15:42:43 -07003245bool SurfaceFlinger::flushTransactionQueues() {
Valerie Haufce31b82019-04-30 16:41:14 -07003246 // to prevent onHandleDestroyed from being called while the lock is held,
3247 // we must keep a copy of the transactions (specifically the composer
3248 // states) around outside the scope of the lock
3249 std::vector<const TransactionState> transactions;
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003250 bool flushedATransaction = false;
Valerie Haufce31b82019-04-30 16:41:14 -07003251 {
3252 Mutex::Autolock _l(mStateLock);
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003253
Valerie Haufce31b82019-04-30 16:41:14 -07003254 auto it = mTransactionQueues.begin();
3255 while (it != mTransactionQueues.end()) {
3256 auto& [applyToken, transactionQueue] = *it;
Marissa Wall713b63f2018-10-17 15:42:43 -07003257
Valerie Haufce31b82019-04-30 16:41:14 -07003258 while (!transactionQueue.empty()) {
3259 const auto& transaction = transactionQueue.front();
3260 if (!transactionIsReadyToBeApplied(transaction.desiredPresentTime,
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003261 true /* useCachedExpectedPresentTime */,
Valerie Haufce31b82019-04-30 16:41:14 -07003262 transaction.states)) {
3263 setTransactionFlags(eTransactionFlushNeeded);
3264 break;
3265 }
3266 transactions.push_back(transaction);
3267 applyTransactionState(transaction.states, transaction.displays, transaction.flags,
3268 mPendingInputWindowCommands, transaction.desiredPresentTime,
Valerie Hau9dab9732019-08-20 09:29:25 -07003269 transaction.buffer, transaction.postTime,
3270 transaction.privileged, transaction.hasListenerCallbacks,
3271 transaction.listenerCallbacks, /*isMainThread*/ true);
Valerie Haufce31b82019-04-30 16:41:14 -07003272 transactionQueue.pop();
3273 flushedATransaction = true;
Marissa Wall713b63f2018-10-17 15:42:43 -07003274 }
Marissa Wall713b63f2018-10-17 15:42:43 -07003275
Valerie Haufce31b82019-04-30 16:41:14 -07003276 if (transactionQueue.empty()) {
3277 it = mTransactionQueues.erase(it);
3278 mTransactionCV.broadcast();
3279 } else {
Valerie Haue5562ec2019-05-14 12:39:16 -07003280 it = std::next(it, 1);
Valerie Haufce31b82019-04-30 16:41:14 -07003281 }
Valerie Hauf6016b62019-03-28 10:49:59 -07003282 }
Marissa Wall713b63f2018-10-17 15:42:43 -07003283 }
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003284 return flushedATransaction;
3285}
3286
3287bool SurfaceFlinger::transactionFlushNeeded() {
3288 return !mTransactionQueues.empty();
Marissa Wall713b63f2018-10-17 15:42:43 -07003289}
3290
chaviwca27f252018-02-06 16:46:39 -08003291
Marissa Wall17b4e452018-12-26 16:32:34 -08003292bool SurfaceFlinger::transactionIsReadyToBeApplied(int64_t desiredPresentTime,
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003293 bool useCachedExpectedPresentTime,
Marissa Wall17b4e452018-12-26 16:32:34 -08003294 const Vector<ComposerState>& states) {
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003295 if (!useCachedExpectedPresentTime)
3296 populateExpectedPresentTime();
3297
3298 const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
Marissa Wall17b4e452018-12-26 16:32:34 -08003299 // Do not present if the desiredPresentTime has not passed unless it is more than one second
3300 // in the future. We ignore timestamps more than 1 second in the future for stability reasons.
3301 if (desiredPresentTime >= 0 && desiredPresentTime >= expectedPresentTime &&
3302 desiredPresentTime < expectedPresentTime + s2ns(1)) {
3303 return false;
3304 }
3305
Marissa Wall713b63f2018-10-17 15:42:43 -07003306 for (const ComposerState& state : states) {
3307 const layer_state_t& s = state.state;
3308 if (!(s.what & layer_state_t::eAcquireFenceChanged)) {
3309 continue;
3310 }
3311 if (s.acquireFence && s.acquireFence->getStatus() == Fence::Status::Unsignaled) {
Marissa Wall17b4e452018-12-26 16:32:34 -08003312 return false;
Marissa Wall713b63f2018-10-17 15:42:43 -07003313 }
3314 }
Marissa Wall17b4e452018-12-26 16:32:34 -08003315 return true;
Marissa Wall713b63f2018-10-17 15:42:43 -07003316}
3317
Valerie Hau9dab9732019-08-20 09:29:25 -07003318void SurfaceFlinger::setTransactionState(
3319 const Vector<ComposerState>& states, const Vector<DisplayState>& displays, uint32_t flags,
3320 const sp<IBinder>& applyToken, const InputWindowCommands& inputWindowCommands,
3321 int64_t desiredPresentTime, const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
3322 const std::vector<ListenerCallbacks>& listenerCallbacks) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003323 ATRACE_CALL();
Robert Carr14167e02019-02-13 13:50:55 -08003324
Valerie Haubc6ddb12019-03-08 11:10:15 -08003325 const int64_t postTime = systemTime();
3326
Robert Carr14167e02019-02-13 13:50:55 -08003327 bool privileged = callingThreadHasUnscopedSurfaceFlingerAccess();
3328
Mathias Agopian698c0872011-06-28 19:09:31 -07003329 Mutex::Autolock _l(mStateLock);
Mathias Agopiane57f2922012-08-09 16:29:12 -07003330
Marissa Wall713b63f2018-10-17 15:42:43 -07003331 // If its TransactionQueue already has a pending TransactionState or if it is pending
Valerie Hauf6016b62019-03-28 10:49:59 -07003332 auto itr = mTransactionQueues.find(applyToken);
3333 // if this is an animation frame, wait until prior animation frame has
3334 // been applied by SF
3335 if (flags & eAnimation) {
3336 while (itr != mTransactionQueues.end()) {
3337 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
3338 if (CC_UNLIKELY(err != NO_ERROR)) {
3339 ALOGW_IF(err == TIMED_OUT,
3340 "setTransactionState timed out "
3341 "waiting for animation frame to apply");
3342 break;
3343 }
3344 itr = mTransactionQueues.find(applyToken);
3345 }
3346 }
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07003347
3348 // Expected present time is computed and cached on invalidate, so it may be stale.
3349 if (itr != mTransactionQueues.end() || !transactionIsReadyToBeApplied(
3350 desiredPresentTime, false /* useCachedExpectedPresentTime */, states)) {
Robert Carr14167e02019-02-13 13:50:55 -08003351 mTransactionQueues[applyToken].emplace(states, displays, flags, desiredPresentTime,
Valerie Hau9dab9732019-08-20 09:29:25 -07003352 uncacheBuffer, postTime, privileged,
3353 hasListenerCallbacks, listenerCallbacks);
Marissa Walle6e3c0d2019-03-29 10:28:30 -07003354 setTransactionFlags(eTransactionFlushNeeded);
Marissa Wall713b63f2018-10-17 15:42:43 -07003355 return;
3356 }
3357
Valerie Haubc6ddb12019-03-08 11:10:15 -08003358 applyTransactionState(states, displays, flags, inputWindowCommands, desiredPresentTime,
Valerie Hau9dab9732019-08-20 09:29:25 -07003359 uncacheBuffer, postTime, privileged, hasListenerCallbacks,
3360 listenerCallbacks);
Marissa Wall713b63f2018-10-17 15:42:43 -07003361}
3362
Valerie Hau9dab9732019-08-20 09:29:25 -07003363void SurfaceFlinger::applyTransactionState(
3364 const Vector<ComposerState>& states, const Vector<DisplayState>& displays, uint32_t flags,
3365 const InputWindowCommands& inputWindowCommands, const int64_t desiredPresentTime,
3366 const client_cache_t& uncacheBuffer, const int64_t postTime, bool privileged,
3367 bool hasListenerCallbacks, const std::vector<ListenerCallbacks>& listenerCallbacks,
3368 bool isMainThread) {
Marissa Wall713b63f2018-10-17 15:42:43 -07003369 uint32_t transactionFlags = 0;
3370
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003371 if (flags & eAnimation) {
3372 // For window updates that are part of an animation we must wait for
3373 // previous animation "frames" to be handled.
Valerie Hau38448362019-04-11 14:49:33 -07003374 while (!isMainThread && mAnimTransactionPending) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003375 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003376 if (CC_UNLIKELY(err != NO_ERROR)) {
3377 // just in case something goes wrong in SF, return to the
Jamie Gennis7c41bf72012-10-17 09:29:47 -07003378 // caller after a few seconds.
3379 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out "
3380 "waiting for previous animation frame");
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003381 mAnimTransactionPending = false;
3382 break;
3383 }
3384 }
3385 }
3386
chaviwca27f252018-02-06 16:46:39 -08003387 for (const DisplayState& display : displays) {
3388 transactionFlags |= setDisplayStateLocked(display);
Jamie Gennisb8d69a52011-10-10 15:48:06 -07003389 }
3390
Valerie Hau9dab9732019-08-20 09:29:25 -07003391 // start and end registration for listeners w/ no surface so they can get their callback. Note
3392 // that listeners with SurfaceControls will start registration during setClientStateLocked
3393 // below.
3394 for (const auto& listener : listenerCallbacks) {
3395 mTransactionCompletedThread.startRegistration(listener);
3396 mTransactionCompletedThread.endRegistration(listener);
Marissa Walld600d572019-03-26 15:38:50 -07003397 }
3398
Valerie Hau9dab9732019-08-20 09:29:25 -07003399 std::unordered_set<ListenerCallbacks, ListenerCallbacksHash> listenerCallbacksWithSurfaces;
Marissa Walle2ffb422018-10-12 11:33:52 -07003400 uint32_t clientStateFlags = 0;
chaviwca27f252018-02-06 16:46:39 -08003401 for (const ComposerState& state : states) {
Valerie Hau9dab9732019-08-20 09:29:25 -07003402 clientStateFlags |= setClientStateLocked(state, desiredPresentTime, postTime, privileged,
3403 listenerCallbacksWithSurfaces);
Marissa Wall3dad52d2019-03-22 14:03:19 -07003404 }
3405
Valerie Hau9dab9732019-08-20 09:29:25 -07003406 for (const auto& listenerCallback : listenerCallbacksWithSurfaces) {
Marissa Wallefb71af2019-06-27 14:45:53 -07003407 mTransactionCompletedThread.endRegistration(listenerCallback);
3408 }
3409
Marissa Walle2ffb422018-10-12 11:33:52 -07003410 // If the state doesn't require a traversal and there are callbacks, send them now
Valerie Hau9dab9732019-08-20 09:29:25 -07003411 if (!(clientStateFlags & eTraversalNeeded) && hasListenerCallbacks) {
Marissa Walle2ffb422018-10-12 11:33:52 -07003412 mTransactionCompletedThread.sendCallbacks();
3413 }
3414 transactionFlags |= clientStateFlags;
chaviwca27f252018-02-06 16:46:39 -08003415
chaviw273171b2018-12-26 11:46:30 -08003416 transactionFlags |= addInputWindowCommands(inputWindowCommands);
3417
Marissa Wall947d34e2019-03-29 14:03:53 -07003418 if (uncacheBuffer.isValid()) {
3419 ClientCache::getInstance().erase(uncacheBuffer);
Alec Mouri4545a8a2019-08-08 20:05:32 -07003420 getRenderEngine().unbindExternalTextureBuffer(uncacheBuffer.id);
Marissa Wall78b72202019-03-15 14:58:34 -07003421 }
3422
Jorim Jaggibdcf09c2017-08-08 15:22:08 +02003423 // If a synchronous transaction is explicitly requested without any changes, force a transaction
3424 // anyway. This can be used as a flush mechanism for previous async transactions.
3425 // Empty animation transaction can be used to simulate back-pressure, so also force a
3426 // transaction for empty animation transactions.
3427 if (transactionFlags == 0 &&
3428 ((flags & eSynchronous) || (flags & eAnimation))) {
Robert Carr2a7dbb42016-05-24 11:41:28 -07003429 transactionFlags = eTransactionNeeded;
3430 }
3431
Marissa Wall06255332019-03-27 13:48:27 -07003432 // If we are on the main thread, we are about to preform a traversal. Clear the traversal bit
3433 // so we don't have to wake up again next frame to preform an uneeded traversal.
3434 if (isMainThread && (transactionFlags & eTraversalNeeded)) {
3435 transactionFlags = transactionFlags & (~eTraversalNeeded);
3436 mTraversalNeededMainThread = true;
3437 }
3438
Mathias Agopian386aa982011-11-07 21:58:03 -08003439 if (transactionFlags) {
Lloyd Pique4dccc412018-01-22 17:21:36 -08003440 if (mInterceptor->isEnabled()) {
3441 mInterceptor->saveTransaction(states, mCurrentState.displays, displays, flags);
Irvelffc9efc2016-07-27 15:16:37 -07003442 }
Irvel468051e2016-06-13 16:44:44 -07003443
Mathias Agopian386aa982011-11-07 21:58:03 -08003444 // this triggers the transaction
Ana Krulec7ecce8c2018-10-12 13:44:41 -07003445 const auto start = (flags & eEarlyWakeup) ? Scheduler::TransactionStart::EARLY
3446 : Scheduler::TransactionStart::NORMAL;
Dan Stoza84d619e2018-03-28 17:07:36 -07003447 setTransactionFlags(transactionFlags, start);
Mathias Agopian386aa982011-11-07 21:58:03 -08003448
3449 // if this is a synchronous transaction, wait for it to take effect
3450 // before returning.
3451 if (flags & eSynchronous) {
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003452 mTransactionPending = true;
Mathias Agopian386aa982011-11-07 21:58:03 -08003453 }
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003454 if (flags & eAnimation) {
3455 mAnimTransactionPending = true;
3456 }
chaviw4fe36852019-04-15 16:25:49 -07003457 if (mPendingInputWindowCommands.syncInputWindows) {
3458 mPendingSyncInputWindows = true;
3459 }
Valerie Hau0779ded2019-03-19 12:43:04 -07003460
3461 // applyTransactionState can be called by either the main SF thread or by
3462 // another process through setTransactionState. While a given process may wish
3463 // to wait on synchronous transactions, the main SF thread should never
3464 // be blocked. Therefore, we only wait if isMainThread is false.
3465 while (!isMainThread && (mTransactionPending || mPendingSyncInputWindows)) {
Mathias Agopian386aa982011-11-07 21:58:03 -08003466 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
3467 if (CC_UNLIKELY(err != NO_ERROR)) {
3468 // just in case something goes wrong in SF, return to the
3469 // called after a few seconds.
Jamie Gennis2d5e2302012-10-15 18:24:43 -07003470 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");
3471 mTransactionPending = false;
chaviw95ef3c42019-02-14 10:55:09 -08003472 mPendingSyncInputWindows = false;
Mathias Agopian386aa982011-11-07 21:58:03 -08003473 break;
3474 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -07003475 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003476 }
3477}
3478
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003479uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s) {
3480 const ssize_t index = mCurrentState.displays.indexOfKey(s.token);
3481 if (index < 0) return 0;
Jesse Hall9a143922012-10-04 16:29:19 -07003482
Mathias Agopiane57f2922012-08-09 16:29:12 -07003483 uint32_t flags = 0;
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003484 DisplayDeviceState& state = mCurrentState.displays.editValueAt(index);
3485
3486 const uint32_t what = s.what;
3487 if (what & DisplayState::eSurfaceChanged) {
3488 if (IInterface::asBinder(state.surface) != IInterface::asBinder(s.surface)) {
3489 state.surface = s.surface;
3490 flags |= eDisplayTransactionNeeded;
Michael Lentine47e45402014-07-18 15:34:25 -07003491 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07003492 }
Dominik Laskowskif07b85b2018-06-11 12:49:15 -07003493 if (what & DisplayState::eLayerStackChanged) {
3494 if (state.layerStack != s.layerStack) {
3495 state.layerStack = s.layerStack;
3496 flags |= eDisplayTransactionNeeded;
3497 }
3498 }
3499 if (what & DisplayState::eDisplayProjectionChanged) {
3500 if (state.orientation != s.orientation) {
3501 state.orientation = s.orientation;
3502 flags |= eDisplayTransactionNeeded;
3503 }
3504 if (state.frame != s.frame) {
3505 state.frame = s.frame;
3506 flags |= eDisplayTransactionNeeded;
3507 }
3508 if (state.viewport != s.viewport) {
3509 state.viewport = s.viewport;
3510 flags |= eDisplayTransactionNeeded;
3511 }
3512 }
3513 if (what & DisplayState::eDisplaySizeChanged) {
3514 if (state.width != s.width) {
3515 state.width = s.width;
3516 flags |= eDisplayTransactionNeeded;
3517 }
3518 if (state.height != s.height) {
3519 state.height = s.height;
3520 flags |= eDisplayTransactionNeeded;
3521 }
3522 }
3523
Mathias Agopiane57f2922012-08-09 16:29:12 -07003524 return flags;
3525}
3526
Steven Thomasd4071902020-03-24 16:02:53 -07003527bool SurfaceFlinger::callingThreadHasUnscopedSurfaceFlingerAccess(bool usePermissionCache) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003528 IPCThreadState* ipc = IPCThreadState::self();
3529 const int pid = ipc->getCallingPid();
3530 const int uid = ipc->getCallingUid();
Robert Carrd4ae7f32018-06-07 16:10:57 -07003531 if ((uid != AID_GRAPHICS && uid != AID_SYSTEM) &&
Steven Thomasd4071902020-03-24 16:02:53 -07003532 (usePermissionCache ? !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)
3533 : !checkPermission(sAccessSurfaceFlinger, pid, uid))) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003534 return false;
3535 }
3536 return true;
3537}
3538
Marissa Wall3dad52d2019-03-22 14:03:19 -07003539uint32_t SurfaceFlinger::setClientStateLocked(
Valerie Hau9dab9732019-08-20 09:29:25 -07003540 const ComposerState& composerState, int64_t desiredPresentTime, int64_t postTime,
3541 bool privileged,
3542 std::unordered_set<ListenerCallbacks, ListenerCallbacksHash>& listenerCallbacks) {
chaviwca27f252018-02-06 16:46:39 -08003543 const layer_state_t& s = composerState.state;
chaviwca27f252018-02-06 16:46:39 -08003544
Valerie Hau9dab9732019-08-20 09:29:25 -07003545 for (auto& listener : s.listeners) {
3546 // note that startRegistration will not re-register if the listener has
3547 // already be registered for a prior surface control
3548 mTransactionCompletedThread.startRegistration(listener);
3549 listenerCallbacks.insert(listener);
3550 }
3551
Vishnu Nairdc6f5b92019-12-03 07:33:37 -08003552 sp<Layer> layer = nullptr;
3553 if (s.surface) {
3554 layer = fromHandle(s.surface);
3555 } else {
3556 // The client may provide us a null handle. Treat it as if the layer was removed.
3557 ALOGW("Attempt to set client state with a null layer handle");
3558 }
chaviw8b3871a2017-11-01 17:41:01 -07003559 if (layer == nullptr) {
Valerie Hau9dab9732019-08-20 09:29:25 -07003560 for (auto& [listener, callbackIds] : s.listeners) {
Marissa Wallefb71af2019-06-27 14:45:53 -07003561 mTransactionCompletedThread.registerUnpresentedCallbackHandle(
Valerie Hau9dab9732019-08-20 09:29:25 -07003562 new CallbackHandle(listener, callbackIds, s.surface));
Marissa Wall88e20482019-06-24 10:49:42 -07003563 }
chaviw8b3871a2017-11-01 17:41:01 -07003564 return 0;
3565 }
3566
chaviw8b3871a2017-11-01 17:41:01 -07003567 uint32_t flags = 0;
3568
Garfield Tan8a3083e2018-12-03 13:21:07 -08003569 const uint64_t what = s.what;
Jorim Jaggidba32732018-05-28 17:43:52 +02003570
3571 // If we are deferring transaction, make sure to push the pending state, as otherwise the
3572 // pending state will also be deferred.
Marissa Wallf58c14b2018-07-24 10:50:43 -07003573 if (what & layer_state_t::eDeferTransaction_legacy) {
Jorim Jaggidba32732018-05-28 17:43:52 +02003574 layer->pushPendingState();
3575 }
3576
Valerie Hau871d6352020-01-29 08:44:02 -08003577 // Only set by BLAST adapter layers
3578 if (what & layer_state_t::eProducerDisconnect) {
3579 layer->onDisconnect();
3580 }
3581
chaviw8b3871a2017-11-01 17:41:01 -07003582 if (what & layer_state_t::ePositionChanged) {
chaviw214c89d2019-09-04 16:03:53 -07003583 if (layer->setPosition(s.x, s.y)) {
chaviw8b3871a2017-11-01 17:41:01 -07003584 flags |= eTraversalNeeded;
Mathias Agopiane57f2922012-08-09 16:29:12 -07003585 }
chaviw8b3871a2017-11-01 17:41:01 -07003586 }
3587 if (what & layer_state_t::eLayerChanged) {
3588 // NOTE: index needs to be calculated before we update the state
3589 const auto& p = layer->getParent();
3590 if (p == nullptr) {
chaviw64f7b422017-07-12 10:31:58 -07003591 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
chaviw8b3871a2017-11-01 17:41:01 -07003592 if (layer->setLayer(s.z) && idx >= 0) {
Mathias Agopiane57f2922012-08-09 16:29:12 -07003593 mCurrentState.layersSortedByZ.removeAt(idx);
3594 mCurrentState.layersSortedByZ.add(layer);
3595 // we need traversal (state changed)
3596 // AND transaction (list changed)
3597 flags |= eTransactionNeeded|eTraversalNeeded;
3598 }
chaviw8b3871a2017-11-01 17:41:01 -07003599 } else {
3600 if (p->setChildLayer(layer, s.z)) {
chaviw06178942017-07-27 10:25:59 -07003601 flags |= eTransactionNeeded|eTraversalNeeded;
3602 }
3603 }
chaviw8b3871a2017-11-01 17:41:01 -07003604 }
3605 if (what & layer_state_t::eRelativeLayerChanged) {
Robert Carr503c7042017-09-27 15:06:08 -07003606 // NOTE: index needs to be calculated before we update the state
3607 const auto& p = layer->getParent();
3608 if (p == nullptr) {
3609 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
3610 if (layer->setRelativeLayer(s.relativeLayerHandle, s.z) && idx >= 0) {
3611 mCurrentState.layersSortedByZ.removeAt(idx);
3612 mCurrentState.layersSortedByZ.add(layer);
3613 // we need traversal (state changed)
3614 // AND transaction (list changed)
3615 flags |= eTransactionNeeded|eTraversalNeeded;
3616 }
3617 } else {
3618 if (p->setChildRelativeLayer(layer, s.relativeLayerHandle, s.z)) {
3619 flags |= eTransactionNeeded|eTraversalNeeded;
3620 }
chaviw8b3871a2017-11-01 17:41:01 -07003621 }
3622 }
3623 if (what & layer_state_t::eSizeChanged) {
3624 if (layer->setSize(s.w, s.h)) {
3625 flags |= eTraversalNeeded;
3626 }
3627 }
3628 if (what & layer_state_t::eAlphaChanged) {
3629 if (layer->setAlpha(s.alpha))
3630 flags |= eTraversalNeeded;
3631 }
3632 if (what & layer_state_t::eColorChanged) {
3633 if (layer->setColor(s.color))
3634 flags |= eTraversalNeeded;
3635 }
Peiyong Lind3788632018-09-18 16:01:31 -07003636 if (what & layer_state_t::eColorTransformChanged) {
3637 if (layer->setColorTransform(s.colorTransform)) {
3638 flags |= eTraversalNeeded;
3639 }
3640 }
Valerie Haudd0b7572019-01-29 14:59:27 -08003641 if (what & layer_state_t::eBackgroundColorChanged) {
3642 if (layer->setBackgroundColor(s.color, s.bgColorAlpha, s.bgColorDataspace)) {
3643 flags |= eTraversalNeeded;
3644 }
3645 }
chaviw8b3871a2017-11-01 17:41:01 -07003646 if (what & layer_state_t::eMatrixChanged) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07003647 // TODO: b/109894387
3648 //
3649 // SurfaceFlinger's renderer is not prepared to handle cropping in the face of arbitrary
3650 // rotation. To see the problem observe that if we have a square parent, and a child
3651 // of the same size, then we rotate the child 45 degrees around it's center, the child
3652 // must now be cropped to a non rectangular 8 sided region.
3653 //
3654 // Of course we can fix this in the future. For now, we are lucky, SurfaceControl is
3655 // private API, and the WindowManager only uses rotation in one case, which is on a top
3656 // level layer in which cropping is not an issue.
3657 //
3658 // However given that abuse of rotation matrices could lead to surfaces extending outside
3659 // of cropped areas, we need to prevent non-root clients without permission ACCESS_SURFACE_FLINGER
3660 // (a.k.a. everyone except WindowManager and tests) from setting non rectangle preserving
3661 // transformations.
Robert Carr14167e02019-02-13 13:50:55 -08003662 if (layer->setMatrix(s.matrix, privileged))
chaviw8b3871a2017-11-01 17:41:01 -07003663 flags |= eTraversalNeeded;
3664 }
3665 if (what & layer_state_t::eTransparentRegionChanged) {
3666 if (layer->setTransparentRegionHint(s.transparentRegion))
3667 flags |= eTraversalNeeded;
3668 }
3669 if (what & layer_state_t::eFlagsChanged) {
3670 if (layer->setFlags(s.flags, s.mask))
3671 flags |= eTraversalNeeded;
3672 }
Marissa Wallf58c14b2018-07-24 10:50:43 -07003673 if (what & layer_state_t::eCropChanged_legacy) {
chaviw214c89d2019-09-04 16:03:53 -07003674 if (layer->setCrop_legacy(s.crop_legacy)) flags |= eTraversalNeeded;
chaviw8b3871a2017-11-01 17:41:01 -07003675 }
Lucas Dupin1b6531c2018-07-05 17:18:21 -07003676 if (what & layer_state_t::eCornerRadiusChanged) {
3677 if (layer->setCornerRadius(s.cornerRadius))
3678 flags |= eTraversalNeeded;
3679 }
Lucas Dupin00f16422020-03-11 11:33:04 -07003680 if (what & layer_state_t::eBackgroundBlurRadiusChanged && !mDisableBlurs) {
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08003681 if (layer->setBackgroundBlurRadius(s.backgroundBlurRadius)) flags |= eTraversalNeeded;
3682 }
chaviw8b3871a2017-11-01 17:41:01 -07003683 if (what & layer_state_t::eLayerStackChanged) {
3684 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
3685 // We only allow setting layer stacks for top level layers,
3686 // everything else inherits layer stack from its parent.
3687 if (layer->hasParent()) {
3688 ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003689 layer->getDebugName());
chaviw8b3871a2017-11-01 17:41:01 -07003690 } else if (idx < 0) {
3691 ALOGE("Attempt to set layer stack on layer without parent (%s) that "
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003692 "that also does not appear in the top level layer list. Something"
3693 " has gone wrong.",
3694 layer->getDebugName());
chaviw8b3871a2017-11-01 17:41:01 -07003695 } else if (layer->setLayerStack(s.layerStack)) {
3696 mCurrentState.layersSortedByZ.removeAt(idx);
3697 mCurrentState.layersSortedByZ.add(layer);
3698 // we need traversal (state changed)
3699 // AND transaction (list changed)
Lloyd Piqued432a7c2018-03-23 16:05:31 -07003700 flags |= eTransactionNeeded|eTraversalNeeded|eDisplayLayerStackChanged;
chaviw8b3871a2017-11-01 17:41:01 -07003701 }
3702 }
Marissa Wallf58c14b2018-07-24 10:50:43 -07003703 if (what & layer_state_t::eDeferTransaction_legacy) {
3704 if (s.barrierHandle_legacy != nullptr) {
3705 layer->deferTransactionUntil_legacy(s.barrierHandle_legacy, s.frameNumber_legacy);
3706 } else if (s.barrierGbp_legacy != nullptr) {
3707 const sp<IGraphicBufferProducer>& gbp = s.barrierGbp_legacy;
chaviw8b3871a2017-11-01 17:41:01 -07003708 if (authenticateSurfaceTextureLocked(gbp)) {
3709 const auto& otherLayer =
3710 (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
Marissa Wallf58c14b2018-07-24 10:50:43 -07003711 layer->deferTransactionUntil_legacy(otherLayer, s.frameNumber_legacy);
chaviw8b3871a2017-11-01 17:41:01 -07003712 } else {
3713 ALOGE("Attempt to defer transaction to to an"
3714 " unrecognized GraphicBufferProducer");
Robert Carr1db73f62016-12-21 12:58:51 -08003715 }
3716 }
chaviw8b3871a2017-11-01 17:41:01 -07003717 // We don't trigger a traversal here because if no other state is
3718 // changed, we don't want this to cause any more work
3719 }
chaviw8b3871a2017-11-01 17:41:01 -07003720 if (what & layer_state_t::eReparentChildren) {
3721 if (layer->reparentChildren(s.reparentHandle)) {
3722 flags |= eTransactionNeeded|eTraversalNeeded;
Robert Carrc3574f72016-03-24 12:19:32 -07003723 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07003724 }
chaviw8b3871a2017-11-01 17:41:01 -07003725 if (what & layer_state_t::eDetachChildren) {
3726 layer->detachChildren();
3727 }
3728 if (what & layer_state_t::eOverrideScalingModeChanged) {
3729 layer->setOverrideScalingMode(s.overrideScalingMode);
3730 // We don't trigger a traversal here because if no other state is
3731 // changed, we don't want this to cause any more work
3732 }
Marissa Wall61c58622018-07-18 10:12:20 -07003733 if (what & layer_state_t::eTransformChanged) {
3734 if (layer->setTransform(s.transform)) flags |= eTraversalNeeded;
3735 }
3736 if (what & layer_state_t::eTransformToDisplayInverseChanged) {
3737 if (layer->setTransformToDisplayInverse(s.transformToDisplayInverse))
3738 flags |= eTraversalNeeded;
3739 }
3740 if (what & layer_state_t::eCropChanged) {
3741 if (layer->setCrop(s.crop)) flags |= eTraversalNeeded;
3742 }
Marissa Wall861616d2018-10-22 12:52:23 -07003743 if (what & layer_state_t::eFrameChanged) {
3744 if (layer->setFrame(s.frame)) flags |= eTraversalNeeded;
3745 }
Marissa Wall61c58622018-07-18 10:12:20 -07003746 if (what & layer_state_t::eAcquireFenceChanged) {
3747 if (layer->setAcquireFence(s.acquireFence)) flags |= eTraversalNeeded;
3748 }
3749 if (what & layer_state_t::eDataspaceChanged) {
3750 if (layer->setDataspace(s.dataspace)) flags |= eTraversalNeeded;
3751 }
3752 if (what & layer_state_t::eHdrMetadataChanged) {
3753 if (layer->setHdrMetadata(s.hdrMetadata)) flags |= eTraversalNeeded;
3754 }
3755 if (what & layer_state_t::eSurfaceDamageRegionChanged) {
3756 if (layer->setSurfaceDamageRegion(s.surfaceDamageRegion)) flags |= eTraversalNeeded;
3757 }
3758 if (what & layer_state_t::eApiChanged) {
3759 if (layer->setApi(s.api)) flags |= eTraversalNeeded;
3760 }
3761 if (what & layer_state_t::eSidebandStreamChanged) {
3762 if (layer->setSidebandStream(s.sidebandStream)) flags |= eTraversalNeeded;
3763 }
Robert Carr720e5062018-07-30 17:45:14 -07003764 if (what & layer_state_t::eInputInfoChanged) {
Vishnu Nairce5d0cc2019-02-28 14:38:41 -08003765 if (privileged) {
Robert Carr11ac2012019-01-22 09:05:25 -08003766 layer->setInputInfo(s.inputInfo);
3767 flags |= eTraversalNeeded;
3768 } else {
3769 ALOGE("Attempt to update InputWindowInfo without permission ACCESS_SURFACE_FLINGER");
3770 }
Robert Carr720e5062018-07-30 17:45:14 -07003771 }
Evan Rosky1f6d6d52018-12-06 10:47:26 -08003772 if (what & layer_state_t::eMetadataChanged) {
3773 if (layer->setMetadata(s.metadata)) flags |= eTraversalNeeded;
3774 }
Peiyong Linc502cb72019-03-01 15:00:23 -08003775 if (what & layer_state_t::eColorSpaceAgnosticChanged) {
3776 if (layer->setColorSpaceAgnostic(s.colorSpaceAgnostic)) {
3777 flags |= eTraversalNeeded;
3778 }
3779 }
Vishnu Nairc97b8db2019-10-29 18:19:35 -07003780 if (what & layer_state_t::eShadowRadiusChanged) {
3781 if (layer->setShadowRadius(s.shadowRadius)) flags |= eTraversalNeeded;
3782 }
Ana Krulecc84d09b2019-11-02 23:10:29 +01003783 if (what & layer_state_t::eFrameRateSelectionPriority) {
3784 if (privileged && layer->setFrameRateSelectionPriority(s.frameRateSelectionPriority)) {
3785 flags |= eTraversalNeeded;
3786 }
3787 }
Steven Thomas3172e202020-01-06 19:25:30 -08003788 if (what & layer_state_t::eFrameRateChanged) {
Steven Thomas62a4cf82020-01-31 12:04:03 -08003789 if (ValidateFrameRate(s.frameRate, s.frameRateCompatibility,
3790 "SurfaceFlinger::setClientStateLocked") &&
3791 layer->setFrameRate(Layer::FrameRate(s.frameRate,
3792 Layer::FrameRate::convertCompatibility(
3793 s.frameRateCompatibility)))) {
Ady Abraham71c437d2020-01-31 15:56:57 -08003794 flags |= eTraversalNeeded;
Steven Thomas62a4cf82020-01-31 12:04:03 -08003795 }
Steven Thomas3172e202020-01-06 19:25:30 -08003796 }
Vishnu Nair14d76922019-08-05 08:41:20 -07003797 // This has to happen after we reparent children because when we reparent to null we remove
3798 // child layers from current state and remove its relative z. If the children are reparented in
3799 // the same transaction, then we have to make sure we reparent the children first so we do not
3800 // lose its relative z order.
3801 if (what & layer_state_t::eReparent) {
3802 bool hadParent = layer->hasParent();
3803 if (layer->reparent(s.parentHandleForChild)) {
3804 if (!hadParent) {
3805 mCurrentState.layersSortedByZ.remove(layer);
3806 }
3807 flags |= eTransactionNeeded | eTraversalNeeded;
3808 }
3809 }
Marissa Walle2ffb422018-10-12 11:33:52 -07003810 std::vector<sp<CallbackHandle>> callbackHandles;
Valerie Hau9dab9732019-08-20 09:29:25 -07003811 if ((what & layer_state_t::eHasListenerCallbacksChanged) && (!s.listeners.empty())) {
3812 for (auto& [listener, callbackIds] : s.listeners) {
Marissa Walle2ffb422018-10-12 11:33:52 -07003813 callbackHandles.emplace_back(new CallbackHandle(listener, callbackIds, s.surface));
3814 }
3815 }
Marissa Wall78b72202019-03-15 14:58:34 -07003816 bool bufferChanged = what & layer_state_t::eBufferChanged;
3817 bool cacheIdChanged = what & layer_state_t::eCachedBufferChanged;
3818 sp<GraphicBuffer> buffer;
Alec Mouri4545a8a2019-08-08 20:05:32 -07003819 if (bufferChanged && cacheIdChanged && s.buffer != nullptr) {
Marissa Wall78b72202019-03-15 14:58:34 -07003820 buffer = s.buffer;
Alec Mouri4545a8a2019-08-08 20:05:32 -07003821 bool success = ClientCache::getInstance().add(s.cachedBuffer, s.buffer);
3822 if (success) {
3823 getRenderEngine().cacheExternalTextureBuffer(s.buffer);
3824 success = ClientCache::getInstance()
3825 .registerErasedRecipient(s.cachedBuffer,
3826 wp<ClientCache::ErasedRecipient>(this));
3827 if (!success) {
3828 getRenderEngine().unbindExternalTextureBuffer(s.buffer->getId());
3829 }
3830 }
Marissa Wall78b72202019-03-15 14:58:34 -07003831 } else if (cacheIdChanged) {
Marissa Wall947d34e2019-03-29 14:03:53 -07003832 buffer = ClientCache::getInstance().get(s.cachedBuffer);
Marissa Wall78b72202019-03-15 14:58:34 -07003833 } else if (bufferChanged) {
3834 buffer = s.buffer;
Marissa Wall73411622019-01-25 10:45:41 -08003835 }
Marissa Wall78b72202019-03-15 14:58:34 -07003836 if (buffer) {
Valerie Haubf784642020-01-29 07:25:23 -08003837 if (layer->setBuffer(buffer, s.acquireFence, postTime, desiredPresentTime,
3838 s.cachedBuffer)) {
Valerie Haubc6ddb12019-03-08 11:10:15 -08003839 flags |= eTraversalNeeded;
Valerie Haubc6ddb12019-03-08 11:10:15 -08003840 }
Marissa Wallebc2c052019-01-16 19:16:55 -08003841 }
Marissa Walle2ffb422018-10-12 11:33:52 -07003842 if (layer->setTransactionCompletedListeners(callbackHandles)) flags |= eTraversalNeeded;
3843 // Do not put anything that updates layer state or modifies flags after
3844 // setTransactionCompletedListener
Mathias Agopiane57f2922012-08-09 16:29:12 -07003845 return flags;
3846}
3847
chaviw273171b2018-12-26 11:46:30 -08003848uint32_t SurfaceFlinger::addInputWindowCommands(const InputWindowCommands& inputWindowCommands) {
3849 uint32_t flags = 0;
chaviwa911b102019-02-14 10:18:33 -08003850 if (inputWindowCommands.syncInputWindows) {
3851 flags |= eTraversalNeeded;
3852 }
3853
Vishnu Nairec0ab382019-02-13 15:32:56 -08003854 mPendingInputWindowCommands.merge(inputWindowCommands);
chaviw273171b2018-12-26 11:46:30 -08003855 return flags;
3856}
3857
chaviwfe94a222019-08-21 13:52:59 -07003858status_t SurfaceFlinger::mirrorLayer(const sp<Client>& client, const sp<IBinder>& mirrorFromHandle,
3859 sp<IBinder>* outHandle) {
3860 if (!mirrorFromHandle) {
3861 return NAME_NOT_FOUND;
3862 }
3863
3864 sp<Layer> mirrorLayer;
3865 sp<Layer> mirrorFrom;
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003866 std::string uniqueName = getUniqueLayerName("MirrorRoot");
chaviwfe94a222019-08-21 13:52:59 -07003867
3868 {
3869 Mutex::Autolock _l(mStateLock);
3870 mirrorFrom = fromHandle(mirrorFromHandle);
3871 if (!mirrorFrom) {
3872 return NAME_NOT_FOUND;
3873 }
3874
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003875 status_t result = createContainerLayer(client, std::move(uniqueName), -1, -1, 0,
3876 LayerMetadata(), outHandle, &mirrorLayer);
chaviwfe94a222019-08-21 13:52:59 -07003877 if (result != NO_ERROR) {
3878 return result;
3879 }
3880
3881 mirrorLayer->mClonedChild = mirrorFrom->createClone();
3882 }
3883
3884 return addClientLayer(client, *outHandle, nullptr, mirrorLayer, nullptr, nullptr, false);
3885}
3886
Marissa Wall2d814fb2019-04-09 18:52:57 +00003887status_t SurfaceFlinger::createLayer(const String8& name, const sp<Client>& client, uint32_t w,
3888 uint32_t h, PixelFormat format, uint32_t flags,
3889 LayerMetadata metadata, sp<IBinder>* handle,
Robert Carrc0df3122019-04-11 13:18:21 -07003890 sp<IGraphicBufferProducer>* gbp,
Valerie Hau1acd6962019-10-28 16:35:48 -07003891 const sp<IBinder>& parentHandle, const sp<Layer>& parentLayer,
3892 uint32_t* outTransformHint) {
Mathias Agopian6e2d6482009-07-09 18:16:43 -07003893 if (int32_t(w|h) < 0) {
Mathias Agopian921e6ac2012-07-23 23:11:29 -07003894 ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
Mathias Agopian6e2d6482009-07-09 18:16:43 -07003895 int(w), int(h));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003896 return BAD_VALUE;
Mathias Agopian6e2d6482009-07-09 18:16:43 -07003897 }
Andreas Huber8b42e8a2010-08-16 08:49:37 -07003898
Robert Carrc0df3122019-04-11 13:18:21 -07003899 ALOG_ASSERT(parentLayer == nullptr || parentHandle == nullptr,
3900 "Expected only one of parentLayer or parentHandle to be non-null. "
3901 "Programmer error?");
3902
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003903 status_t result = NO_ERROR;
3904
3905 sp<Layer> layer;
3906
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003907 std::string uniqueName = getUniqueLayerName(name.string());
Cody Northropbc755282017-03-31 12:00:08 -06003908
Evan Roskya1f1e152019-01-24 16:17:46 -08003909 bool primaryDisplayOnly = false;
3910
3911 // window type is WINDOW_TYPE_DONT_SCREENSHOT from SurfaceControl.java
3912 // TODO b/64227542
3913 if (metadata.has(METADATA_WINDOW_TYPE)) {
3914 int32_t windowType = metadata.getInt32(METADATA_WINDOW_TYPE, 0);
3915 if (windowType == 441731) {
Ady Abraham8f1ee7f2019-04-05 10:32:50 -07003916 metadata.setInt32(METADATA_WINDOW_TYPE, InputWindowInfo::TYPE_NAVIGATION_BAR_PANEL);
Evan Roskya1f1e152019-01-24 16:17:46 -08003917 primaryDisplayOnly = true;
3918 }
3919 }
3920
Mathias Agopian3165cc22012-08-08 19:42:09 -07003921 switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
Marissa Wall61c58622018-07-18 10:12:20 -07003922 case ISurfaceComposerClient::eFXSurfaceBufferQueue:
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003923 result = createBufferQueueLayer(client, std::move(uniqueName), w, h, flags,
3924 std::move(metadata), format, handle, gbp, &layer);
David Sodman0c69cad2017-08-21 12:12:51 -07003925
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003926 break;
Marissa Wall61c58622018-07-18 10:12:20 -07003927 case ISurfaceComposerClient::eFXSurfaceBufferState:
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003928 result = createBufferStateLayer(client, std::move(uniqueName), w, h, flags,
Valerie Hau1acd6962019-10-28 16:35:48 -07003929 std::move(metadata), handle, outTransformHint, &layer);
Marissa Wall61c58622018-07-18 10:12:20 -07003930 break;
Vishnu Nairfa247b12020-02-11 08:58:26 -08003931 case ISurfaceComposerClient::eFXSurfaceEffect:
Vishnu Nair88a11f22018-11-28 18:30:57 -08003932 // check if buffer size is set for color layer.
3933 if (w > 0 || h > 0) {
3934 ALOGE("createLayer() failed, w or h cannot be set for color layer (w=%d, h=%d)",
3935 int(w), int(h));
3936 return BAD_VALUE;
3937 }
3938
Vishnu Nairfa247b12020-02-11 08:58:26 -08003939 result = createEffectLayer(client, std::move(uniqueName), w, h, flags,
3940 std::move(metadata), handle, &layer);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003941 break;
Robert Carr6b3f6c52018-08-13 13:05:17 -07003942 case ISurfaceComposerClient::eFXSurfaceContainer:
Vishnu Nair88a11f22018-11-28 18:30:57 -08003943 // check if buffer size is set for container layer.
3944 if (w > 0 || h > 0) {
3945 ALOGE("createLayer() failed, w or h cannot be set for container layer (w=%d, h=%d)",
3946 int(w), int(h));
3947 return BAD_VALUE;
3948 }
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003949 result = createContainerLayer(client, std::move(uniqueName), w, h, flags,
3950 std::move(metadata), handle, &layer);
Robert Carr6b3f6c52018-08-13 13:05:17 -07003951 break;
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003952 default:
3953 result = BAD_VALUE;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003954 break;
3955 }
3956
Dan Stoza7d89d062015-04-30 13:29:25 -07003957 if (result != NO_ERROR) {
3958 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003959 }
Dan Stoza7d89d062015-04-30 13:29:25 -07003960
Evan Roskya1f1e152019-01-24 16:17:46 -08003961 if (primaryDisplayOnly) {
3962 layer->setPrimaryDisplayOnly();
Chia-I Wuab0c3192017-08-01 11:29:00 -07003963 }
3964
Robert Carrb89ea9d2018-12-10 13:01:14 -08003965 bool addToCurrentState = callingThreadHasUnscopedSurfaceFlingerAccess();
Robert Carrc0df3122019-04-11 13:18:21 -07003966 result = addClientLayer(client, *handle, *gbp, layer, parentHandle, parentLayer,
3967 addToCurrentState);
Dan Stoza7d89d062015-04-30 13:29:25 -07003968 if (result != NO_ERROR) {
3969 return result;
3970 }
Lloyd Pique4dccc412018-01-22 17:21:36 -08003971 mInterceptor->saveSurfaceCreation(layer);
Dan Stoza7d89d062015-04-30 13:29:25 -07003972
3973 setTransactionFlags(eTransactionNeeded);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07003974 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003975}
3976
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003977std::string SurfaceFlinger::getUniqueLayerName(const char* name) {
3978 unsigned dupeCounter = 0;
Cody Northropbc755282017-03-31 12:00:08 -06003979
3980 // Tack on our counter whether there is a hit or not, so everyone gets a tag
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003981 std::string uniqueName = base::StringPrintf("%s#%u", name, dupeCounter);
Cody Northropbc755282017-03-31 12:00:08 -06003982
Dan Stoza436ccf32018-06-21 12:10:12 -07003983 // Grab the state lock since we're accessing mCurrentState
3984 Mutex::Autolock lock(mStateLock);
3985
Cody Northropbc755282017-03-31 12:00:08 -06003986 // Loop over layers until we're sure there is no matching name
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003987 bool matchFound = true;
Cody Northropbc755282017-03-31 12:00:08 -06003988 while (matchFound) {
3989 matchFound = false;
Edgar Arriaga844fa672020-01-16 14:21:42 -08003990 mCurrentState.traverse([&](Layer* layer) {
Cody Northropbc755282017-03-31 12:00:08 -06003991 if (layer->getName() == uniqueName) {
3992 matchFound = true;
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003993 uniqueName = base::StringPrintf("%s#%u", name, ++dupeCounter);
Cody Northropbc755282017-03-31 12:00:08 -06003994 }
3995 });
3996 }
3997
Dominik Laskowski87a07e42019-10-10 20:38:02 -07003998 ALOGV_IF(dupeCounter > 0, "duplicate layer name: changing %s to %s", name, uniqueName.c_str());
Cody Northropbc755282017-03-31 12:00:08 -06003999 return uniqueName;
4000}
4001
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004002status_t SurfaceFlinger::createBufferQueueLayer(const sp<Client>& client, std::string name,
Marissa Wallfd668622018-05-10 10:21:13 -07004003 uint32_t w, uint32_t h, uint32_t flags,
Evan Roskya1f1e152019-01-24 16:17:46 -08004004 LayerMetadata metadata, PixelFormat& format,
4005 sp<IBinder>* handle,
Marissa Wallfd668622018-05-10 10:21:13 -07004006 sp<IGraphicBufferProducer>* gbp,
4007 sp<Layer>* outLayer) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004008 // initialize the surfaces
Mathias Agopian92a979a2012-08-02 18:32:23 -07004009 switch (format) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004010 case PIXEL_FORMAT_TRANSPARENT:
4011 case PIXEL_FORMAT_TRANSLUCENT:
4012 format = PIXEL_FORMAT_RGBA_8888;
4013 break;
4014 case PIXEL_FORMAT_OPAQUE:
Mathias Agopian8f105402010-04-05 18:01:24 -07004015 format = PIXEL_FORMAT_RGBX_8888;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004016 break;
4017 }
4018
chaviwb4c6e582019-08-16 14:35:07 -07004019 sp<BufferQueueLayer> layer;
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004020 LayerCreationArgs args(this, client, std::move(name), w, h, flags, std::move(metadata));
chaviwb4c6e582019-08-16 14:35:07 -07004021 args.textureName = getNewTexture();
4022 {
4023 // Grab the SF state lock during this since it's the only safe way to access
4024 // RenderEngine when creating a BufferLayerConsumer
4025 // TODO: Check if this lock is still needed here
4026 Mutex::Autolock lock(mStateLock);
4027 layer = getFactory().createBufferQueueLayer(args);
4028 }
4029
Marissa Wallfd668622018-05-10 10:21:13 -07004030 status_t err = layer->setDefaultBufferProperties(w, h, format);
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004031 if (err == NO_ERROR) {
David Sodman0c69cad2017-08-21 12:12:51 -07004032 *handle = layer->getHandle();
4033 *gbp = layer->getProducer();
4034 *outLayer = layer;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004035 }
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004036
Marissa Wallfd668622018-05-10 10:21:13 -07004037 ALOGE_IF(err, "createBufferQueueLayer() failed (%s)", strerror(-err));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004038 return err;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004039}
4040
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004041status_t SurfaceFlinger::createBufferStateLayer(const sp<Client>& client, std::string name,
Marissa Wall61c58622018-07-18 10:12:20 -07004042 uint32_t w, uint32_t h, uint32_t flags,
Evan Roskya1f1e152019-01-24 16:17:46 -08004043 LayerMetadata metadata, sp<IBinder>* handle,
Valerie Hau1acd6962019-10-28 16:35:48 -07004044 uint32_t* outTransformHint, sp<Layer>* outLayer) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004045 LayerCreationArgs args(this, client, std::move(name), w, h, flags, std::move(metadata));
chaviwb4c6e582019-08-16 14:35:07 -07004046 args.displayDevice = getDefaultDisplayDevice();
4047 args.textureName = getNewTexture();
4048 sp<BufferStateLayer> layer = getFactory().createBufferStateLayer(args);
Valerie Hau1acd6962019-10-28 16:35:48 -07004049 if (outTransformHint) {
4050 *outTransformHint = layer->getTransformHint();
4051 }
Marissa Wall61c58622018-07-18 10:12:20 -07004052 *handle = layer->getHandle();
4053 *outLayer = layer;
4054
4055 return NO_ERROR;
4056}
4057
Vishnu Nairfa247b12020-02-11 08:58:26 -08004058status_t SurfaceFlinger::createEffectLayer(const sp<Client>& client, std::string name, uint32_t w,
4059 uint32_t h, uint32_t flags, LayerMetadata metadata,
4060 sp<IBinder>* handle, sp<Layer>* outLayer) {
4061 *outLayer = getFactory().createEffectLayer(
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004062 {this, client, std::move(name), w, h, flags, std::move(metadata)});
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004063 *handle = (*outLayer)->getHandle();
Mathias Agopian4d9b8222013-03-12 17:11:48 -07004064 return NO_ERROR;
Mathias Agopian118d0242011-10-13 16:02:48 -07004065}
4066
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004067status_t SurfaceFlinger::createContainerLayer(const sp<Client>& client, std::string name,
Evan Roskya1f1e152019-01-24 16:17:46 -08004068 uint32_t w, uint32_t h, uint32_t flags,
4069 LayerMetadata metadata, sp<IBinder>* handle,
4070 sp<Layer>* outLayer) {
4071 *outLayer = getFactory().createContainerLayer(
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004072 {this, client, std::move(name), w, h, flags, std::move(metadata)});
Robert Carr6b3f6c52018-08-13 13:05:17 -07004073 *handle = (*outLayer)->getHandle();
4074 return NO_ERROR;
4075}
4076
Robert Carr6fb1a7e2018-12-11 12:07:25 -08004077void SurfaceFlinger::markLayerPendingRemovalLocked(const sp<Layer>& layer) {
Robert Carr2e102c92018-10-23 12:11:15 -07004078 mLayersPendingRemoval.add(layer);
4079 mLayersRemoved = true;
4080 setTransactionFlags(eTransactionNeeded);
4081}
4082
Robert Carr695d5282018-12-18 15:27:58 -08004083void SurfaceFlinger::onHandleDestroyed(sp<Layer>& layer)
Rob Carr4bba3702018-10-08 21:53:30 +00004084{
Robert Carr2e102c92018-10-23 12:11:15 -07004085 Mutex::Autolock lock(mStateLock);
Robert Carr6fb1a7e2018-12-11 12:07:25 -08004086 // If a layer has a parent, we allow it to out-live it's handle
4087 // with the idea that the parent holds a reference and will eventually
4088 // be cleaned up. However no one cleans up the top-level so we do so
4089 // here.
4090 if (layer->getParent() == nullptr) {
4091 mCurrentState.layersSortedByZ.remove(layer);
4092 }
4093 markLayerPendingRemovalLocked(layer);
Robert Carrc0df3122019-04-11 13:18:21 -07004094
4095 auto it = mLayersByLocalBinderToken.begin();
4096 while (it != mLayersByLocalBinderToken.end()) {
4097 if (it->second == layer) {
4098 it = mLayersByLocalBinderToken.erase(it);
4099 } else {
4100 it++;
4101 }
4102 }
4103
Robert Carr695d5282018-12-18 15:27:58 -08004104 layer.clear();
Rob Carr4bba3702018-10-08 21:53:30 +00004105}
4106
Mathias Agopianb60314a2012-04-10 22:09:54 -07004107// ---------------------------------------------------------------------------
4108
Andy McFadden13a082e2012-08-24 10:16:42 -07004109void SurfaceFlinger::onInitializeDisplays() {
Dominik Laskowski83b88212018-12-11 13:34:06 -08004110 const auto display = getDefaultDisplayDeviceLocked();
4111 if (!display) return;
4112
4113 const sp<IBinder> token = display->getDisplayToken().promote();
4114 LOG_ALWAYS_FATAL_IF(token == nullptr);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004115
Jesse Hall01e29052013-02-19 16:13:35 -08004116 // reset screen orientation and use primary layer stack
Andy McFadden13a082e2012-08-24 10:16:42 -07004117 Vector<ComposerState> state;
4118 Vector<DisplayState> displays;
4119 DisplayState d;
Jesse Hall01e29052013-02-19 16:13:35 -08004120 d.what = DisplayState::eDisplayProjectionChanged |
4121 DisplayState::eLayerStackChanged;
Dominik Laskowski83b88212018-12-11 13:34:06 -08004122 d.token = token;
Jesse Hall01e29052013-02-19 16:13:35 -08004123 d.layerStack = 0;
Dominik Laskowski718f9602019-11-09 20:01:35 -08004124 d.orientation = ui::ROTATION_0;
Jeff Brown4c05dd12012-09-09 00:07:17 -07004125 d.frame.makeInvalid();
4126 d.viewport.makeInvalid();
Michael Lentine47e45402014-07-18 15:34:25 -07004127 d.width = 0;
4128 d.height = 0;
Andy McFadden13a082e2012-08-24 10:16:42 -07004129 displays.add(d);
Valerie Hau9dab9732019-08-20 09:29:25 -07004130 setTransactionState(state, displays, 0, nullptr, mPendingInputWindowCommands, -1, {}, false,
4131 {});
Jamie Gennis6547ff42013-07-16 20:12:42 -07004132
Dominik Laskowskie9774092018-12-11 10:04:24 -08004133 setPowerModeInternal(display, HWC_POWER_MODE_NORMAL);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004134
Dominik Laskowski83b88212018-12-11 13:34:06 -08004135 const nsecs_t vsyncPeriod = getVsyncPeriod();
4136 mAnimFrameTracker.setDisplayRefreshPeriod(vsyncPeriod);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08004137
Brian Andersond0010582017-03-07 13:20:31 -08004138 // Use phase of 0 since phase is not known.
4139 // Use latency of 0, which will snap to the ideal latency.
Dominik Laskowski83b88212018-12-11 13:34:06 -08004140 DisplayStatInfo stats{0 /* vsyncTime */, vsyncPeriod};
Ana Krulece588e312018-09-18 12:32:24 -07004141 setCompositorTimingSnapped(stats, 0);
Andy McFadden13a082e2012-08-24 10:16:42 -07004142}
4143
4144void SurfaceFlinger::initializeDisplays() {
Dominik Laskowski8c001672018-05-30 16:52:06 -07004145 // Async since we may be called from the main thread.
Dominik Laskowski83b88212018-12-11 13:34:06 -08004146 postMessageAsync(
4147 new LambdaMessage([this]() NO_THREAD_SAFETY_ANALYSIS { onInitializeDisplays(); }));
Andy McFadden13a082e2012-08-24 10:16:42 -07004148}
4149
Ady Abraham27c70212019-06-11 10:52:26 -07004150void SurfaceFlinger::setVsyncEnabledInHWC(DisplayId displayId, HWC2::Vsync enabled) {
4151 if (mHWCVsyncState != enabled) {
4152 getHwComposer().setVsyncEnabled(displayId, enabled);
4153 mHWCVsyncState = enabled;
4154 }
4155}
4156
Dominik Laskowskie9774092018-12-11 10:04:24 -08004157void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& display, int mode) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004158 if (display->isVirtual()) {
4159 ALOGE("%s: Invalid operation on virtual display", __FUNCTION__);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004160 return;
4161 }
4162
Dominik Laskowski075d3172018-05-24 15:50:06 -07004163 const auto displayId = display->getId();
4164 LOG_ALWAYS_FATAL_IF(!displayId);
4165
Dominik Laskowski34157762018-10-31 13:07:19 -07004166 ALOGD("Setting power mode %d on display %s", mode, to_string(*displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004167
4168 int currentMode = display->getPowerMode();
4169 if (mode == currentMode) {
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004170 return;
4171 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004172
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004173 display->setPowerMode(mode);
4174
Lloyd Pique4dccc412018-01-22 17:21:36 -08004175 if (mInterceptor->isEnabled()) {
Dominik Laskowskie9774092018-12-11 10:04:24 -08004176 mInterceptor->savePowerModeUpdate(display->getSequenceId(), mode);
Irvelffc9efc2016-07-27 15:16:37 -07004177 }
4178
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004179 if (currentMode == HWC_POWER_MODE_OFF) {
Martin Liu4a322352020-03-24 21:30:38 +08004180 if (SurfaceFlinger::setSchedFifo(true) != NO_ERROR) {
4181 ALOGW("Couldn't set SCHED_FIFO on display on: %s\n", strerror(errno));
4182 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07004183 getHwComposer().setPowerMode(*displayId, mode);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004184 if (display->isPrimary() && mode != HWC_POWER_MODE_DOZE_SUSPEND) {
Ady Abraham27c70212019-06-11 10:52:26 -07004185 setVsyncEnabledInHWC(*displayId, mHWCVsyncPendingState);
Ana Krulecc2870422019-01-29 19:00:58 -08004186 mScheduler->onScreenAcquired(mAppConnectionHandle);
4187 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004188 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004189
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004190 mVisibleRegionsDirty = true;
Dan Stozab90cf072015-03-05 11:05:59 -08004191 mHasPoweredOff = true;
Dan Stozac7a25ad2018-04-12 11:45:09 -07004192 repaintEverything();
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004193 } else if (mode == HWC_POWER_MODE_OFF) {
Tim Murrayf9d4e442016-08-02 15:43:59 -07004194 // Turn off the display
Martin Liu4a322352020-03-24 21:30:38 +08004195 if (SurfaceFlinger::setSchedFifo(false) != NO_ERROR) {
4196 ALOGW("Couldn't set SCHED_OTHER on display off: %s\n", strerror(errno));
Tim Murrayf9d4e442016-08-02 15:43:59 -07004197 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004198 if (display->isPrimary() && currentMode != HWC_POWER_MODE_DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08004199 mScheduler->disableHardwareVsync(true);
4200 mScheduler->onScreenReleased(mAppConnectionHandle);
Mathias Agopiancde87a32012-09-13 14:09:01 -07004201 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004202
Ady Abraham27c70212019-06-11 10:52:26 -07004203 // Make sure HWVsync is disabled before turning off the display
4204 setVsyncEnabledInHWC(*displayId, HWC2::Vsync::Disable);
4205
Dominik Laskowski075d3172018-05-24 15:50:06 -07004206 getHwComposer().setPowerMode(*displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004207 mVisibleRegionsDirty = true;
4208 // from this point on, SF will stop drawing on this display
Matthew Bouyack38d49612017-05-12 12:49:32 -07004209 } else if (mode == HWC_POWER_MODE_DOZE ||
4210 mode == HWC_POWER_MODE_NORMAL) {
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004211 // Update display while dozing
Dominik Laskowski075d3172018-05-24 15:50:06 -07004212 getHwComposer().setPowerMode(*displayId, mode);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004213 if (display->isPrimary() && currentMode == HWC_POWER_MODE_DOZE_SUSPEND) {
Ana Krulecc2870422019-01-29 19:00:58 -08004214 mScheduler->onScreenAcquired(mAppConnectionHandle);
4215 mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004216 }
4217 } else if (mode == HWC_POWER_MODE_DOZE_SUSPEND) {
4218 // Leave display going to doze
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004219 if (display->isPrimary()) {
Ana Krulecc2870422019-01-29 19:00:58 -08004220 mScheduler->disableHardwareVsync(true);
4221 mScheduler->onScreenReleased(mAppConnectionHandle);
Zheng Zhang8a43fe62017-03-17 11:19:39 +01004222 }
Dominik Laskowski075d3172018-05-24 15:50:06 -07004223 getHwComposer().setPowerMode(*displayId, mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -07004224 } else {
Matthew Bouyack38d49612017-05-12 12:49:32 -07004225 ALOGE("Attempting to set unknown power mode: %d\n", mode);
Dominik Laskowski075d3172018-05-24 15:50:06 -07004226 getHwComposer().setPowerMode(*displayId, mode);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004227 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004228
Yiwei Zhang3a226d22018-10-16 09:23:03 -07004229 if (display->isPrimary()) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08004230 mTimeStats->setPowerMode(mode);
Steven Thomas2bbaabe2019-08-28 16:08:35 -07004231 mRefreshRateStats->setPowerMode(mode);
Ady Abraham6fe2c172019-07-12 12:37:57 -07004232 mScheduler->setDisplayPowerState(mode == HWC_POWER_MODE_NORMAL);
Yiwei Zhang3a226d22018-10-16 09:23:03 -07004233 }
4234
Dominik Laskowski34157762018-10-31 13:07:19 -07004235 ALOGD("Finished setting power mode %d on display %s", mode, to_string(*displayId).c_str());
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004236}
4237
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004238void SurfaceFlinger::setPowerMode(const sp<IBinder>& displayToken, int mode) {
Dominik Laskowski83b88212018-12-11 13:34:06 -08004239 postMessageSync(new LambdaMessage([&]() NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07004240 const auto display = getDisplayDeviceLocked(displayToken);
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004241 if (!display) {
4242 ALOGE("Attempt to set power mode %d for invalid display token %p", mode,
4243 displayToken.get());
4244 } else if (display->isVirtual()) {
4245 ALOGW("Attempt to set power mode %d for virtual display", mode);
4246 } else {
Dominik Laskowskie9774092018-12-11 10:04:24 -08004247 setPowerModeInternal(display, mode);
Andy McFaddenc01a79d2012-09-27 16:02:06 -07004248 }
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004249 }));
Mathias Agopianb60314a2012-04-10 22:09:54 -07004250}
4251
4252// ---------------------------------------------------------------------------
4253
Dominik Laskowskic2867142019-01-21 11:33:38 -08004254status_t SurfaceFlinger::doDump(int fd, const DumpArgs& args,
4255 bool asProto) NO_THREAD_SAFETY_ANALYSIS {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004256 std::string result;
Mathias Agopian99b49842011-06-27 16:05:52 -07004257
Mathias Agopianbd115332013-04-18 16:41:04 -07004258 IPCThreadState* ipc = IPCThreadState::self();
4259 const int pid = ipc->getCallingPid();
4260 const int uid = ipc->getCallingUid();
Vishnu Nair6a408532017-10-24 09:11:27 -07004261
Mathias Agopianbd115332013-04-18 16:41:04 -07004262 if ((uid != AID_SHELL) &&
4263 !PermissionCache::checkPermission(sDump, pid, uid)) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004264 StringAppendF(&result, "Permission Denial: can't dump SurfaceFlinger from pid=%d, uid=%d\n",
4265 pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004266 } else {
Jesse Hallfcd15b42014-12-23 13:57:23 -08004267 // Try to get the main lock, but give up after one second
Mathias Agopian9795c422009-08-26 16:36:26 -07004268 // (this would indicate SF is stuck, but we want to be able to
4269 // print something in dumpsys).
Jesse Hallfcd15b42014-12-23 13:57:23 -08004270 status_t err = mStateLock.timedLock(s2ns(1));
4271 bool locked = (err == NO_ERROR);
Mathias Agopian9795c422009-08-26 16:36:26 -07004272 if (!locked) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004273 StringAppendF(&result,
4274 "SurfaceFlinger appears to be unresponsive (%s [%d]), dumping anyways "
4275 "(no locks held)\n",
4276 strerror(-err), err);
Mathias Agopian9795c422009-08-26 16:36:26 -07004277 }
4278
Dominik Laskowskic2867142019-01-21 11:33:38 -08004279 static const std::unordered_map<std::string, Dumper> dumpers = {
Dominik Laskowskic2867142019-01-21 11:33:38 -08004280 {"--display-id"s, dumper(&SurfaceFlinger::dumpDisplayIdentificationData)},
Dominik Laskowski98041832019-08-01 18:35:59 -07004281 {"--dispsync"s,
4282 dumper([this](std::string& s) { mScheduler->getPrimaryDispSync().dump(s); })},
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004283 {"--edid"s, argsDumper(&SurfaceFlinger::dumpRawDisplayIdentificationData)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08004284 {"--frame-events"s, dumper(&SurfaceFlinger::dumpFrameEventsLocked)},
4285 {"--latency"s, argsDumper(&SurfaceFlinger::dumpStatsLocked)},
4286 {"--latency-clear"s, argsDumper(&SurfaceFlinger::clearStatsLocked)},
4287 {"--list"s, dumper(&SurfaceFlinger::listLayersLocked)},
4288 {"--static-screen"s, dumper(&SurfaceFlinger::dumpStaticScreenStats)},
4289 {"--timestats"s, protoDumper(&SurfaceFlinger::dumpTimeStats)},
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004290 {"--vsync"s, dumper(&SurfaceFlinger::dumpVSync)},
Dominik Laskowskic2867142019-01-21 11:33:38 -08004291 {"--wide-color"s, dumper(&SurfaceFlinger::dumpWideColorInfo)},
4292 };
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004293
Dominik Laskowskic2867142019-01-21 11:33:38 -08004294 const auto flag = args.empty() ? ""s : std::string(String8(args[0]));
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004295
Dominik Laskowski46470112019-08-02 13:13:11 -07004296 const auto it = dumpers.find(flag);
4297 if (it != dumpers.end()) {
Dominik Laskowskic2867142019-01-21 11:33:38 -08004298 (it->second)(args, asProto, result);
Vishnu Nair8406fd72019-07-30 11:29:31 -07004299 } else if (!asProto) {
4300 dumpAllLocked(args, result);
Mathias Agopian48b888a2011-01-19 16:15:53 -08004301 }
4302
Mathias Agopian9795c422009-08-26 16:36:26 -07004303 if (locked) {
4304 mStateLock.unlock();
4305 }
Vishnu Nair8406fd72019-07-30 11:29:31 -07004306
Dominik Laskowski46470112019-08-02 13:13:11 -07004307 if (it == dumpers.end()) {
4308 const LayersProto layersProto = dumpProtoFromMainThread();
4309 if (asProto) {
4310 result.append(layersProto.SerializeAsString());
4311 } else {
Vishnu Nair0f085c62019-08-30 08:49:12 -07004312 // Dump info that we need to access from the main thread
Dominik Laskowski46470112019-08-02 13:13:11 -07004313 const auto layerTree = LayerProtoParser::generateLayerTree(layersProto);
4314 result.append(LayerProtoParser::layerTreeToString(layerTree));
4315 result.append("\n");
Vishnu Nair0f085c62019-08-30 08:49:12 -07004316 dumpOffscreenLayers(result);
Dominik Laskowski46470112019-08-02 13:13:11 -07004317 }
Vishnu Nair8406fd72019-07-30 11:29:31 -07004318 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004319 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08004320 write(fd, result.c_str(), result.size());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004321 return NO_ERROR;
4322}
4323
Nataniel Borges8e7dc722019-02-28 15:10:28 -08004324status_t SurfaceFlinger::dumpCritical(int fd, const DumpArgs&, bool asProto) {
4325 if (asProto && mTracing.isEnabled()) {
4326 mTracing.writeToFileAsync();
4327 }
4328
4329 return doDump(fd, DumpArgs(), asProto);
4330}
4331
Dominik Laskowskic2867142019-01-21 11:33:38 -08004332void SurfaceFlinger::listLayersLocked(std::string& result) const {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004333 mCurrentState.traverseInZOrder(
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004334 [&](Layer* layer) { StringAppendF(&result, "%s\n", layer->getDebugName()); });
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004335}
4336
Dominik Laskowskic2867142019-01-21 11:33:38 -08004337void SurfaceFlinger::dumpStatsLocked(const DumpArgs& args, std::string& result) const {
Dominik Laskowski83b88212018-12-11 13:34:06 -08004338 StringAppendF(&result, "%" PRId64 "\n", getVsyncPeriod());
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004339
Dominik Laskowskic2867142019-01-21 11:33:38 -08004340 if (args.size() > 1) {
4341 const auto name = String8(args[1]);
Robert Carr2047fae2016-11-28 14:09:09 -08004342 mCurrentState.traverseInZOrder([&](Layer* layer) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004343 if (layer->getName() == name.string()) {
Svetoslavd85084b2014-03-20 10:28:31 -07004344 layer->dumpFrameStats(result);
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004345 }
Robert Carr2047fae2016-11-28 14:09:09 -08004346 });
Dominik Laskowskic2867142019-01-21 11:33:38 -08004347 } else {
4348 mAnimFrameTracker.dumpStats(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004349 }
4350}
4351
Dominik Laskowskic2867142019-01-21 11:33:38 -08004352void SurfaceFlinger::clearStatsLocked(const DumpArgs& args, std::string&) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004353 const bool clearAll = args.size() < 2;
4354 const auto name = clearAll ? String8() : String8(args[1]);
4355
Edgar Arriaga844fa672020-01-16 14:21:42 -08004356 mCurrentState.traverse([&](Layer* layer) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004357 if (clearAll || layer->getName() == name.string()) {
Svetoslavd85084b2014-03-20 10:28:31 -07004358 layer->clearFrameStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004359 }
Robert Carr2047fae2016-11-28 14:09:09 -08004360 });
Jamie Gennis4b0eba92013-02-05 13:30:24 -08004361
Svetoslavd85084b2014-03-20 10:28:31 -07004362 mAnimFrameTracker.clearStats();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08004363}
4364
Dominik Laskowskic2867142019-01-21 11:33:38 -08004365void SurfaceFlinger::dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const {
4366 mTimeStats->parseArgs(asProto, args, result);
4367}
4368
Jamie Gennis6547ff42013-07-16 20:12:42 -07004369// This should only be called from the main thread. Otherwise it would need
4370// the lock and should use mCurrentState rather than mDrawingState.
4371void SurfaceFlinger::logFrameStats() {
Edgar Arriaga844fa672020-01-16 14:21:42 -08004372 mDrawingState.traverse([&](Layer* layer) {
Jamie Gennis6547ff42013-07-16 20:12:42 -07004373 layer->logFrameStats();
Robert Carr2047fae2016-11-28 14:09:09 -08004374 });
Jamie Gennis6547ff42013-07-16 20:12:42 -07004375
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004376 mAnimFrameTracker.logAndResetStats("<win-anim>");
Jamie Gennis6547ff42013-07-16 20:12:42 -07004377}
4378
Yiwei Zhang5434a782018-12-05 18:06:32 -08004379void SurfaceFlinger::appendSfConfigString(std::string& result) const {
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004380 result.append(" [sf");
Fabien Sanglardc93afd52017-03-13 13:02:42 -07004381
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004382 if (isLayerTripleBufferingDisabled())
4383 result.append(" DISABLE_TRIPLE_BUFFERING");
Fabien Sanglardc45a7d92017-03-14 13:24:22 -07004384
Yiwei Zhang5434a782018-12-05 18:06:32 -08004385 StringAppendF(&result, " PRESENT_TIME_OFFSET=%" PRId64, dispSyncPresentTimeOffset);
4386 StringAppendF(&result, " FORCE_HWC_FOR_RBG_TO_YUV=%d", useHwcForRgbToYuv);
4387 StringAppendF(&result, " MAX_VIRT_DISPLAY_DIM=%" PRIu64, maxVirtualDisplaySize);
4388 StringAppendF(&result, " RUNNING_WITHOUT_SYNC_FRAMEWORK=%d", !hasSyncFramework);
4389 StringAppendF(&result, " NUM_FRAMEBUFFER_SURFACE_BUFFERS=%" PRId64,
4390 maxFrameBufferAcquiredBuffers);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08004391 result.append("]");
Andy McFadden4803b742012-09-24 19:07:20 -07004392}
4393
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004394void SurfaceFlinger::dumpVSync(std::string& result) const {
Dominik Laskowski98041832019-08-01 18:35:59 -07004395 mScheduler->dump(result);
Dominik Laskowski98041832019-08-01 18:35:59 -07004396
Steven Thomas2bbaabe2019-08-28 16:08:35 -07004397 mRefreshRateStats->dump(result);
Dominik Laskowski98041832019-08-01 18:35:59 -07004398 result.append("\n");
4399
Ady Abraham9e16a482019-12-03 17:19:41 -08004400 mPhaseConfiguration->dump(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004401 StringAppendF(&result,
Dominik Laskowski98041832019-08-01 18:35:59 -07004402 " present offset: %9" PRId64 " ns\t VSYNC period: %9" PRId64 " ns\n\n",
Ana Krulec757f63a2019-01-25 10:46:18 -08004403 dispSyncPresentTimeOffset, getVsyncPeriod());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004404
Steven Thomasd4071902020-03-24 16:02:53 -07004405 scheduler::RefreshRateConfigs::Policy policy = mRefreshRateConfigs->getDisplayManagerPolicy();
Ana Krulec234bb162019-11-10 22:55:55 +01004406 StringAppendF(&result,
Ana Kruleced3a8cc2019-11-14 00:55:07 +01004407 "DesiredDisplayConfigSpecs: default config ID: %d"
Ana Krulec234bb162019-11-10 22:55:55 +01004408 ", min: %.2f Hz, max: %.2f Hz",
Steven Thomasd4071902020-03-24 16:02:53 -07004409 policy.defaultConfig.value(), policy.minRefreshRate, policy.maxRefreshRate);
Ady Abraham42b3beb2019-07-09 18:09:52 -07004410 StringAppendF(&result, "(config override by backdoor: %s)\n\n",
4411 mDebugDisplayConfigSetByBackdoor ? "yes" : "no");
Dominik Laskowski98041832019-08-01 18:35:59 -07004412
Ana Krulecc2870422019-01-29 19:00:58 -08004413 mScheduler->dump(mAppConnectionHandle, result);
Ady Abraham75398722020-04-07 14:08:45 -07004414 mScheduler->getPrimaryDispSync().dump(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004415}
4416
Yiwei Zhang5434a782018-12-05 18:06:32 -08004417void SurfaceFlinger::dumpStaticScreenStats(std::string& result) const {
4418 result.append("Static screen stats:\n");
David Sodman4a36e932017-11-07 14:29:47 -08004419 for (size_t b = 0; b < SurfaceFlingerBE::NUM_BUCKETS - 1; ++b) {
4420 float bucketTimeSec = getBE().mFrameBuckets[b] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08004421 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08004422 static_cast<float>(getBE().mFrameBuckets[b]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004423 StringAppendF(&result, " < %zd frames: %.3f s (%.1f%%)\n", b + 1, bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08004424 }
David Sodman4a36e932017-11-07 14:29:47 -08004425 float bucketTimeSec = getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1] / 1e9;
Dan Stozab90cf072015-03-05 11:05:59 -08004426 float percent = 100.0f *
David Sodman4a36e932017-11-07 14:29:47 -08004427 static_cast<float>(getBE().mFrameBuckets[SurfaceFlingerBE::NUM_BUCKETS - 1]) / getBE().mTotalTime;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004428 StringAppendF(&result, " %zd+ frames: %.3f s (%.1f%%)\n", SurfaceFlingerBE::NUM_BUCKETS - 1,
4429 bucketTimeSec, percent);
Dan Stozab90cf072015-03-05 11:05:59 -08004430}
4431
Dominik Laskowski87a07e42019-10-10 20:38:02 -07004432void SurfaceFlinger::recordBufferingStats(const std::string& layerName,
4433 std::vector<OccupancyTracker::Segment>&& history) {
David Sodmancbaf0832017-11-07 14:21:36 -08004434 Mutex::Autolock lock(getBE().mBufferingStatsMutex);
4435 auto& stats = getBE().mBufferingStats[layerName];
Dan Stozae77c7662016-05-13 11:37:28 -07004436 for (const auto& segment : history) {
4437 if (!segment.usedThirdBuffer) {
4438 stats.twoBufferTime += segment.totalTime;
4439 }
4440 if (segment.occupancyAverage < 1.0f) {
4441 stats.doubleBufferedTime += segment.totalTime;
4442 } else if (segment.occupancyAverage < 2.0f) {
4443 stats.tripleBufferedTime += segment.totalTime;
4444 }
4445 ++stats.numSegments;
4446 stats.totalTime += segment.totalTime;
4447 }
4448}
4449
Yiwei Zhang5434a782018-12-05 18:06:32 -08004450void SurfaceFlinger::dumpFrameEventsLocked(std::string& result) {
4451 result.append("Layer frame timestamps:\n");
Brian Andersond6927fb2016-07-23 23:37:30 -07004452
4453 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
4454 const size_t count = currentLayers.size();
4455 for (size_t i=0 ; i<count ; i++) {
4456 currentLayers[i]->dumpFrameEvents(result);
4457 }
4458}
4459
Yiwei Zhang5434a782018-12-05 18:06:32 -08004460void SurfaceFlinger::dumpBufferingStats(std::string& result) const {
Dan Stozae77c7662016-05-13 11:37:28 -07004461 result.append("Buffering stats:\n");
4462 result.append(" [Layer name] <Active time> <Two buffer> "
4463 "<Double buffered> <Triple buffered>\n");
David Sodmancbaf0832017-11-07 14:21:36 -08004464 Mutex::Autolock lock(getBE().mBufferingStatsMutex);
Dan Stozae77c7662016-05-13 11:37:28 -07004465 typedef std::tuple<std::string, float, float, float> BufferTuple;
4466 std::map<float, BufferTuple, std::greater<float>> sorted;
David Sodmancbaf0832017-11-07 14:21:36 -08004467 for (const auto& statsPair : getBE().mBufferingStats) {
Dan Stozae77c7662016-05-13 11:37:28 -07004468 const char* name = statsPair.first.c_str();
David Sodmancbaf0832017-11-07 14:21:36 -08004469 const SurfaceFlingerBE::BufferingStats& stats = statsPair.second;
Dan Stozae77c7662016-05-13 11:37:28 -07004470 if (stats.numSegments == 0) {
4471 continue;
4472 }
4473 float activeTime = ns2ms(stats.totalTime) / 1000.0f;
4474 float twoBufferRatio = static_cast<float>(stats.twoBufferTime) /
4475 stats.totalTime;
4476 float doubleBufferRatio = static_cast<float>(
4477 stats.doubleBufferedTime) / stats.totalTime;
4478 float tripleBufferRatio = static_cast<float>(
4479 stats.tripleBufferedTime) / stats.totalTime;
4480 sorted.insert({activeTime, {name, twoBufferRatio,
4481 doubleBufferRatio, tripleBufferRatio}});
4482 }
4483 for (const auto& sortedPair : sorted) {
4484 float activeTime = sortedPair.first;
4485 const BufferTuple& values = sortedPair.second;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004486 StringAppendF(&result, " [%s] %.2f %.3f %.3f %.3f\n", std::get<0>(values).c_str(),
4487 activeTime, std::get<1>(values), std::get<2>(values), std::get<3>(values));
Dan Stozae77c7662016-05-13 11:37:28 -07004488 }
4489 result.append("\n");
4490}
4491
Yiwei Zhang5434a782018-12-05 18:06:32 -08004492void SurfaceFlinger::dumpDisplayIdentificationData(std::string& result) const {
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004493 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004494 const auto displayId = display->getId();
4495 if (!displayId) {
4496 continue;
4497 }
4498 const auto hwcDisplayId = getHwComposer().fromPhysicalDisplayId(*displayId);
Dominik Laskowski7e045462018-05-30 13:02:02 -07004499 if (!hwcDisplayId) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004500 continue;
4501 }
4502
Yiwei Zhang5434a782018-12-05 18:06:32 -08004503 StringAppendF(&result,
4504 "Display %s (HWC display %" PRIu64 "): ", to_string(*displayId).c_str(),
4505 *hwcDisplayId);
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004506 uint8_t port;
4507 DisplayIdentificationData data;
Dominik Laskowski7e045462018-05-30 13:02:02 -07004508 if (!getHwComposer().getDisplayIdentificationData(*hwcDisplayId, &port, &data)) {
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004509 result.append("no identification data\n");
4510 continue;
4511 }
4512
4513 if (!isEdid(data)) {
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004514 result.append("unknown identification data\n");
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004515 continue;
4516 }
4517
4518 const auto edid = parseEdid(data);
4519 if (!edid) {
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004520 result.append("invalid EDID\n");
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004521 continue;
4522 }
4523
Yiwei Zhang5434a782018-12-05 18:06:32 -08004524 StringAppendF(&result, "port=%u pnpId=%s displayName=\"", port, edid->pnpId.data());
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004525 result.append(edid->displayName.data(), edid->displayName.length());
4526 result.append("\"\n");
4527 }
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004528}
4529
Dominik Laskowskib6e54372019-09-04 14:06:28 -07004530void SurfaceFlinger::dumpRawDisplayIdentificationData(const DumpArgs& args,
4531 std::string& result) const {
4532 hwc2_display_t hwcDisplayId;
4533 uint8_t port;
4534 DisplayIdentificationData data;
4535
4536 if (args.size() > 1 && base::ParseUint(String8(args[1]), &hwcDisplayId) &&
4537 getHwComposer().getDisplayIdentificationData(hwcDisplayId, &port, &data)) {
4538 result.append(reinterpret_cast<const char*>(data.data()), data.size());
4539 }
4540}
4541
Yiwei Zhang5434a782018-12-05 18:06:32 -08004542void SurfaceFlinger::dumpWideColorInfo(std::string& result) const {
Peiyong Linff84a152019-05-17 18:36:19 -07004543 StringAppendF(&result, "Device has wide color built-in display: %d\n", hasWideColorDisplay);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004544 StringAppendF(&result, "Device uses color management: %d\n", useColorManagement);
4545 StringAppendF(&result, "DisplayColorSetting: %s\n",
4546 decodeDisplayColorSetting(mDisplayColorSetting).c_str());
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004547
4548 // TODO: print out if wide-color mode is active or not
4549
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004550 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004551 const auto displayId = display->getId();
4552 if (!displayId) {
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004553 continue;
4554 }
4555
Yiwei Zhang5434a782018-12-05 18:06:32 -08004556 StringAppendF(&result, "Display %s color modes:\n", to_string(*displayId).c_str());
Dominik Laskowski075d3172018-05-24 15:50:06 -07004557 std::vector<ColorMode> modes = getHwComposer().getColorModes(*displayId);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004558 for (auto&& mode : modes) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08004559 StringAppendF(&result, " %s (%d)\n", decodeColorMode(mode).c_str(), mode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004560 }
4561
Lloyd Pique32cbe282018-10-19 13:09:22 -07004562 ColorMode currentMode = display->getCompositionDisplay()->getState().colorMode;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004563 StringAppendF(&result, " Current color mode: %s (%d)\n",
4564 decodeColorMode(currentMode).c_str(), currentMode);
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004565 }
4566 result.append("\n");
4567}
4568
Alec Mouri5793c7d2020-03-10 19:55:50 -07004569LayersProto SurfaceFlinger::dumpDrawingStateProto(
4570 uint32_t traceFlags, const sp<const DisplayDevice>& displayDevice) const {
chaviw1d044282017-09-27 12:19:28 -07004571 LayersProto layersProto;
chaviw08f3cb22020-01-13 13:17:21 -08004572 for (const sp<Layer>& layer : mDrawingState.layersSortedByZ) {
Alec Mouri5793c7d2020-03-10 19:55:50 -07004573 layer->writeToProto(layersProto, traceFlags, displayDevice);
chaviw08f3cb22020-01-13 13:17:21 -08004574 }
Alec Mouri6b9e9912020-01-21 10:50:24 -08004575
chaviw1d044282017-09-27 12:19:28 -07004576 return layersProto;
4577}
4578
Alec Mouri6b9e9912020-01-21 10:50:24 -08004579void SurfaceFlinger::dumpHwc(std::string& result) const {
4580 getHwComposer().dump(result);
4581}
4582
Vishnu Nair0f085c62019-08-30 08:49:12 -07004583void SurfaceFlinger::dumpOffscreenLayersProto(LayersProto& layersProto, uint32_t traceFlags) const {
4584 // Add a fake invisible root layer to the proto output and parent all the offscreen layers to
4585 // it.
4586 LayerProto* rootProto = layersProto.add_layers();
4587 const int32_t offscreenRootLayerId = INT32_MAX - 2;
4588 rootProto->set_id(offscreenRootLayerId);
4589 rootProto->set_name("Offscreen Root");
Vishnu Naird5aeb612019-09-20 14:39:39 -07004590 rootProto->set_parent(-1);
Vishnu Nair0f085c62019-08-30 08:49:12 -07004591
4592 for (Layer* offscreenLayer : mOffscreenLayers) {
4593 // Add layer as child of the fake root
4594 rootProto->add_children(offscreenLayer->sequence);
4595
4596 // Add layer
Alec Mouri6b9e9912020-01-21 10:50:24 -08004597 LayerProto* layerProto =
4598 offscreenLayer->writeToProto(layersProto, traceFlags, nullptr /*device*/);
Vishnu Nair0f085c62019-08-30 08:49:12 -07004599 layerProto->set_parent(offscreenRootLayerId);
Vishnu Nair0f085c62019-08-30 08:49:12 -07004600 }
4601}
4602
Vishnu Nair8406fd72019-07-30 11:29:31 -07004603LayersProto SurfaceFlinger::dumpProtoFromMainThread(uint32_t traceFlags) {
4604 LayersProto layersProto;
Alec Mouri5793c7d2020-03-10 19:55:50 -07004605 postMessageSync(new LambdaMessage([&]() {
4606 const auto& displayDevice = getDefaultDisplayDeviceLocked();
4607 layersProto = dumpDrawingStateProto(traceFlags, displayDevice);
4608 }));
Vishnu Nair8406fd72019-07-30 11:29:31 -07004609 return layersProto;
4610}
4611
Vishnu Nair0f085c62019-08-30 08:49:12 -07004612void SurfaceFlinger::dumpOffscreenLayers(std::string& result) {
4613 result.append("Offscreen Layers:\n");
4614 postMessageSync(new LambdaMessage([&]() {
4615 for (Layer* offscreenLayer : mOffscreenLayers) {
Edgar Arriaga844fa672020-01-16 14:21:42 -08004616 offscreenLayer->traverse(LayerVector::StateSet::Drawing, [&](Layer* layer) {
Vishnu Nair0f085c62019-08-30 08:49:12 -07004617 layer->dumpCallingUidPid(result);
4618 });
4619 }
4620 }));
4621}
4622
Dominik Laskowskic2867142019-01-21 11:33:38 -08004623void SurfaceFlinger::dumpAllLocked(const DumpArgs& args, std::string& result) const {
4624 const bool colorize = !args.empty() && args[0] == String16("--color");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004625 Colorizer colorizer(colorize);
4626
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004627 // figure out if we're stuck somewhere
4628 const nsecs_t now = systemTime();
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004629 const nsecs_t inTransaction(mDebugInTransaction);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004630 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
4631
4632 /*
Andy McFadden4803b742012-09-24 19:07:20 -07004633 * Dump library configuration.
4634 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004635
4636 colorizer.bold(result);
Andy McFadden4803b742012-09-24 19:07:20 -07004637 result.append("Build configuration:");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004638 colorizer.reset(result);
Andy McFadden4803b742012-09-24 19:07:20 -07004639 appendSfConfigString(result);
4640 appendUiConfigString(result);
4641 appendGuiConfigString(result);
4642 result.append("\n");
4643
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -07004644 result.append("\nDisplay identification data:\n");
4645 dumpDisplayIdentificationData(result);
4646
Courtney Goeltzenleuchterf3b2de12017-03-27 12:18:12 -06004647 result.append("\nWide-Color information:\n");
4648 dumpWideColorInfo(result);
4649
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004650 colorizer.bold(result);
Mathias Agopianca088332013-03-28 17:44:13 -07004651 result.append("Sync configuration: ");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004652 colorizer.reset(result);
Mathias Agopianca088332013-03-28 17:44:13 -07004653 result.append(SyncFeatures::getInstance().toString());
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004654 result.append("\n\n");
Mathias Agopianca088332013-03-28 17:44:13 -07004655
Andy McFadden41d67d72014-04-25 16:58:34 -07004656 colorizer.bold(result);
Dominik Laskowski98041832019-08-01 18:35:59 -07004657 result.append("Scheduler:\n");
Andy McFadden41d67d72014-04-25 16:58:34 -07004658 colorizer.reset(result);
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004659 dumpVSync(result);
Dan Stozab90cf072015-03-05 11:05:59 -08004660 result.append("\n");
Dominik Laskowskid9e4de62019-01-21 14:23:01 -08004661
Dan Stozab90cf072015-03-05 11:05:59 -08004662 dumpStaticScreenStats(result);
4663 result.append("\n");
4664
Alec Mouri40189b02019-03-05 15:07:54 -08004665 StringAppendF(&result, "Total missed frame count: %u\n", mFrameMissedCount.load());
4666 StringAppendF(&result, "HWC missed frame count: %u\n", mHwcFrameMissedCount.load());
4667 StringAppendF(&result, "GPU missed frame count: %u\n\n", mGpuFrameMissedCount.load());
Marissa Wallcfcdaa52018-05-21 15:45:59 -07004668
Dan Stozae77c7662016-05-13 11:37:28 -07004669 dumpBufferingStats(result);
4670
Andy McFadden4803b742012-09-24 19:07:20 -07004671 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004672 * Dump the visible layer list
4673 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004674 colorizer.bold(result);
chaviweadf0d42019-08-12 13:28:29 -07004675 StringAppendF(&result, "Visible layers (count = %zu)\n", mNumLayers.load());
Yiwei Zhang5434a782018-12-05 18:06:32 -08004676 StringAppendF(&result, "GraphicBufferProducers: %zu, max %zu\n",
4677 mGraphicBufferProducerList.size(), mMaxGraphicBufferProducerListSize);
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004678 colorizer.reset(result);
chaviw1d044282017-09-27 12:19:28 -07004679
Chia-I Wu2f884132018-09-13 15:17:58 -07004680 {
Lloyd Pique207def92019-02-28 16:09:52 -08004681 StringAppendF(&result, "Composition layers\n");
4682 mDrawingState.traverseInZOrder([&](Layer* layer) {
Lloyd Piquede196652020-01-22 17:29:58 -08004683 auto* compositionState = layer->getCompositionState();
4684 if (!compositionState) return;
4685
4686 android::base::StringAppendF(&result, "* Layer %p (%s)\n", layer,
4687 layer->getDebugName() ? layer->getDebugName()
4688 : "<unknown>");
4689 compositionState->dump(result);
Lloyd Pique207def92019-02-28 16:09:52 -08004690 });
4691 }
4692
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004693 /*
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004694 * Dump Display state
4695 */
4696
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004697 colorizer.bold(result);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004698 StringAppendF(&result, "Displays (%zu entries)\n", mDisplays.size());
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004699 colorizer.reset(result);
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004700 for (const auto& [token, display] : mDisplays) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07004701 display->dump(result);
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004702 }
Chia-I Wu1e043612018-03-01 09:45:09 -08004703 result.append("\n");
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07004704
4705 /*
Lloyd Piquec3cb7292019-05-17 15:25:14 -07004706 * Dump CompositionEngine state
4707 */
4708
4709 mCompositionEngine->dump(result);
4710
4711 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004712 * Dump SurfaceFlinger global state
4713 */
4714
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004715 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02004716 result.append("SurfaceFlinger global state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004717 colorizer.reset(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004718
Lloyd Piqueb97e04f2018-10-18 17:07:05 -07004719 getRenderEngine().dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004720
Ady Abrahama3b08ef2019-07-15 18:43:10 -07004721 DebugEGLImageTracker::getInstance()->dump(result);
4722
Dominik Laskowski075d3172018-05-24 15:50:06 -07004723 if (const auto display = getDefaultDisplayDeviceLocked()) {
Lloyd Pique32cbe282018-10-19 13:09:22 -07004724 display->getCompositionDisplay()->getState().undefinedRegion.dump(result,
4725 "undefinedRegion");
Dominik Laskowski718f9602019-11-09 20:01:35 -08004726 StringAppendF(&result, " orientation=%s, isPoweredOn=%d\n",
4727 toCString(display->getOrientation()), display->isPoweredOn());
Lloyd Pique2ae2b3b2017-12-14 17:18:17 -08004728 }
Yiwei Zhang5434a782018-12-05 18:06:32 -08004729 StringAppendF(&result,
4730 " transaction-flags : %08x\n"
4731 " gpu_to_cpu_unsupported : %d\n",
4732 mTransactionFlags.load(), !mGpuToCpuSupported);
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004733
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08004734 if (const auto displayId = getInternalDisplayIdLocked();
Dominik Laskowski075d3172018-05-24 15:50:06 -07004735 displayId && getHwComposer().isConnected(*displayId)) {
4736 const auto activeConfig = getHwComposer().getActiveConfig(*displayId);
Yiwei Zhang5434a782018-12-05 18:06:32 -08004737 StringAppendF(&result,
4738 " refresh-rate : %f fps\n"
4739 " x-dpi : %f\n"
4740 " y-dpi : %f\n",
Ady Abraham3a77a7b2019-12-02 18:46:59 -08004741 1e9 / getHwComposer().getDisplayVsyncPeriod(*displayId),
4742 activeConfig->getDpiX(), activeConfig->getDpiY());
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07004743 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004744
Yiwei Zhang5434a782018-12-05 18:06:32 -08004745 StringAppendF(&result, " transaction time: %f us\n", inTransactionDuration / 1000.0);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004746
Dan Stozae22aec72016-08-01 13:20:59 -07004747 /*
Yichi Chenadc69612018-09-15 14:51:18 +08004748 * Tracing state
4749 */
4750 mTracing.dump(result);
4751 result.append("\n");
4752
4753 /*
Dan Stozae22aec72016-08-01 13:20:59 -07004754 * HWC layer minidump
4755 */
Dominik Laskowski9fae1022018-05-29 13:17:40 -07004756 for (const auto& [token, display] : mDisplays) {
Dominik Laskowski075d3172018-05-24 15:50:06 -07004757 const auto displayId = display->getId();
4758 if (!displayId) {
Dan Stozae22aec72016-08-01 13:20:59 -07004759 continue;
4760 }
4761
Yiwei Zhang5434a782018-12-05 18:06:32 -08004762 StringAppendF(&result, "Display %s HWC layers:\n", to_string(*displayId).c_str());
Dan Stozae22aec72016-08-01 13:20:59 -07004763 Layer::miniDumpHeader(result);
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08004764 const sp<DisplayDevice> displayDevice = display;
4765 mCurrentState.traverseInZOrder(
4766 [&](Layer* layer) { layer->miniDump(result, displayDevice); });
Dan Stozae22aec72016-08-01 13:20:59 -07004767 result.append("\n");
4768 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004769
4770 /*
4771 * Dump HWComposer state
4772 */
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004773 colorizer.bold(result);
Mathias Agopian74d211a2013-04-22 16:55:35 +02004774 result.append("h/w composer state:\n");
Mathias Agopian3e25fd82013-04-22 17:52:16 +02004775 colorizer.reset(result);
Dan Stoza9f26a9c2016-06-22 14:51:09 -07004776 bool hwcDisabled = mDebugDisableHWC || mDebugRegion;
Yiwei Zhang5434a782018-12-05 18:06:32 -08004777 StringAppendF(&result, " h/w composer %s\n", hwcDisabled ? "disabled" : "enabled");
Dominik Laskowski075d3172018-05-24 15:50:06 -07004778 getHwComposer().dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004779
4780 /*
4781 * Dump gralloc state
4782 */
4783 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
4784 alloc.dump(result);
Karthik Ravi Shankar171155a2017-06-28 15:40:24 -07004785
4786 /*
4787 * Dump VrFlinger state if in use.
4788 */
4789 if (mVrFlingerRequestsDisplay && mVrFlinger) {
4790 result.append("VrFlinger state:\n");
Yiwei Zhang5434a782018-12-05 18:06:32 -08004791 result.append(mVrFlinger->Dump());
Karthik Ravi Shankar171155a2017-06-28 15:40:24 -07004792 result.append("\n");
4793 }
Ana Krulecb43429d2019-01-09 14:28:51 -08004794
Yiwei Zhang7eb58b72019-04-22 19:00:02 -07004795 result.append(mTimeStats->miniDump());
4796 result.append("\n");
Mathias Agopian82d7ab62012-01-19 18:34:40 -08004797}
4798
Chia-I Wu28f320b2018-05-03 11:02:56 -07004799void SurfaceFlinger::updateColorMatrixLocked() {
4800 mat4 colorMatrix;
4801 if (mGlobalSaturationFactor != 1.0f) {
4802 // Rec.709 luma coefficients
4803 float3 luminance{0.213f, 0.715f, 0.072f};
4804 luminance *= 1.0f - mGlobalSaturationFactor;
4805 mat4 saturationMatrix = mat4(
4806 vec4{luminance.r + mGlobalSaturationFactor, luminance.r, luminance.r, 0.0f},
4807 vec4{luminance.g, luminance.g + mGlobalSaturationFactor, luminance.g, 0.0f},
4808 vec4{luminance.b, luminance.b, luminance.b + mGlobalSaturationFactor, 0.0f},
4809 vec4{0.0f, 0.0f, 0.0f, 1.0f}
4810 );
4811 colorMatrix = mClientColorMatrix * saturationMatrix * mDaltonizer();
4812 } else {
4813 colorMatrix = mClientColorMatrix * mDaltonizer();
4814 }
4815
4816 if (mCurrentState.colorMatrix != colorMatrix) {
4817 mCurrentState.colorMatrix = colorMatrix;
4818 mCurrentState.colorMatrixChanged = true;
4819 setTransactionFlags(eTransactionNeeded);
4820 }
4821}
4822
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07004823status_t SurfaceFlinger::CheckTransactCodeCredentials(uint32_t code) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004824#pragma clang diagnostic push
4825#pragma clang diagnostic error "-Wswitch-enum"
4826 switch (static_cast<ISurfaceComposerTag>(code)) {
4827 // These methods should at minimum make sure that the client requested
4828 // access to SF.
Dan Stozae3344402018-08-20 19:53:42 +00004829 case BOOT_FINISHED:
4830 case CLEAR_ANIMATION_FRAME_STATS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004831 case CREATE_DISPLAY:
4832 case DESTROY_DISPLAY:
Dan Stozae3344402018-08-20 19:53:42 +00004833 case ENABLE_VSYNC_INJECTIONS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004834 case GET_ANIMATION_FRAME_STATS:
4835 case GET_HDR_CAPABILITIES:
Ana Krulec0782b882019-10-15 17:34:54 -07004836 case SET_DESIRED_DISPLAY_CONFIG_SPECS:
Ana Krulec234bb162019-11-10 22:55:55 +01004837 case GET_DESIRED_DISPLAY_CONFIG_SPECS:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004838 case SET_ACTIVE_COLOR_MODE:
Galia Peycheva5492cb52019-10-30 14:13:16 +01004839 case GET_AUTO_LOW_LATENCY_MODE_SUPPORT:
4840 case SET_AUTO_LOW_LATENCY_MODE:
4841 case GET_GAME_CONTENT_TYPE_SUPPORT:
4842 case SET_GAME_CONTENT_TYPE:
Chia-I Wu90f669f2017-10-05 14:24:41 -07004843 case INJECT_VSYNC:
Kevin DuBois9c0a1762018-10-16 13:32:31 -07004844 case SET_POWER_MODE:
Kevin DuBois74e53772018-11-19 10:52:38 -08004845 case GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES:
Kevin DuBois1d4249a2018-08-29 10:45:14 -07004846 case SET_DISPLAY_CONTENT_SAMPLING_ENABLED:
Ady Abraham8532d012019-05-08 14:50:56 -07004847 case GET_DISPLAYED_CONTENT_SAMPLE:
Vishnu Nairb13bb952019-11-15 10:24:08 -08004848 case NOTIFY_POWER_HINT:
Steven Thomasd4071902020-03-24 16:02:53 -07004849 case SET_GLOBAL_SHADOW_SETTINGS:
4850 case ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN: {
4851 // ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN is used by CTS tests, which acquire the
4852 // necessary permission dynamically. Don't use the permission cache for this check.
4853 bool usePermissionCache = code != ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN;
4854 if (!callingThreadHasUnscopedSurfaceFlingerAccess(usePermissionCache)) {
Robert Carrd4ae7f32018-06-07 16:10:57 -07004855 IPCThreadState* ipc = IPCThreadState::self();
4856 ALOGE("Permission Denial: can't access SurfaceFlinger pid=%d, uid=%d",
4857 ipc->getCallingPid(), ipc->getCallingUid());
Mathias Agopian375f5632009-06-15 18:24:59 -07004858 return PERMISSION_DENIED;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004859 }
Robert Carr1db73f62016-12-21 12:58:51 -08004860 return OK;
4861 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004862 case GET_LAYER_DEBUG_INFO: {
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07004863 IPCThreadState* ipc = IPCThreadState::self();
4864 const int pid = ipc->getCallingPid();
4865 const int uid = ipc->getCallingUid();
Ana Krulec13be8ad2018-08-21 02:43:56 +00004866 if ((uid != AID_SHELL) && !PermissionCache::checkPermission(sDump, pid, uid)) {
4867 ALOGE("Layer debug info permission denied for pid=%d, uid=%d", pid, uid);
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07004868 return PERMISSION_DENIED;
4869 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004870 return OK;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004871 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004872 // Used by apps to hook Choreographer to SurfaceFlinger.
4873 case CREATE_DISPLAY_EVENT_CONNECTION:
4874 // The following calls are currently used by clients that do not
4875 // request necessary permissions. However, they do not expose any secret
4876 // information, so it is OK to pass them.
4877 case AUTHENTICATE_SURFACE:
Peiyong Lind1fedb42019-03-11 17:48:41 -07004878 case GET_ACTIVE_COLOR_MODE:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004879 case GET_ACTIVE_CONFIG:
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08004880 case GET_PHYSICAL_DISPLAY_IDS:
4881 case GET_PHYSICAL_DISPLAY_TOKEN:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004882 case GET_DISPLAY_COLOR_MODES:
Daniel Solomon42d04562019-01-20 21:03:19 -08004883 case GET_DISPLAY_NATIVE_PRIMARIES:
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08004884 case GET_DISPLAY_INFO:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004885 case GET_DISPLAY_CONFIGS:
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08004886 case GET_DISPLAY_STATE:
Ana Krulec13be8ad2018-08-21 02:43:56 +00004887 case GET_DISPLAY_STATS:
4888 case GET_SUPPORTED_FRAME_TIMESTAMPS:
4889 // Calling setTransactionState is safe, because you need to have been
4890 // granted a reference to Client* and Handle* to do anything with it.
4891 case SET_TRANSACTION_STATE:
Robert Carrb89ea9d2018-12-10 13:01:14 -08004892 case CREATE_CONNECTION:
Ady Abraham37965d42018-11-01 13:43:32 -07004893 case GET_COLOR_MANAGEMENT:
Peiyong Lin3c2791e2019-01-14 17:05:18 -08004894 case GET_COMPOSITION_PREFERENCE:
Marissa Wallebc2c052019-01-16 19:16:55 -08004895 case GET_PROTECTED_CONTENT_SUPPORT:
Dan Gittik57e63c52019-01-18 16:37:54 +00004896 case IS_WIDE_COLOR_DISPLAY:
Steven Thomas62a4cf82020-01-31 12:04:03 -08004897 // setFrameRate() is deliberately available for apps to call without any
4898 // special permissions.
4899 case SET_FRAME_RATE:
Dan Gittik57e63c52019-01-18 16:37:54 +00004900 case GET_DISPLAY_BRIGHTNESS_SUPPORT:
4901 case SET_DISPLAY_BRIGHTNESS: {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004902 return OK;
4903 }
Chong Zhangd1690d12019-10-04 17:47:13 +00004904 case CAPTURE_LAYERS:
Dan Stoza84ab9372018-12-17 15:27:57 -08004905 case CAPTURE_SCREEN:
4906 case ADD_REGION_SAMPLING_LISTENER:
4907 case REMOVE_REGION_SAMPLING_LISTENER: {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004908 // codes that require permission check
chaviwa76b2712017-09-20 12:02:26 -07004909 IPCThreadState* ipc = IPCThreadState::self();
4910 const int pid = ipc->getCallingPid();
4911 const int uid = ipc->getCallingUid();
4912 if ((uid != AID_GRAPHICS) &&
4913 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
4914 ALOGE("Permission Denial: can't read framebuffer pid=%d, uid=%d", pid, uid);
4915 return PERMISSION_DENIED;
4916 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004917 return OK;
4918 }
chaviw93df2ea2019-04-30 16:45:12 -07004919 case CAPTURE_SCREEN_BY_ID: {
4920 IPCThreadState* ipc = IPCThreadState::self();
4921 const int uid = ipc->getCallingUid();
Peiyong Lin96cfebc2019-05-15 11:36:13 -07004922 if (uid == AID_ROOT || uid == AID_GRAPHICS || uid == AID_SYSTEM || uid == AID_SHELL) {
chaviw93df2ea2019-04-30 16:45:12 -07004923 return OK;
4924 }
4925 return PERMISSION_DENIED;
4926 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004927 }
Ana Krulec13be8ad2018-08-21 02:43:56 +00004928
4929 // These codes are used for the IBinder protocol to either interrogate the recipient
4930 // side of the transaction for its canonical interface descriptor or to dump its state.
4931 // We let them pass by default.
4932 if (code == IBinder::INTERFACE_TRANSACTION || code == IBinder::DUMP_TRANSACTION ||
4933 code == IBinder::PING_TRANSACTION || code == IBinder::SHELL_COMMAND_TRANSACTION ||
4934 code == IBinder::SYSPROPS_TRANSACTION) {
4935 return OK;
4936 }
Ady Abraham03b02dd2019-03-21 15:40:11 -07004937 // Numbers from 1000 to 1034 are currently used for backdoors. The code
Ana Krulec13be8ad2018-08-21 02:43:56 +00004938 // in onTransact verifies that the user is root, and has access to use SF.
Ady Abraham34392f72019-04-10 11:29:27 -07004939 if (code >= 1000 && code <= 1035) {
Ana Krulec13be8ad2018-08-21 02:43:56 +00004940 ALOGV("Accessing SurfaceFlinger through backdoor code: %u", code);
4941 return OK;
4942 }
4943 ALOGE("Permission Denial: SurfaceFlinger did not recognize request code: %u", code);
4944 return PERMISSION_DENIED;
4945#pragma clang diagnostic pop
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07004946}
4947
Ana Krulec13be8ad2018-08-21 02:43:56 +00004948status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
4949 uint32_t flags) {
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07004950 status_t credentialCheck = CheckTransactCodeCredentials(code);
4951 if (credentialCheck != OK) {
4952 return credentialCheck;
4953 }
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07004954
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004955 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
4956 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
Mathias Agopianb8a55602009-06-26 19:06:36 -07004957 CHECK_INTERFACE(ISurfaceComposer, data, reply);
Romain Guy8c6bbd62017-06-05 13:51:43 -07004958 IPCThreadState* ipc = IPCThreadState::self();
4959 const int uid = ipc->getCallingUid();
4960 if (CC_UNLIKELY(uid != AID_SYSTEM
4961 && !PermissionCache::checkCallingPermission(sHardwareTest))) {
Mathias Agopian375f5632009-06-15 18:24:59 -07004962 const int pid = ipc->getCallingPid();
Steve Blocke6f43dd2012-01-06 19:20:56 +00004963 ALOGE("Permission Denial: "
Mathias Agopian375f5632009-06-15 18:24:59 -07004964 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004965 return PERMISSION_DENIED;
4966 }
4967 int n;
4968 switch (code) {
Mathias Agopian01b76682009-04-16 20:04:08 -07004969 case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
Mathias Agopian35b48d12010-09-13 22:57:58 -07004970 case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004971 return NO_ERROR;
4972 case 1002: // SHOW_UPDATES
4973 n = data.readInt32();
4974 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
Mathias Agopian53331da2011-08-22 21:44:41 -07004975 invalidateHwcGeometry();
4976 repaintEverything();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004977 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004978 case 1004:{ // repaint everything
Mathias Agopian53331da2011-08-22 21:44:41 -07004979 repaintEverything();
Mathias Agopiancbb288b2009-09-07 16:32:45 -07004980 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08004981 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -07004982 case 1005:{ // force transaction
Steven Thomas6d8110b2017-08-31 18:24:21 -07004983 Mutex::Autolock _l(mStateLock);
Mathias Agopiane57f2922012-08-09 16:29:12 -07004984 setTransactionFlags(
4985 eTransactionNeeded|
4986 eDisplayTransactionNeeded|
4987 eTraversalNeeded);
Mathias Agopiancbb288b2009-09-07 16:32:45 -07004988 return NO_ERROR;
4989 }
Mathias Agopian4d143ee2012-02-23 20:05:39 -08004990 case 1006:{ // send empty update
4991 signalRefresh();
4992 return NO_ERROR;
4993 }
Mathias Agopian53331da2011-08-22 21:44:41 -07004994 case 1008: // toggle use of hw composer
4995 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07004996 mDebugDisableHWC = n != 0;
Mathias Agopian53331da2011-08-22 21:44:41 -07004997 invalidateHwcGeometry();
4998 repaintEverything();
4999 return NO_ERROR;
Mathias Agopiana4583642011-08-23 18:03:18 -07005000 case 1009: // toggle use of transform hint
5001 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005002 mDebugDisableTransformHint = n != 0;
Mathias Agopiana4583642011-08-23 18:03:18 -07005003 invalidateHwcGeometry();
5004 repaintEverything();
5005 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005006 case 1010: // interrogate.
Mathias Agopian01b76682009-04-16 20:04:08 -07005007 reply->writeInt32(0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005008 reply->writeInt32(0);
5009 reply->writeInt32(mDebugRegion);
Mathias Agopianb9494d52012-04-18 02:28:45 -07005010 reply->writeInt32(0);
Dianne Hackborn12839be2012-02-06 21:21:05 -08005011 reply->writeInt32(mDebugDisableHWC);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005012 return NO_ERROR;
5013 case 1013: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005014 const auto display = getDefaultDisplayDevice();
Dominik Laskowski45de9bd2018-06-11 17:44:10 -07005015 if (!display) {
5016 return NAME_NOT_FOUND;
5017 }
5018
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005019 reply->writeInt32(display->getPageFlipCount());
Mathias Agopianff2ed702013-09-01 21:36:12 -07005020 return NO_ERROR;
5021 }
5022 case 1014: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005023 Mutex::Autolock _l(mStateLock);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005024 // daltonize
5025 n = data.readInt32();
5026 switch (n % 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005027 case 1:
5028 mDaltonizer.setType(ColorBlindnessType::Protanomaly);
5029 break;
5030 case 2:
5031 mDaltonizer.setType(ColorBlindnessType::Deuteranomaly);
5032 break;
5033 case 3:
5034 mDaltonizer.setType(ColorBlindnessType::Tritanomaly);
5035 break;
5036 default:
5037 mDaltonizer.setType(ColorBlindnessType::None);
5038 break;
Mathias Agopianff2ed702013-09-01 21:36:12 -07005039 }
5040 if (n >= 10) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005041 mDaltonizer.setMode(ColorBlindnessMode::Correction);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005042 } else {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005043 mDaltonizer.setMode(ColorBlindnessMode::Simulation);
Mathias Agopianff2ed702013-09-01 21:36:12 -07005044 }
Chia-I Wu28f320b2018-05-03 11:02:56 -07005045
5046 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005047 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005048 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005049 case 1015: {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005050 Mutex::Autolock _l(mStateLock);
Alan Viverette9c5a3332013-09-12 20:04:35 -07005051 // apply a color matrix
5052 n = data.readInt32();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005053 if (n) {
Romain Guy0147a172017-06-01 13:53:56 -07005054 // color matrix is sent as a column-major mat4 matrix
Alan Viverette794c5ba2013-10-03 16:40:52 -07005055 for (size_t i = 0 ; i < 4; i++) {
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005056 for (size_t j = 0; j < 4; j++) {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005057 mClientColorMatrix[i][j] = data.readFloat();
Dan Stoza9f26a9c2016-06-22 14:51:09 -07005058 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005059 }
Alan Viverette9c5a3332013-09-12 20:04:35 -07005060 } else {
Chia-I Wu28f320b2018-05-03 11:02:56 -07005061 mClientColorMatrix = mat4();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005062 }
Romain Guy88d37dd2017-05-26 17:57:05 -07005063
5064 // Check that supplied matrix's last row is {0,0,0,1} so we can avoid
5065 // the division by w in the fragment shader
Chia-I Wu28f320b2018-05-03 11:02:56 -07005066 float4 lastRow(transpose(mClientColorMatrix)[3]);
Romain Guy88d37dd2017-05-26 17:57:05 -07005067 if (any(greaterThan(abs(lastRow - float4{0, 0, 0, 1}), float4{1e-4f}))) {
5068 ALOGE("The color transform's last row must be (0, 0, 0, 1)");
5069 }
5070
Chia-I Wu28f320b2018-05-03 11:02:56 -07005071 updateColorMatrixLocked();
Alan Viverette9c5a3332013-09-12 20:04:35 -07005072 return NO_ERROR;
5073 }
Dominik Laskowski8d32ddc2019-08-07 11:25:35 -07005074 case 1016: { // Unused.
5075 return NAME_NOT_FOUND;
Ruchi Kandoif52b3c82014-04-24 16:42:35 -07005076 }
Dan Stozaee44edd2015-03-23 15:50:23 -07005077 case 1017: {
5078 n = data.readInt32();
Dominik Laskowski9dab3432019-03-27 13:21:10 -07005079 mForceFullDamage = n != 0;
Dan Stozaee44edd2015-03-23 15:50:23 -07005080 return NO_ERROR;
5081 }
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005082 case 1018: { // Modify Choreographer's phase offset
5083 n = data.readInt32();
Ana Krulecc2870422019-01-29 19:00:58 -08005084 mScheduler->setPhaseOffset(mAppConnectionHandle, static_cast<nsecs_t>(n));
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005085 return NO_ERROR;
5086 }
5087 case 1019: { // Modify SurfaceFlinger's phase offset
5088 n = data.readInt32();
Ana Krulecc2870422019-01-29 19:00:58 -08005089 mScheduler->setPhaseOffset(mSfConnectionHandle, static_cast<nsecs_t>(n));
Dan Stozadb4ac3c2015-04-14 11:34:01 -07005090 return NO_ERROR;
5091 }
Irvel468051e2016-06-13 16:44:44 -07005092 case 1020: { // Layer updates interceptor
5093 n = data.readInt32();
5094 if (n) {
5095 ALOGV("Interceptor enabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08005096 mInterceptor->enable(mDrawingState.layersSortedByZ, mDrawingState.displays);
Irvel468051e2016-06-13 16:44:44 -07005097 }
5098 else{
5099 ALOGV("Interceptor disabled");
Lloyd Pique4dccc412018-01-22 17:21:36 -08005100 mInterceptor->disable();
Irvel468051e2016-06-13 16:44:44 -07005101 }
5102 return NO_ERROR;
5103 }
Dan Stoza8cf150a2016-08-02 10:27:31 -07005104 case 1021: { // Disable HWC virtual displays
5105 n = data.readInt32();
5106 mUseHwcVirtualDisplays = !n;
5107 return NO_ERROR;
5108 }
Romain Guy0147a172017-06-01 13:53:56 -07005109 case 1022: { // Set saturation boost
Chia-I Wu28f320b2018-05-03 11:02:56 -07005110 Mutex::Autolock _l(mStateLock);
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005111 mGlobalSaturationFactor = std::max(0.0f, std::min(data.readFloat(), 2.0f));
Romain Guy0147a172017-06-01 13:53:56 -07005112
Chia-I Wu28f320b2018-05-03 11:02:56 -07005113 updateColorMatrixLocked();
Romain Guy0147a172017-06-01 13:53:56 -07005114 return NO_ERROR;
5115 }
Romain Guy54f154a2017-10-24 21:40:32 +01005116 case 1023: { // Set native mode
Daniel Solomon7c7ede22019-07-11 16:35:40 -07005117 int32_t colorMode;
5118
Chia-I Wu0d711262018-05-21 15:19:35 -07005119 mDisplayColorSetting = static_cast<DisplayColorSetting>(data.readInt32());
Daniel Solomon7c7ede22019-07-11 16:35:40 -07005120 if (data.readInt32(&colorMode) == NO_ERROR) {
5121 mForceColorMode = static_cast<ColorMode>(colorMode);
5122 }
Romain Guy54f154a2017-10-24 21:40:32 +01005123 invalidateHwcGeometry();
5124 repaintEverything();
5125 return NO_ERROR;
5126 }
Peiyong Lin4bac91c2018-10-25 09:48:33 -07005127 // Deprecate, use 1030 to check whether the device is color managed.
5128 case 1024: {
5129 return NAME_NOT_FOUND;
Romain Guy54f154a2017-10-24 21:40:32 +01005130 }
Vishnu Nair87704c92018-01-08 15:32:57 -08005131 case 1025: { // Set layer tracing
Adrian Roos1e1a1282017-11-01 19:05:31 +01005132 n = data.readInt32();
5133 if (n) {
Yichi Chenadc69612018-09-15 14:51:18 +08005134 ALOGD("LayerTracing enabled");
Nataniel Borges2b796da2019-02-15 13:32:18 -08005135 Mutex::Autolock lock(mStateLock);
5136 mTracingEnabledChanged = true;
Adrian Roos1e1a1282017-11-01 19:05:31 +01005137 mTracing.enable();
Adrian Roos1e1a1282017-11-01 19:05:31 +01005138 reply->writeInt32(NO_ERROR);
5139 } else {
Yichi Chenadc69612018-09-15 14:51:18 +08005140 ALOGD("LayerTracing disabled");
Nataniel Borges2b796da2019-02-15 13:32:18 -08005141 bool writeFile = false;
5142 {
5143 Mutex::Autolock lock(mStateLock);
5144 mTracingEnabledChanged = true;
5145 writeFile = mTracing.disable();
5146 }
5147
5148 if (writeFile) {
5149 reply->writeInt32(mTracing.writeToFile());
5150 } else {
5151 reply->writeInt32(NO_ERROR);
5152 }
Adrian Roos1e1a1282017-11-01 19:05:31 +01005153 }
5154 return NO_ERROR;
5155 }
Vishnu Nair87704c92018-01-08 15:32:57 -08005156 case 1026: { // Get layer tracing status
5157 reply->writeBool(mTracing.isEnabled());
5158 return NO_ERROR;
5159 }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005160 // Is a DisplayColorSetting supported?
5161 case 1027: {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005162 const auto display = getDefaultDisplayDevice();
5163 if (!display) {
Chia-I Wu0d711262018-05-21 15:19:35 -07005164 return NAME_NOT_FOUND;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005165 }
Chia-I Wu0d711262018-05-21 15:19:35 -07005166
5167 DisplayColorSetting setting = static_cast<DisplayColorSetting>(data.readInt32());
5168 switch (setting) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -08005169 case DisplayColorSetting::kManaged:
Peiyong Lin13effd12018-07-24 17:01:47 -07005170 reply->writeBool(useColorManagement);
Chia-I Wu0d711262018-05-21 15:19:35 -07005171 break;
Lloyd Pique6a3b4462019-03-07 20:58:12 -08005172 case DisplayColorSetting::kUnmanaged:
Chia-I Wu0d711262018-05-21 15:19:35 -07005173 reply->writeBool(true);
5174 break;
Lloyd Pique6a3b4462019-03-07 20:58:12 -08005175 case DisplayColorSetting::kEnhanced:
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005176 reply->writeBool(display->hasRenderIntent(RenderIntent::ENHANCE));
Chia-I Wu0d711262018-05-21 15:19:35 -07005177 break;
5178 default: // vendor display color setting
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005179 reply->writeBool(
5180 display->hasRenderIntent(static_cast<RenderIntent>(setting)));
Chia-I Wu0d711262018-05-21 15:19:35 -07005181 break;
5182 }
5183 return NO_ERROR;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005184 }
Steven Thomas97f1f4c2018-06-01 12:04:16 -07005185 // Is VrFlinger active?
5186 case 1028: {
5187 Mutex::Autolock _l(mStateLock);
Lloyd Pique441d5042018-10-18 16:49:51 -07005188 reply->writeBool(getHwComposer().isUsingVrComposer());
Steven Thomas97f1f4c2018-06-01 12:04:16 -07005189 return NO_ERROR;
5190 }
Nataniel Borges2b796da2019-02-15 13:32:18 -08005191 // Set buffer size for SF tracing (value in KB)
5192 case 1029: {
5193 n = data.readInt32();
5194 if (n <= 0 || n > MAX_TRACING_MEMORY) {
5195 ALOGW("Invalid buffer size: %d KB", n);
5196 reply->writeInt32(BAD_VALUE);
5197 return BAD_VALUE;
5198 }
5199
5200 ALOGD("Updating trace buffer to %d KB", n);
5201 mTracing.setBufferSize(n * 1024);
5202 reply->writeInt32(NO_ERROR);
5203 return NO_ERROR;
5204 }
Peiyong Lin13effd12018-07-24 17:01:47 -07005205 // Is device color managed?
5206 case 1030: {
5207 reply->writeBool(useColorManagement);
5208 return NO_ERROR;
5209 }
Peiyong Lin9d846a52018-11-05 13:18:20 -08005210 // Override default composition data space
5211 // adb shell service call SurfaceFlinger 1031 i32 1 DATASPACE_NUMBER DATASPACE_NUMBER \
5212 // && adb shell stop zygote && adb shell start zygote
5213 // to restore: adb shell service call SurfaceFlinger 1031 i32 0 && \
5214 // adb shell stop zygote && adb shell start zygote
5215 case 1031: {
5216 Mutex::Autolock _l(mStateLock);
5217 n = data.readInt32();
5218 if (n) {
5219 n = data.readInt32();
5220 if (n) {
5221 Dataspace dataspace = static_cast<Dataspace>(n);
5222 if (!validateCompositionDataspace(dataspace)) {
5223 return BAD_VALUE;
5224 }
5225 mDefaultCompositionDataspace = dataspace;
5226 }
5227 n = data.readInt32();
5228 if (n) {
5229 Dataspace dataspace = static_cast<Dataspace>(n);
5230 if (!validateCompositionDataspace(dataspace)) {
5231 return BAD_VALUE;
5232 }
5233 mWideColorGamutCompositionDataspace = dataspace;
5234 }
5235 } else {
5236 // restore composition data space.
5237 mDefaultCompositionDataspace = defaultCompositionDataspace;
5238 mWideColorGamutCompositionDataspace = wideColorGamutCompositionDataspace;
5239 }
5240 return NO_ERROR;
5241 }
Vishnu Nair9245d3b2019-03-22 13:38:56 -07005242 // Set trace flags
5243 case 1033: {
5244 n = data.readUint32();
5245 ALOGD("Updating trace flags to 0x%x", n);
5246 mTracing.setTraceFlags(n);
5247 reply->writeInt32(NO_ERROR);
5248 return NO_ERROR;
5249 }
Ady Abraham03b02dd2019-03-21 15:40:11 -07005250 case 1034: {
Ady Abraham03b02dd2019-03-21 15:40:11 -07005251 n = data.readInt32();
Ady Abraham2cb8b622019-12-02 18:55:33 -08005252 if (n == 1 && !mRefreshRateOverlay) {
Ady Abraham03b02dd2019-03-21 15:40:11 -07005253 mRefreshRateOverlay = std::make_unique<RefreshRateOverlay>(*this);
Ady Abraham2e1dd892020-03-05 13:48:36 -08005254 auto& current = mRefreshRateConfigs->getCurrentRefreshRate();
Ady Abraham2139f732019-11-13 18:56:40 -08005255 mRefreshRateOverlay->changeRefreshRate(current);
Ady Abraham2cb8b622019-12-02 18:55:33 -08005256 } else if (n == 0) {
Ady Abraham03b02dd2019-03-21 15:40:11 -07005257 mRefreshRateOverlay.reset();
Ady Abraham2cb8b622019-12-02 18:55:33 -08005258 } else {
5259 reply->writeBool(mRefreshRateOverlay != nullptr);
Ady Abraham03b02dd2019-03-21 15:40:11 -07005260 }
5261 return NO_ERROR;
5262 }
Ady Abraham34392f72019-04-10 11:29:27 -07005263 case 1035: {
5264 n = data.readInt32();
5265 mDebugDisplayConfigSetByBackdoor = false;
5266 if (n >= 0) {
5267 const auto displayToken = getInternalDisplayToken();
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005268 status_t result = setActiveConfig(displayToken, n);
Ady Abraham34392f72019-04-10 11:29:27 -07005269 if (result != NO_ERROR) {
5270 return result;
5271 }
5272 mDebugDisplayConfigSetByBackdoor = true;
5273 }
5274 return NO_ERROR;
5275 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08005276 }
5277 }
5278 return err;
5279}
5280
Steven Thomas6d8110b2017-08-31 18:24:21 -07005281void SurfaceFlinger::repaintEverything() {
Lloyd Piquef1c675b2018-09-12 20:45:39 -07005282 mRepaintEverything = true;
Dan Stozac7a25ad2018-04-12 11:45:09 -07005283 signalTransaction();
Steven Thomas6d8110b2017-08-31 18:24:21 -07005284}
5285
Ana Krulec7d1d6832018-12-27 11:10:09 -08005286void SurfaceFlinger::repaintEverythingForHWC() {
5287 mRepaintEverything = true;
Dan Stoza030fbc12020-02-19 15:32:01 -08005288 mPowerAdvisor.notifyDisplayUpdateImminent();
Ady Abraham8532d012019-05-08 14:50:56 -07005289 mEventQueue->invalidate();
Ana Krulec7d1d6832018-12-27 11:10:09 -08005290}
5291
Ady Abrahama09852a2020-02-20 14:23:42 -08005292void SurfaceFlinger::kernelTimerChanged(bool expired) {
5293 static bool updateOverlay =
5294 property_get_bool("debug.sf.kernel_idle_timer_update_overlay", true);
5295 if (!updateOverlay || !mRefreshRateOverlay) return;
5296
5297 // Update the overlay on the main thread to avoid race conditions with
5298 // mRefreshRateConfigs->getCurrentRefreshRate()
5299 postMessageAsync(new LambdaMessage([this, expired]() NO_THREAD_SAFETY_ANALYSIS {
5300 if (mRefreshRateOverlay) {
5301 const auto kernelTimerEnabled = property_get_bool(KERNEL_IDLE_TIMER_PROP, false);
5302 const bool timerExpired = kernelTimerEnabled && expired;
Ady Abraham2e1dd892020-03-05 13:48:36 -08005303 const auto& current = [this]() -> const RefreshRate& {
Ady Abrahama09852a2020-02-20 14:23:42 -08005304 std::lock_guard<std::mutex> lock(mActiveConfigLock);
5305 if (mDesiredActiveConfigChanged) {
5306 return mRefreshRateConfigs->getRefreshRateFromConfigId(
5307 mDesiredActiveConfig.configId);
5308 }
5309
5310 return mRefreshRateConfigs->getCurrentRefreshRate();
5311 }();
5312 const auto& min = mRefreshRateConfigs->getMinRefreshRate();
5313
5314 if (current != min) {
5315 mRefreshRateOverlay->changeRefreshRate(timerExpired ? min : current);
5316 mEventQueue->invalidate();
5317 }
5318 }
5319 }));
5320}
5321
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005322// A simple RAII class to disconnect from an ANativeWindow* when it goes out of scope
5323class WindowDisconnector {
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005324public:
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005325 WindowDisconnector(ANativeWindow* window, int api) : mWindow(window), mApi(api) {}
5326 ~WindowDisconnector() {
5327 native_window_api_disconnect(mWindow, mApi);
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005328 }
5329
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005330private:
5331 ANativeWindow* mWindow;
5332 const int mApi;
Mathias Agopian2ed0fe52013-07-08 17:09:41 -07005333};
5334
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005335status_t SurfaceFlinger::captureScreen(const sp<IBinder>& displayToken,
Robert Carr108b2c72019-04-02 16:32:58 -07005336 sp<GraphicBuffer>* outBuffer, bool& outCapturedSecureLayers,
Dominik Laskowski718f9602019-11-09 20:01:35 -08005337 Dataspace reqDataspace, ui::PixelFormat reqPixelFormat,
5338 const Rect& sourceCrop, uint32_t reqWidth,
5339 uint32_t reqHeight, bool useIdentityTransform,
5340 ui::Rotation rotation, bool captureSecureLayers) {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005341 ATRACE_CALL();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005342
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005343 if (!displayToken) return BAD_VALUE;
chaviwa76b2712017-09-20 12:02:26 -07005344
Dominik Laskowski718f9602019-11-09 20:01:35 -08005345 auto renderAreaRotation = ui::Transform::toRotationFlags(rotation);
5346 if (renderAreaRotation == ui::Transform::ROT_INVALID) {
5347 ALOGE("%s: Invalid rotation: %s", __FUNCTION__, toCString(rotation));
5348 renderAreaRotation = ui::Transform::ROT_0;
5349 }
Chia-I Wuc80dcbb2018-08-24 15:34:02 -07005350
Chia-I Wu20261cb2018-08-23 12:55:44 -07005351 sp<DisplayDevice> display;
5352 {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005353 Mutex::Autolock lock(mStateLock);
Garfield Tan3b1b8af2018-03-16 17:37:33 -07005354
Chia-I Wu20261cb2018-08-23 12:55:44 -07005355 display = getDisplayDeviceLocked(displayToken);
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005356 if (!display) return NAME_NOT_FOUND;
Chia-I Wu20261cb2018-08-23 12:55:44 -07005357
Chia-I Wucb023152018-08-28 12:57:23 -07005358 // set the requested width/height to the logical display viewport size
5359 // by default
5360 if (reqWidth == 0 || reqHeight == 0) {
5361 reqWidth = uint32_t(display->getViewport().width());
5362 reqHeight = uint32_t(display->getViewport().height());
Chia-I Wu20261cb2018-08-23 12:55:44 -07005363 }
Yiwei Zhang06a58e22018-08-20 16:42:23 -07005364 }
5365
Peiyong Lin0e003c92018-09-17 11:09:51 -07005366 DisplayRenderArea renderArea(display, sourceCrop, reqWidth, reqHeight, reqDataspace,
Robert Carrfa8855f2019-02-19 10:05:00 -08005367 renderAreaRotation, captureSecureLayers);
Dominik Laskowskiccf37d72019-02-01 16:47:58 -08005368 auto traverseLayers = std::bind(&SurfaceFlinger::traverseLayersInDisplay, this, display,
5369 std::placeholders::_1);
Peiyong Lin0e003c92018-09-17 11:09:51 -07005370 return captureScreenCommon(renderArea, traverseLayers, outBuffer, reqPixelFormat,
Robert Carr108b2c72019-04-02 16:32:58 -07005371 useIdentityTransform, outCapturedSecureLayers);
chaviwa76b2712017-09-20 12:02:26 -07005372}
5373
chaviw93df2ea2019-04-30 16:45:12 -07005374static Dataspace pickDataspaceFromColorMode(const ColorMode colorMode) {
5375 switch (colorMode) {
5376 case ColorMode::DISPLAY_P3:
5377 case ColorMode::BT2100_PQ:
5378 case ColorMode::BT2100_HLG:
5379 case ColorMode::DISPLAY_BT2020:
5380 return Dataspace::DISPLAY_P3;
5381 default:
5382 return Dataspace::V0_SRGB;
5383 }
5384}
5385
Martin Liu4a322352020-03-24 21:30:38 +08005386status_t SurfaceFlinger::setSchedFifo(bool enabled) {
5387 static constexpr int kFifoPriority = 2;
5388 static constexpr int kOtherPriority = 0;
5389
5390 struct sched_param param = {0};
5391 int sched_policy;
5392 if (enabled) {
5393 sched_policy = SCHED_FIFO;
5394 param.sched_priority = kFifoPriority;
5395 } else {
5396 sched_policy = SCHED_OTHER;
5397 param.sched_priority = kOtherPriority;
5398 }
5399
5400 if (sched_setscheduler(0, sched_policy, &param) != 0) {
5401 return -errno;
5402 }
5403 return NO_ERROR;
5404}
5405
chaviw93df2ea2019-04-30 16:45:12 -07005406const sp<DisplayDevice> SurfaceFlinger::getDisplayByIdOrLayerStack(uint64_t displayOrLayerStack) {
5407 const sp<IBinder> displayToken = getPhysicalDisplayTokenLocked(DisplayId{displayOrLayerStack});
5408 if (displayToken) {
5409 return getDisplayDeviceLocked(displayToken);
5410 }
5411 // Couldn't find display by displayId. Try to get display by layerStack since virtual displays
5412 // may not have a displayId.
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005413 return getDisplayByLayerStack(displayOrLayerStack);
5414}
5415
5416const sp<DisplayDevice> SurfaceFlinger::getDisplayByLayerStack(uint64_t layerStack) {
chaviw93df2ea2019-04-30 16:45:12 -07005417 for (const auto& [token, display] : mDisplays) {
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005418 if (display->getLayerStack() == layerStack) {
chaviw93df2ea2019-04-30 16:45:12 -07005419 return display;
5420 }
5421 }
5422 return nullptr;
5423}
5424
5425status_t SurfaceFlinger::captureScreen(uint64_t displayOrLayerStack, Dataspace* outDataspace,
5426 sp<GraphicBuffer>* outBuffer) {
5427 sp<DisplayDevice> display;
5428 uint32_t width;
5429 uint32_t height;
Dominik Laskowski718f9602019-11-09 20:01:35 -08005430 ui::Transform::RotationFlags captureOrientation;
chaviw93df2ea2019-04-30 16:45:12 -07005431 {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005432 Mutex::Autolock lock(mStateLock);
chaviw93df2ea2019-04-30 16:45:12 -07005433 display = getDisplayByIdOrLayerStack(displayOrLayerStack);
5434 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005435 return NAME_NOT_FOUND;
chaviw93df2ea2019-04-30 16:45:12 -07005436 }
5437
5438 width = uint32_t(display->getViewport().width());
5439 height = uint32_t(display->getViewport().height());
5440
Dominik Laskowski718f9602019-11-09 20:01:35 -08005441 const auto orientation = display->getOrientation();
5442 captureOrientation = ui::Transform::toRotationFlags(orientation);
5443
5444 switch (captureOrientation) {
5445 case ui::Transform::ROT_90:
5446 captureOrientation = ui::Transform::ROT_270;
5447 break;
5448
5449 case ui::Transform::ROT_270:
5450 captureOrientation = ui::Transform::ROT_90;
5451 break;
5452
5453 case ui::Transform::ROT_INVALID:
5454 ALOGE("%s: Invalid orientation: %s", __FUNCTION__, toCString(orientation));
5455 captureOrientation = ui::Transform::ROT_0;
5456 break;
5457
5458 default:
5459 break;
Alec Mouri21fab752019-06-20 14:12:17 -07005460 }
chaviw93df2ea2019-04-30 16:45:12 -07005461 *outDataspace =
5462 pickDataspaceFromColorMode(display->getCompositionDisplay()->getState().colorMode);
5463 }
5464
5465 DisplayRenderArea renderArea(display, Rect(), width, height, *outDataspace, captureOrientation,
5466 false /* captureSecureLayers */);
5467
5468 auto traverseLayers = std::bind(&SurfaceFlinger::traverseLayersInDisplay, this, display,
5469 std::placeholders::_1);
5470 bool ignored = false;
5471 return captureScreenCommon(renderArea, traverseLayers, outBuffer, ui::PixelFormat::RGBA_8888,
5472 false /* useIdentityTransform */,
5473 ignored /* outCapturedSecureLayers */);
5474}
5475
Robert Carr866455f2019-04-02 16:28:26 -07005476status_t SurfaceFlinger::captureLayers(
5477 const sp<IBinder>& layerHandleBinder, sp<GraphicBuffer>* outBuffer,
5478 const Dataspace reqDataspace, const ui::PixelFormat reqPixelFormat, const Rect& sourceCrop,
5479 const std::unordered_set<sp<IBinder>, ISurfaceComposer::SpHash<IBinder>>& excludeHandles,
5480 float frameScale, bool childrenOnly) {
chaviwa76b2712017-09-20 12:02:26 -07005481 ATRACE_CALL();
5482
5483 class LayerRenderArea : public RenderArea {
5484 public:
Robert Carr578038f2018-03-09 12:25:24 -08005485 LayerRenderArea(SurfaceFlinger* flinger, const sp<Layer>& layer, const Rect crop,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005486 int32_t reqWidth, int32_t reqHeight, Dataspace reqDataSpace,
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005487 bool childrenOnly, const Rect& displayViewport)
5488 : RenderArea(reqWidth, reqHeight, CaptureFill::CLEAR, reqDataSpace, displayViewport),
Robert Carr578038f2018-03-09 12:25:24 -08005489 mLayer(layer),
5490 mCrop(crop),
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005491 mNeedsFiltering(false),
Robert Carr578038f2018-03-09 12:25:24 -08005492 mFlinger(flinger),
5493 mChildrenOnly(childrenOnly) {}
Peiyong Linefefaac2018-08-17 12:27:51 -07005494 const ui::Transform& getTransform() const override { return mTransform; }
Alec Mouri5a6d8572020-03-23 23:56:15 -07005495 Rect getBounds() const override { return mLayer->getBufferSize(mLayer->getDrawingState()); }
Marissa Wall61c58622018-07-18 10:12:20 -07005496 int getHeight() const override {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08005497 return mLayer->getBufferSize(mLayer->getDrawingState()).getHeight();
Marissa Wall61c58622018-07-18 10:12:20 -07005498 }
Vishnu Nair88a11f22018-11-28 18:30:57 -08005499 int getWidth() const override {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08005500 return mLayer->getBufferSize(mLayer->getDrawingState()).getWidth();
Vishnu Nair88a11f22018-11-28 18:30:57 -08005501 }
chaviwa76b2712017-09-20 12:02:26 -07005502 bool isSecure() const override { return false; }
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005503 bool needsFiltering() const override { return mNeedsFiltering; }
Dominik Laskowski718f9602019-11-09 20:01:35 -08005504 sp<const DisplayDevice> getDisplayDevice() const override { return nullptr; }
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08005505 Rect getSourceCrop() const override {
5506 if (mCrop.isEmpty()) {
5507 return getBounds();
5508 } else {
5509 return mCrop;
5510 }
5511 }
Robert Carr578038f2018-03-09 12:25:24 -08005512 class ReparentForDrawing {
5513 public:
5514 const sp<Layer>& oldParent;
5515 const sp<Layer>& newParent;
5516
Vishnu Nair4351ad52019-02-11 14:13:02 -08005517 ReparentForDrawing(const sp<Layer>& oldParent, const sp<Layer>& newParent,
5518 const Rect& drawingBounds)
Robert Carr578038f2018-03-09 12:25:24 -08005519 : oldParent(oldParent), newParent(newParent) {
Vishnu Nair4351ad52019-02-11 14:13:02 -08005520 // Compute and cache the bounds for the new parent layer.
Vishnu Nairc97b8db2019-10-29 18:19:35 -07005521 newParent->computeBounds(drawingBounds.toFloatRect(), ui::Transform(),
5522 0.f /* shadowRadius */);
Robert Carr15eae092018-03-23 13:43:53 -07005523 oldParent->setChildrenDrawingParent(newParent);
Robert Carr578038f2018-03-09 12:25:24 -08005524 }
Vishnu Nairbce6ffd2019-02-14 10:58:59 -08005525 ~ReparentForDrawing() { oldParent->setChildrenDrawingParent(oldParent); }
Robert Carr578038f2018-03-09 12:25:24 -08005526 };
5527
5528 void render(std::function<void()> drawLayers) override {
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005529 const Rect sourceCrop = getSourceCrop();
5530 // no need to check rotation because there is none
5531 mNeedsFiltering = sourceCrop.width() != getReqWidth() ||
5532 sourceCrop.height() != getReqHeight();
5533
Robert Carr578038f2018-03-09 12:25:24 -08005534 if (!mChildrenOnly) {
5535 mTransform = mLayer->getTransform().inverse();
5536 drawLayers();
5537 } else {
Alec Mouri5a6d8572020-03-23 23:56:15 -07005538 uint32_t w = static_cast<uint32_t>(getWidth());
5539 uint32_t h = static_cast<uint32_t>(getHeight());
chaviw32811fd2019-08-12 13:16:09 -07005540 // In the "childrenOnly" case we reparent the children to a screenshot
5541 // layer which has no properties set and which does not draw.
5542 sp<ContainerLayer> screenshotParentLayer =
Dominik Laskowski87a07e42019-10-10 20:38:02 -07005543 mFlinger->getFactory().createContainerLayer({mFlinger, nullptr,
5544 "Screenshot Parent"s, w, h, 0,
5545 LayerMetadata()});
Robert Carr578038f2018-03-09 12:25:24 -08005546
Vishnu Nair4351ad52019-02-11 14:13:02 -08005547 ReparentForDrawing reparent(mLayer, screenshotParentLayer, sourceCrop);
Robert Carr578038f2018-03-09 12:25:24 -08005548 drawLayers();
5549 }
5550 }
chaviwa76b2712017-09-20 12:02:26 -07005551
chaviwa76b2712017-09-20 12:02:26 -07005552 private:
chaviw7206d492017-11-10 16:16:12 -08005553 const sp<Layer> mLayer;
5554 const Rect mCrop;
Robert Carr578038f2018-03-09 12:25:24 -08005555
Peiyong Linefefaac2018-08-17 12:27:51 -07005556 ui::Transform mTransform;
Chia-I Wu5f6664c2018-08-28 11:01:44 -07005557 bool mNeedsFiltering;
Robert Carr578038f2018-03-09 12:25:24 -08005558
5559 SurfaceFlinger* mFlinger;
5560 const bool mChildrenOnly;
chaviwa76b2712017-09-20 12:02:26 -07005561 };
5562
Robert Carrc0df3122019-04-11 13:18:21 -07005563 int reqWidth = 0;
5564 int reqHeight = 0;
5565 sp<Layer> parent;
chaviw7206d492017-11-10 16:16:12 -08005566 Rect crop(sourceCrop);
Robert Carrc0df3122019-04-11 13:18:21 -07005567 std::unordered_set<sp<Layer>, ISurfaceComposer::SpHash<Layer>> excludeLayers;
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005568 Rect displayViewport;
Robert Carrc0df3122019-04-11 13:18:21 -07005569 {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005570 Mutex::Autolock lock(mStateLock);
chaviw7206d492017-11-10 16:16:12 -08005571
Robert Carrc0df3122019-04-11 13:18:21 -07005572 parent = fromHandle(layerHandleBinder);
5573 if (parent == nullptr || parent->isRemovedFromCurrentState()) {
5574 ALOGE("captureLayers called with an invalid or removed parent");
5575 return NAME_NOT_FOUND;
5576 }
5577
5578 const int uid = IPCThreadState::self()->getCallingUid();
5579 const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
5580 if (!forSystem && parent->getCurrentState().flags & layer_state_t::eLayerSecure) {
5581 ALOGW("Attempting to capture secure layer: PERMISSION_DENIED");
5582 return PERMISSION_DENIED;
5583 }
5584
Vishnu Nairefc42e22019-12-03 17:36:12 -08005585 Rect parentSourceBounds = parent->getCroppedBufferSize(parent->getCurrentState());
Robert Carrc0df3122019-04-11 13:18:21 -07005586 if (sourceCrop.width() <= 0) {
5587 crop.left = 0;
Vishnu Nairefc42e22019-12-03 17:36:12 -08005588 crop.right = parentSourceBounds.getWidth();
Robert Carrc0df3122019-04-11 13:18:21 -07005589 }
5590
5591 if (sourceCrop.height() <= 0) {
5592 crop.top = 0;
Vishnu Nairefc42e22019-12-03 17:36:12 -08005593 crop.bottom = parentSourceBounds.getHeight();
5594 }
5595
5596 if (crop.isEmpty() || frameScale <= 0.0f) {
5597 // Error out if the layer has no source bounds (i.e. they are boundless) and a source
5598 // crop was not specified, or an invalid frame scale was provided.
5599 return BAD_VALUE;
Robert Carrc0df3122019-04-11 13:18:21 -07005600 }
5601 reqWidth = crop.width() * frameScale;
5602 reqHeight = crop.height() * frameScale;
5603
5604 for (const auto& handle : excludeHandles) {
5605 sp<Layer> excludeLayer = fromHandle(handle);
5606 if (excludeLayer != nullptr) {
5607 excludeLayers.emplace(excludeLayer);
5608 } else {
5609 ALOGW("Invalid layer handle passed as excludeLayer to captureLayers");
5610 return NAME_NOT_FOUND;
5611 }
5612 }
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005613
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005614 const auto display = getDisplayByLayerStack(parent->getLayerStack());
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005615 if (!display) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07005616 return NAME_NOT_FOUND;
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005617 }
5618
5619 displayViewport = display->getViewport();
Robert Carrc0df3122019-04-11 13:18:21 -07005620 } // mStateLock
chaviw7206d492017-11-10 16:16:12 -08005621
Chia-I Wu20261cb2018-08-23 12:55:44 -07005622 // really small crop or frameScale
5623 if (reqWidth <= 0) {
5624 reqWidth = 1;
5625 }
5626 if (reqHeight <= 0) {
5627 reqHeight = 1;
5628 }
5629
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005630 LayerRenderArea renderArea(this, parent, crop, reqWidth, reqHeight, reqDataspace, childrenOnly,
5631 displayViewport);
Robert Carr866455f2019-04-02 16:28:26 -07005632 auto traverseLayers = [parent, childrenOnly,
5633 &excludeLayers](const LayerVector::Visitor& visitor) {
chaviwa76b2712017-09-20 12:02:26 -07005634 parent->traverseChildrenInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
5635 if (!layer->isVisible()) {
5636 return;
Robert Carr578038f2018-03-09 12:25:24 -08005637 } else if (childrenOnly && layer == parent.get()) {
5638 return;
chaviwa76b2712017-09-20 12:02:26 -07005639 }
Robert Carr866455f2019-04-02 16:28:26 -07005640
5641 sp<Layer> p = layer;
5642 while (p != nullptr) {
5643 if (excludeLayers.count(p) != 0) {
5644 return;
5645 }
5646 p = p->getParent();
5647 }
5648
chaviwa76b2712017-09-20 12:02:26 -07005649 visitor(layer);
5650 });
5651 };
Robert Carr108b2c72019-04-02 16:32:58 -07005652
5653 bool outCapturedSecureLayers = false;
5654 return captureScreenCommon(renderArea, traverseLayers, outBuffer, reqPixelFormat, false,
5655 outCapturedSecureLayers);
chaviwa76b2712017-09-20 12:02:26 -07005656}
5657
5658status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea,
5659 TraverseLayersFunction traverseLayers,
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005660 sp<GraphicBuffer>* outBuffer,
Peiyong Lin0e003c92018-09-17 11:09:51 -07005661 const ui::PixelFormat reqPixelFormat,
Robert Carr108b2c72019-04-02 16:32:58 -07005662 bool useIdentityTransform,
5663 bool& outCapturedSecureLayers) {
chaviwa76b2712017-09-20 12:02:26 -07005664 ATRACE_CALL();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005665
Peiyong Lin0e003c92018-09-17 11:09:51 -07005666 // TODO(b/116112787) Make buffer usage a parameter.
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005667 const uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
5668 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
Lloyd Pique90c115d2018-09-18 21:39:42 -07005669 *outBuffer =
5670 getFactory().createGraphicBuffer(renderArea.getReqWidth(), renderArea.getReqHeight(),
5671 static_cast<android_pixel_format>(reqPixelFormat), 1,
5672 usage, "screenshot");
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005673
Robert Carr108b2c72019-04-02 16:32:58 -07005674 return captureScreenCommon(renderArea, traverseLayers, *outBuffer, useIdentityTransform,
5675 outCapturedSecureLayers);
Dan Stozaec460082018-12-17 15:35:09 -08005676}
5677
Kevin DuBois7cbcc372019-02-25 14:53:28 -08005678status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea,
5679 TraverseLayersFunction traverseLayers,
5680 const sp<GraphicBuffer>& buffer,
Robert Carr108b2c72019-04-02 16:32:58 -07005681 bool useIdentityTransform,
5682 bool& outCapturedSecureLayers) {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005683 // This mutex protects syncFd and captureResult for communication of the return values from the
5684 // main thread back to this Binder thread
5685 std::mutex captureMutex;
5686 std::condition_variable captureCondition;
5687 std::unique_lock<std::mutex> captureLock(captureMutex);
5688 int syncFd = -1;
5689 std::optional<status_t> captureResult;
5690
Robert Carr03480e22018-01-04 16:02:06 -08005691 const int uid = IPCThreadState::self()->getCallingUid();
5692 const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
5693
Dominik Laskowski8c001672018-05-30 16:52:06 -07005694 sp<LambdaMessage> message = new LambdaMessage([&] {
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005695 // If there is a refresh pending, bug out early and tell the binder thread to try again
5696 // after the refresh.
5697 if (mRefreshPending) {
5698 ATRACE_NAME("Skipping screenshot for now");
5699 std::unique_lock<std::mutex> captureLock(captureMutex);
5700 captureResult = std::make_optional<status_t>(EAGAIN);
5701 captureCondition.notify_one();
5702 return;
5703 }
5704
5705 status_t result = NO_ERROR;
5706 int fd = -1;
5707 {
5708 Mutex::Autolock _l(mStateLock);
Dominik Laskowski8c001672018-05-30 16:52:06 -07005709 renderArea.render([&] {
Dan Stozaec460082018-12-17 15:35:09 -08005710 result = captureScreenImplLocked(renderArea, traverseLayers, buffer.get(),
Robert Carr108b2c72019-04-02 16:32:58 -07005711 useIdentityTransform, forSystem, &fd,
5712 outCapturedSecureLayers);
Robert Carr578038f2018-03-09 12:25:24 -08005713 });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005714 }
5715
5716 {
5717 std::unique_lock<std::mutex> captureLock(captureMutex);
5718 syncFd = fd;
5719 captureResult = std::make_optional<status_t>(result);
5720 captureCondition.notify_one();
5721 }
5722 });
5723
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005724 status_t result = postMessageAsync(message);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005725 if (result == NO_ERROR) {
Dominik Laskowski8c001672018-05-30 16:52:06 -07005726 captureCondition.wait(captureLock, [&] { return captureResult; });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005727 while (*captureResult == EAGAIN) {
5728 captureResult.reset();
5729 result = postMessageAsync(message);
5730 if (result != NO_ERROR) {
5731 return result;
5732 }
Dominik Laskowski8c001672018-05-30 16:52:06 -07005733 captureCondition.wait(captureLock, [&] { return captureResult; });
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005734 }
5735 result = *captureResult;
5736 }
5737
5738 if (result == NO_ERROR) {
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005739 sync_wait(syncFd, -1);
5740 close(syncFd);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005741 }
Chavi Weingarten40482ff2017-11-30 01:51:40 +00005742
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005743 return result;
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005744}
5745
chaviwa76b2712017-09-20 12:02:26 -07005746void SurfaceFlinger::renderScreenImplLocked(const RenderArea& renderArea,
Chia-I Wu1be50b52018-08-29 10:44:48 -07005747 TraverseLayersFunction traverseLayers,
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005748 ANativeWindowBuffer* buffer, bool useIdentityTransform,
5749 int* outSyncFd) {
Mathias Agopian180f10d2013-04-10 22:55:41 -07005750 ATRACE_CALL();
chaviwa76b2712017-09-20 12:02:26 -07005751
chaviwa76b2712017-09-20 12:02:26 -07005752 const auto reqWidth = renderArea.getReqWidth();
5753 const auto reqHeight = renderArea.getReqHeight();
Alec Mouriadb75f42019-03-28 21:42:24 -07005754 const auto sourceCrop = renderArea.getSourceCrop();
Alec Mouri5a6d8572020-03-23 23:56:15 -07005755 const auto transform = renderArea.getTransform();
5756 const auto rotation = renderArea.getRotationFlags();
Vishnu Nair3a7346c2019-12-04 08:09:09 -08005757 const auto& displayViewport = renderArea.getDisplayViewport();
Dan Stozac1879002014-05-22 15:59:05 -07005758
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005759 renderengine::DisplaySettings clientCompositionDisplay;
Vishnu Nair9b079a22020-01-21 14:36:08 -08005760 std::vector<compositionengine::LayerFE::LayerSettings> clientCompositionLayers;
Romain Guy88d37dd2017-05-26 17:57:05 -07005761
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005762 // assume that bounds are never offset, and that they are the same as the
5763 // buffer bounds.
5764 clientCompositionDisplay.physicalDisplay = Rect(reqWidth, reqHeight);
Alec Mouriadb75f42019-03-28 21:42:24 -07005765 clientCompositionDisplay.clip = sourceCrop;
Alec Mouri5a6d8572020-03-23 23:56:15 -07005766 clientCompositionDisplay.orientation = rotation;
Alec Mouriadb75f42019-03-28 21:42:24 -07005767
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005768 clientCompositionDisplay.outputDataspace = renderArea.getReqDataSpace();
5769 clientCompositionDisplay.maxLuminance = DisplayDevice::sDefaultMaxLumiance;
Mathias Agopian180f10d2013-04-10 22:55:41 -07005770
chaviw50da5042018-04-09 13:49:37 -07005771 const float alpha = RenderArea::getCaptureFillValue(renderArea.getCaptureFill());
Mathias Agopian180f10d2013-04-10 22:55:41 -07005772
Vishnu Nair9b079a22020-01-21 14:36:08 -08005773 compositionengine::LayerFE::LayerSettings fillLayer;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005774 fillLayer.source.buffer.buffer = nullptr;
5775 fillLayer.source.solidColor = half3(0.0, 0.0, 0.0);
Alec Mouri5a6d8572020-03-23 23:56:15 -07005776 fillLayer.geometry.boundaries =
5777 FloatRect(sourceCrop.left, sourceCrop.top, sourceCrop.right, sourceCrop.bottom);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005778 fillLayer.alpha = half(alpha);
5779 clientCompositionLayers.push_back(fillLayer);
5780
Yichi Chen40773d92020-04-01 10:10:18 +08005781 std::vector<Layer*> renderedLayers;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005782 Region clearRegion = Region::INVALID_REGION;
chaviwa76b2712017-09-20 12:02:26 -07005783 traverseLayers([&](Layer* layer) {
Lloyd Piquef16688f2019-02-19 17:47:57 -08005784 const bool supportProtectedContent = false;
5785 Region clip(renderArea.getBounds());
5786 compositionengine::LayerFE::ClientCompositionTargetSettings targetSettings{
5787 clip,
5788 useIdentityTransform,
Alec Mouri5a6d8572020-03-23 23:56:15 -07005789 layer->needsFilteringForScreenshots(renderArea.getDisplayDevice(), transform) ||
5790 renderArea.needsFiltering(),
Lloyd Piquef16688f2019-02-19 17:47:57 -08005791 renderArea.isSecure(),
5792 supportProtectedContent,
5793 clearRegion,
Vishnu Nairb87d94f2020-02-13 09:17:36 -08005794 displayViewport,
5795 clientCompositionDisplay.outputDataspace,
5796 true, /* realContentIsVisible */
5797 false, /* clearContent */
Lloyd Piquef16688f2019-02-19 17:47:57 -08005798 };
Vishnu Nairb87d94f2020-02-13 09:17:36 -08005799 std::vector<compositionengine::LayerFE::LayerSettings> results =
5800 layer->prepareClientCompositionList(targetSettings);
Yichi Chen40773d92020-04-01 10:10:18 +08005801 if (results.size() > 0) {
Alec Mouri5a6d8572020-03-23 23:56:15 -07005802 for (auto& settings : results) {
5803 settings.geometry.positionTransform =
5804 transform.asMatrix4() * settings.geometry.positionTransform;
5805 }
Yichi Chen40773d92020-04-01 10:10:18 +08005806 clientCompositionLayers.insert(clientCompositionLayers.end(),
5807 std::make_move_iterator(results.begin()),
5808 std::make_move_iterator(results.end()));
5809 renderedLayers.push_back(layer);
5810 }
chaviwa76b2712017-09-20 12:02:26 -07005811 });
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005812
Yichi Chen40773d92020-04-01 10:10:18 +08005813 std::vector<const renderengine::LayerSettings*> clientCompositionLayerPointers(
5814 clientCompositionLayers.size());
Vishnu Nair9b079a22020-01-21 14:36:08 -08005815 std::transform(clientCompositionLayers.begin(), clientCompositionLayers.end(),
Yichi Chen40773d92020-04-01 10:10:18 +08005816 clientCompositionLayerPointers.begin(),
5817 std::pointer_traits<renderengine::LayerSettings*>::pointer_to);
Vishnu Nair9b079a22020-01-21 14:36:08 -08005818
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005819 clientCompositionDisplay.clearRegion = clearRegion;
Alec Mouri6338c9d2019-02-07 16:57:51 -08005820 // Use an empty fence for the buffer fence, since we just created the buffer so
5821 // there is no need for synchronization with the GPU.
5822 base::unique_fd bufferFence;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005823 base::unique_fd drawFence;
Peiyong Lin8f28a1d2019-02-07 17:25:12 -08005824 getRenderEngine().useProtectedContext(false);
Vishnu Nair9b079a22020-01-21 14:36:08 -08005825 getRenderEngine().drawLayers(clientCompositionDisplay, clientCompositionLayerPointers, buffer,
Alec Mourife0d72b2019-03-21 14:05:56 -07005826 /*useFramebufferCache=*/false, std::move(bufferFence), &drawFence);
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005827
5828 *outSyncFd = drawFence.release();
Yichi Chen40773d92020-04-01 10:10:18 +08005829
5830 if (*outSyncFd >= 0) {
5831 sp<Fence> releaseFence = new Fence(dup(*outSyncFd));
5832 for (auto* layer : renderedLayers) {
5833 layer->onLayerDisplayed(releaseFence);
5834 }
5835 }
Mathias Agopian180f10d2013-04-10 22:55:41 -07005836}
5837
chaviwa76b2712017-09-20 12:02:26 -07005838status_t SurfaceFlinger::captureScreenImplLocked(const RenderArea& renderArea,
5839 TraverseLayersFunction traverseLayers,
5840 ANativeWindowBuffer* buffer,
Robert Carr108b2c72019-04-02 16:32:58 -07005841 bool useIdentityTransform, bool forSystem,
5842 int* outSyncFd, bool& outCapturedSecureLayers) {
Mathias Agopian2a9fc492013-03-01 13:42:57 -08005843 ATRACE_CALL();
5844
chaviwa76b2712017-09-20 12:02:26 -07005845 traverseLayers([&](Layer* layer) {
Robert Carr108b2c72019-04-02 16:32:58 -07005846 outCapturedSecureLayers =
5847 outCapturedSecureLayers || (layer->isVisible() && layer->isSecure());
chaviwa76b2712017-09-20 12:02:26 -07005848 });
Pablo Ceballosb5b35632016-02-23 11:18:51 -08005849
Robert Carr03480e22018-01-04 16:02:06 -08005850 // We allow the system server to take screenshots of secure layers for
5851 // use in situations like the Screen-rotation animation and place
5852 // the impetus on WindowManager to not persist them.
Robert Carr108b2c72019-04-02 16:32:58 -07005853 if (outCapturedSecureLayers && !forSystem) {
Pablo Ceballosb5b35632016-02-23 11:18:51 -08005854 ALOGW("FB is protected: PERMISSION_DENIED");
5855 return PERMISSION_DENIED;
5856 }
Alec Mourie7d1d4a2019-02-05 01:13:46 +00005857 renderScreenImplLocked(renderArea, traverseLayers, buffer, useIdentityTransform, outSyncFd);
Dan Stoza2b6d38e2017-06-01 16:40:30 -07005858 return NO_ERROR;
Mathias Agopian74c40c02010-09-29 13:02:36 -07005859}
5860
chaviw95ef3c42019-02-14 10:55:09 -08005861void SurfaceFlinger::setInputWindowsFinished() {
5862 Mutex::Autolock _l(mStateLock);
5863
5864 mPendingSyncInputWindows = false;
Rob Carr9a2cc992020-03-06 12:44:45 -08005865
chaviw95ef3c42019-02-14 10:55:09 -08005866 mTransactionCV.broadcast();
5867}
chaviw5f21a5e2019-02-14 10:00:34 -08005868
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07005869// ---------------------------------------------------------------------------
5870
Edgar Arriaga844fa672020-01-16 14:21:42 -08005871void SurfaceFlinger::State::traverse(const LayerVector::Visitor& visitor) const {
5872 layersSortedByZ.traverse(visitor);
5873}
5874
Dan Stoza412903f2017-04-27 13:42:17 -07005875void SurfaceFlinger::State::traverseInZOrder(const LayerVector::Visitor& visitor) const {
5876 layersSortedByZ.traverseInZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07005877}
5878
Dan Stoza412903f2017-04-27 13:42:17 -07005879void SurfaceFlinger::State::traverseInReverseZOrder(const LayerVector::Visitor& visitor) const {
5880 layersSortedByZ.traverseInReverseZOrder(stateSet, visitor);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07005881}
5882
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005883void SurfaceFlinger::traverseLayersInDisplay(const sp<const DisplayDevice>& display,
chaviwa76b2712017-09-20 12:02:26 -07005884 const LayerVector::Visitor& visitor) {
5885 // We loop through the first level of layers without traversing,
chaviw0e3479f2018-09-10 16:49:30 -07005886 // as we need to determine which layers belong to the requested display.
chaviwa76b2712017-09-20 12:02:26 -07005887 for (const auto& layer : mDrawingState.layersSortedByZ) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005888 if (!layer->belongsToDisplay(display->getLayerStack(), false)) {
chaviwa76b2712017-09-20 12:02:26 -07005889 continue;
5890 }
Chia-I Wuec2d9852017-11-21 09:21:01 -08005891 // relative layers are traversed in Layer::traverseInZOrder
chaviwa76b2712017-09-20 12:02:26 -07005892 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -07005893 if (!layer->belongsToDisplay(display->getLayerStack(), false)) {
Adrian Roos8acf5a02018-01-17 21:28:19 +01005894 return;
5895 }
chaviwa76b2712017-09-20 12:02:26 -07005896 if (!layer->isVisible()) {
5897 return;
5898 }
5899 visitor(layer);
5900 });
5901 }
5902}
5903
Steven Thomasd4071902020-03-24 16:02:53 -07005904status_t SurfaceFlinger::setDesiredDisplayConfigSpecsInternal(
5905 const sp<DisplayDevice>& display,
5906 const std::optional<scheduler::RefreshRateConfigs::Policy>& policy, bool overridePolicy) {
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005907 Mutex::Autolock lock(mStateLock);
5908
Steven Thomasd4071902020-03-24 16:02:53 -07005909 LOG_ALWAYS_FATAL_IF(!display->isPrimary() && overridePolicy,
5910 "Can only set override policy on the primary display");
5911 LOG_ALWAYS_FATAL_IF(!policy && !overridePolicy, "Can only clear the override policy");
5912
Dominik Laskowski22488f62019-03-28 09:53:04 -07005913 if (!display->isPrimary()) {
Ady Abraham3a77a7b2019-12-02 18:46:59 -08005914 // TODO(b/144711714): For non-primary displays we should be able to set an active config
5915 // as well. For now, just call directly to setActiveConfigWithConstraints but ideally
5916 // it should go thru setDesiredActiveConfig, similar to primary display.
5917 ALOGV("setAllowedDisplayConfigsInternal for non-primary display");
5918 const auto displayId = display->getId();
5919 LOG_ALWAYS_FATAL_IF(!displayId);
5920
5921 HWC2::VsyncPeriodChangeConstraints constraints;
5922 constraints.desiredTimeNanos = systemTime();
5923 constraints.seamlessRequired = false;
5924
5925 HWC2::VsyncPeriodChangeTimeline timeline = {0, 0, 0};
Steven Thomasd4071902020-03-24 16:02:53 -07005926 if (getHwComposer().setActiveConfigWithConstraints(*displayId,
5927 policy->defaultConfig.value(),
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005928 constraints, &timeline) < 0) {
5929 return BAD_VALUE;
5930 }
Ady Abraham3a77a7b2019-12-02 18:46:59 -08005931 if (timeline.refreshRequired) {
5932 repaintEverythingForHWC();
5933 }
5934
Steven Thomasd4071902020-03-24 16:02:53 -07005935 display->setActiveConfig(policy->defaultConfig);
5936 const nsecs_t vsyncPeriod = getHwComposer()
5937 .getConfigs(*displayId)[policy->defaultConfig.value()]
5938 ->getVsyncPeriod();
5939 mScheduler->onConfigChanged(mAppConnectionHandle, display->getId()->value,
5940 policy->defaultConfig, vsyncPeriod);
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005941 return NO_ERROR;
Ady Abraham838de062019-02-04 10:24:03 -08005942 }
5943
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005944 if (mDebugDisplayConfigSetByBackdoor) {
5945 // ignore this request as config is overridden by backdoor
5946 return NO_ERROR;
Adrian Salidoab6ef6c2019-08-28 10:02:49 -07005947 }
5948
Steven Thomasd4071902020-03-24 16:02:53 -07005949 status_t setPolicyResult = overridePolicy
5950 ? mRefreshRateConfigs->setOverridePolicy(policy)
5951 : mRefreshRateConfigs->setDisplayManagerPolicy(*policy);
5952 if (setPolicyResult < 0) {
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005953 return BAD_VALUE;
5954 }
Steven Thomasd4071902020-03-24 16:02:53 -07005955 if (setPolicyResult == scheduler::RefreshRateConfigs::CURRENT_POLICY_UNCHANGED) {
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005956 return NO_ERROR;
5957 }
Steven Thomasd4071902020-03-24 16:02:53 -07005958 scheduler::RefreshRateConfigs::Policy currentPolicy = mRefreshRateConfigs->getCurrentPolicy();
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005959
5960 ALOGV("Setting desired display config specs: defaultConfig: %d min: %.f max: %.f",
Steven Thomasd4071902020-03-24 16:02:53 -07005961 currentPolicy.defaultConfig.value(), currentPolicy.minRefreshRate,
5962 currentPolicy.maxRefreshRate);
Adrian Salidoab6ef6c2019-08-28 10:02:49 -07005963
5964 // TODO(b/140204874): This hack triggers a notification that something has changed, so
5965 // that listeners that care about a change in allowed configs can get the notification.
5966 // Giving current ActiveConfig so that most other listeners would just drop the event
Alec Mouri60aee1c2019-10-28 16:18:59 -07005967 const nsecs_t vsyncPeriod =
Ady Abrahamabc27602020-04-08 17:20:29 -07005968 mRefreshRateConfigs->getRefreshRateFromConfigId(display->getActiveConfig())
5969 .getVsyncPeriod();
Adrian Salidoab6ef6c2019-08-28 10:02:49 -07005970 mScheduler->onConfigChanged(mAppConnectionHandle, display->getId()->value,
Alec Mouri60aee1c2019-10-28 16:18:59 -07005971 display->getActiveConfig(), vsyncPeriod);
Ady Abraham838de062019-02-04 10:24:03 -08005972
Ana Krulec3f6a2062020-01-23 15:48:01 -08005973 auto configId = mScheduler->getPreferredConfigId();
Ady Abraham2e1dd892020-03-05 13:48:36 -08005974 auto& preferredRefreshRate = configId
Ana Krulec3f6a2062020-01-23 15:48:01 -08005975 ? mRefreshRateConfigs->getRefreshRateFromConfigId(*configId)
5976 // NOTE: Choose the default config ID, if Scheduler doesn't have one in mind.
Steven Thomasd4071902020-03-24 16:02:53 -07005977 : mRefreshRateConfigs->getRefreshRateFromConfigId(currentPolicy.defaultConfig);
Ana Krulec3f6a2062020-01-23 15:48:01 -08005978 ALOGV("trying to switch to Scheduler preferred config %d (%s)",
Ady Abrahamabc27602020-04-08 17:20:29 -07005979 preferredRefreshRate.getConfigId().value(), preferredRefreshRate.getName().c_str());
Ana Krulec3f6a2062020-01-23 15:48:01 -08005980
Ady Abrahamabc27602020-04-08 17:20:29 -07005981 if (isDisplayConfigAllowed(preferredRefreshRate.getConfigId())) {
5982 ALOGV("switching to Scheduler preferred config %d",
5983 preferredRefreshRate.getConfigId().value());
5984 setDesiredActiveConfig(
5985 {preferredRefreshRate.getConfigId(), Scheduler::ConfigEvent::Changed});
Ady Abraham2139f732019-11-13 18:56:40 -08005986 } else {
Ady Abrahamabc27602020-04-08 17:20:29 -07005987 LOG_ALWAYS_FATAL("Desired config not allowed: %d",
5988 preferredRefreshRate.getConfigId().value());
Dominik Laskowski4f1dd8c2019-04-17 15:54:30 -07005989 }
5990
Ady Abrahamd9b3ea62019-02-26 14:08:03 -08005991 return NO_ERROR;
5992}
5993
Ana Krulec0782b882019-10-15 17:34:54 -07005994status_t SurfaceFlinger::setDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken,
Ana Kruleced3a8cc2019-11-14 00:55:07 +01005995 int32_t defaultConfig, float minRefreshRate,
Ana Krulec0782b882019-10-15 17:34:54 -07005996 float maxRefreshRate) {
5997 ATRACE_CALL();
5998
5999 if (!displayToken) {
6000 return BAD_VALUE;
6001 }
6002
Dominik Laskowski470df5f2020-04-02 22:27:42 -07006003 status_t result = NAME_NOT_FOUND;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006004
Ana Krulec234bb162019-11-10 22:55:55 +01006005 postMessageSync(new LambdaMessage([&]() {
6006 const auto display = getDisplayDeviceLocked(displayToken);
6007 if (!display) {
6008 ALOGE("Attempt to set desired display configs for invalid display token %p",
6009 displayToken.get());
6010 } else if (display->isVirtual()) {
6011 ALOGW("Attempt to set desired display configs for virtual display");
Dominik Laskowski470df5f2020-04-02 22:27:42 -07006012 result = INVALID_OPERATION;
Ana Krulec234bb162019-11-10 22:55:55 +01006013 } else {
Steven Thomasd4071902020-03-24 16:02:53 -07006014 result = setDesiredDisplayConfigSpecsInternal(display,
6015 scheduler::RefreshRateConfigs::
6016 Policy{HwcConfigIndexType(
6017 defaultConfig),
6018 minRefreshRate,
6019 maxRefreshRate},
6020 /*overridePolicy=*/false);
Ana Krulec234bb162019-11-10 22:55:55 +01006021 }
6022 }));
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006023
6024 return result;
Ana Krulec234bb162019-11-10 22:55:55 +01006025}
6026
6027status_t SurfaceFlinger::getDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken,
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006028 int32_t* outDefaultConfig,
Ana Krulec234bb162019-11-10 22:55:55 +01006029 float* outMinRefreshRate,
6030 float* outMaxRefreshRate) {
6031 ATRACE_CALL();
6032
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006033 if (!displayToken || !outDefaultConfig || !outMinRefreshRate || !outMaxRefreshRate) {
Ana Krulec234bb162019-11-10 22:55:55 +01006034 return BAD_VALUE;
6035 }
6036
6037 Mutex::Autolock lock(mStateLock);
6038 const auto display = getDisplayDeviceLocked(displayToken);
6039 if (!display) {
6040 return NAME_NOT_FOUND;
6041 }
6042
6043 if (display->isPrimary()) {
Steven Thomasd4071902020-03-24 16:02:53 -07006044 scheduler::RefreshRateConfigs::Policy policy =
6045 mRefreshRateConfigs->getDisplayManagerPolicy();
6046 *outDefaultConfig = policy.defaultConfig.value();
6047 *outMinRefreshRate = policy.minRefreshRate;
6048 *outMaxRefreshRate = policy.maxRefreshRate;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006049 return NO_ERROR;
6050 } else if (display->isVirtual()) {
Dominik Laskowski470df5f2020-04-02 22:27:42 -07006051 return INVALID_OPERATION;
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006052 } else {
6053 const auto displayId = display->getId();
Dominik Laskowski470df5f2020-04-02 22:27:42 -07006054 LOG_FATAL_IF(!displayId);
6055
Ana Kruleced3a8cc2019-11-14 00:55:07 +01006056 *outDefaultConfig = getHwComposer().getActiveConfigIndex(*displayId);
6057 auto vsyncPeriod = getHwComposer().getActiveConfig(*displayId)->getVsyncPeriod();
6058 *outMinRefreshRate = 1e9f / vsyncPeriod;
6059 *outMaxRefreshRate = 1e9f / vsyncPeriod;
6060 return NO_ERROR;
Ana Krulec234bb162019-11-10 22:55:55 +01006061 }
Ana Krulec0782b882019-10-15 17:34:54 -07006062}
6063
Dominik Laskowski9dab3432019-03-27 13:21:10 -07006064void SurfaceFlinger::SetInputWindowsListener::onSetInputWindowsFinished() {
chaviw291d88a2019-02-14 10:33:58 -08006065 mFlinger->setInputWindowsFinished();
6066}
6067
Robert Carrc0df3122019-04-11 13:18:21 -07006068sp<Layer> SurfaceFlinger::fromHandle(const sp<IBinder>& handle) {
Valerie Hau09e60052019-12-15 14:51:15 -08006069 BBinder* b = nullptr;
6070 if (handle) {
6071 b = handle->localBinder();
6072 }
Robert Carrc0df3122019-04-11 13:18:21 -07006073 if (b == nullptr) {
6074 return nullptr;
6075 }
6076 auto it = mLayersByLocalBinderToken.find(b);
6077 if (it != mLayersByLocalBinderToken.end()) {
6078 return it->second.promote();
6079 }
6080 return nullptr;
6081}
6082
Dominik Laskowski75848362019-11-11 17:57:20 -08006083void SurfaceFlinger::onLayerFirstRef(Layer* layer) {
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -07006084 mNumLayers++;
6085 mScheduler->registerLayer(layer);
6086}
6087
6088void SurfaceFlinger::onLayerDestroyed(Layer* layer) {
6089 mNumLayers--;
Valerie Hauc5686802019-11-22 14:18:09 -08006090 removeFromOffscreenLayers(layer);
6091}
6092
6093// WARNING: ONLY CALL THIS FROM LAYER DTOR
6094// Here we add children in the current state to offscreen layers and remove the
6095// layer itself from the offscreen layer list. Since
6096// this is the dtor, it is safe to access the current state. This keeps us
6097// from dangling children layers such that they are not reachable from the
6098// Drawing state nor the offscreen layer list
6099// See b/141111965
6100void SurfaceFlinger::removeFromOffscreenLayers(Layer* layer) {
6101 for (auto& child : layer->getCurrentChildren()) {
6102 mOffscreenLayers.emplace(child.get());
6103 }
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -07006104 mOffscreenLayers.erase(layer);
6105}
6106
Alec Mouri4545a8a2019-08-08 20:05:32 -07006107void SurfaceFlinger::bufferErased(const client_cache_t& clientCacheId) {
6108 getRenderEngine().unbindExternalTextureBuffer(clientCacheId.id);
6109}
6110
Vishnu Nair08f6eae2019-11-26 14:01:39 -08006111status_t SurfaceFlinger::setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
6112 float lightPosY, float lightPosZ,
6113 float lightRadius) {
6114 Mutex::Autolock _l(mStateLock);
6115 mCurrentState.globalShadowSettings.ambientColor = vec4(ambientColor);
6116 mCurrentState.globalShadowSettings.spotColor = vec4(spotColor);
6117 mCurrentState.globalShadowSettings.lightPos.y = lightPosY;
6118 mCurrentState.globalShadowSettings.lightPos.z = lightPosZ;
6119 mCurrentState.globalShadowSettings.lightRadius = lightRadius;
6120
6121 // these values are overridden when calculating the shadow settings for a layer.
6122 mCurrentState.globalShadowSettings.lightPos.x = 0.f;
6123 mCurrentState.globalShadowSettings.length = 0.f;
Vishnu Nairb13bb952019-11-15 10:24:08 -08006124 return NO_ERROR;
6125}
6126
Lloyd Pique8d9f8362020-02-11 19:13:09 -08006127const std::unordered_map<std::string, uint32_t>& SurfaceFlinger::getGenericLayerMetadataKeyMap()
6128 const {
6129 // TODO(b/149500060): Remove this fixed/static mapping. Please prefer taking
6130 // on the work to remove the table in that bug rather than adding more to
6131 // it.
6132 static const std::unordered_map<std::string, uint32_t> genericLayerMetadataKeyMap{
6133 // Note: METADATA_OWNER_UID and METADATA_WINDOW_TYPE are officially
6134 // supported, and exposed via the
6135 // IVrComposerClient::VrCommand::SET_LAYER_INFO command.
6136 {"org.chromium.arc.V1_0.TaskId", METADATA_TASK_ID},
6137 {"org.chromium.arc.V1_0.CursorInfo", METADATA_MOUSE_CURSOR},
6138 };
6139 return genericLayerMetadataKeyMap;
6140}
6141
Steven Thomas62a4cf82020-01-31 12:04:03 -08006142status_t SurfaceFlinger::setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,
6143 int8_t compatibility) {
6144 if (!ValidateFrameRate(frameRate, compatibility, "SurfaceFlinger::setFrameRate")) {
6145 return BAD_VALUE;
6146 }
6147
Ady Abraham60e42ea2020-03-09 19:17:31 -07006148 postMessageAsync(new LambdaMessage([=]() NO_THREAD_SAFETY_ANALYSIS {
6149 Mutex::Autolock lock(mStateLock);
6150 if (authenticateSurfaceTextureLocked(surface)) {
6151 sp<Layer> layer = (static_cast<MonitoredProducer*>(surface.get()))->getLayer();
6152 if (layer->setFrameRate(
6153 Layer::FrameRate(frameRate,
6154 Layer::FrameRate::convertCompatibility(compatibility)))) {
6155 setTransactionFlags(eTraversalNeeded);
6156 }
6157 } else {
6158 ALOGE("Attempt to set frame rate on an unrecognized IGraphicBufferProducer");
6159 return BAD_VALUE;
Steven Thomas62a4cf82020-01-31 12:04:03 -08006160 }
Ady Abraham60e42ea2020-03-09 19:17:31 -07006161 return NO_ERROR;
6162 }));
6163
Steven Thomas62a4cf82020-01-31 12:04:03 -08006164 return NO_ERROR;
6165}
6166
Steven Thomasd4071902020-03-24 16:02:53 -07006167status_t SurfaceFlinger::acquireFrameRateFlexibilityToken(sp<IBinder>* outToken) {
6168 if (!outToken) {
6169 return BAD_VALUE;
6170 }
6171 status_t result = NO_ERROR;
6172 postMessageSync(new LambdaMessage([&]() {
6173 if (mFrameRateFlexibilityTokenCount == 0) {
6174 // |mStateLock| not needed as we are on the main thread
6175 const auto display = getDefaultDisplayDeviceLocked();
6176
6177 // This is a little racy, but not in a way that hurts anything. As we grab the
6178 // defaultConfig from the display manager policy, we could be setting a new display
6179 // manager policy, leaving us using a stale defaultConfig. The defaultConfig doesn't
6180 // matter for the override policy though, since we set allowGroupSwitching to true, so
6181 // it's not a problem.
6182 scheduler::RefreshRateConfigs::Policy overridePolicy;
6183 overridePolicy.defaultConfig =
6184 mRefreshRateConfigs->getDisplayManagerPolicy().defaultConfig;
6185 overridePolicy.allowGroupSwitching = true;
6186 result = setDesiredDisplayConfigSpecsInternal(display, overridePolicy,
6187 /*overridePolicy=*/true);
6188 }
6189
6190 if (result == NO_ERROR) {
6191 mFrameRateFlexibilityTokenCount++;
6192 // Handing out a reference to the SurfaceFlinger object, as we're doing in the line
6193 // below, is something to consider carefully. The lifetime of the
6194 // FrameRateFlexibilityToken isn't tied to SurfaceFlinger object lifetime, so if this
6195 // SurfaceFlinger object were to be destroyed while the token still exists, the token
6196 // destructor would be accessing a stale SurfaceFlinger reference, and crash. This is ok
6197 // in this case, for two reasons:
6198 // 1. Once SurfaceFlinger::run() is called by main_surfaceflinger.cpp, the only way
6199 // the program exits is via a crash. So we won't have a situation where the
6200 // SurfaceFlinger object is dead but the process is still up.
6201 // 2. The frame rate flexibility token is acquired/released only by CTS tests, so even
6202 // if condition 1 were changed, the problem would only show up when running CTS tests,
6203 // not on end user devices, so we could spot it and fix it without serious impact.
6204 *outToken = new FrameRateFlexibilityToken(
6205 [this]() { onFrameRateFlexibilityTokenReleased(); });
6206 ALOGD("Frame rate flexibility token acquired. count=%d",
6207 mFrameRateFlexibilityTokenCount);
6208 }
6209 }));
6210 return result;
6211}
6212
6213void SurfaceFlinger::onFrameRateFlexibilityTokenReleased() {
6214 postMessageAsync(new LambdaMessage([&]() {
6215 LOG_ALWAYS_FATAL_IF(mFrameRateFlexibilityTokenCount == 0,
6216 "Failed tracking frame rate flexibility tokens");
6217 mFrameRateFlexibilityTokenCount--;
6218 ALOGD("Frame rate flexibility token released. count=%d", mFrameRateFlexibilityTokenCount);
6219 if (mFrameRateFlexibilityTokenCount == 0) {
6220 // |mStateLock| not needed as we are on the main thread
6221 const auto display = getDefaultDisplayDeviceLocked();
6222 status_t result =
6223 setDesiredDisplayConfigSpecsInternal(display, {}, /*overridePolicy=*/true);
6224 LOG_ALWAYS_FATAL_IF(result < 0, "Failed releasing frame rate flexibility token");
6225 }
6226 }));
6227}
6228
Dominik Laskowski9dab3432019-03-27 13:21:10 -07006229} // namespace android
Lloyd Pique074e8122018-07-26 12:57:23 -07006230
Mathias Agopian3f844832013-08-07 21:24:32 -07006231#if defined(__gl_h_)
6232#error "don't include gl/gl.h in this file"
6233#endif
6234
6235#if defined(__gl2_h_)
6236#error "don't include gl2/gl2.h in this file"
Chia-I Wu767fcf72017-11-30 22:07:38 -08006237#endif
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08006238
6239// TODO(b/129481165): remove the #pragma below and fix conversion issues
6240#pragma clang diagnostic pop // ignored "-Wconversion"