blob: 952023ea1914527a276b6466daeec296d120dd12 [file] [log] [blame]
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001/*
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
17#define ATRACE_TAG ATRACE_TAG_GRAPHICS
18
Mark Salyzyn7823e122016-09-29 08:08:05 -070019#include <dlfcn.h>
20#include <errno.h>
21#include <inttypes.h>
22#include <math.h>
23#include <stdatomic.h>
Fabien Sanglard9d96de42016-10-11 00:15:18 +000024#include <stdint.h>
25#include <sys/types.h>
Dan Stoza9e56aa02015-11-02 13:00:03 -080026
Fabien Sanglard9d96de42016-10-11 00:15:18 +000027#include <mutex>
Fabien Sanglard9d96de42016-10-11 00:15:18 +000028
29#include <EGL/egl.h>
30
Fabien Sanglard9d96de42016-10-11 00:15:18 +000031#include <cutils/properties.h>
Mark Salyzyn7823e122016-09-29 08:08:05 -070032#include <log/log.h>
Fabien Sanglard9d96de42016-10-11 00:15:18 +000033
34#include <binder/IPCThreadState.h>
35#include <binder/IServiceManager.h>
Fabien Sanglard9d96de42016-10-11 00:15:18 +000036#include <binder/PermissionCache.h>
37
38#include <ui/DisplayInfo.h>
39#include <ui/DisplayStatInfo.h>
40
Fabien Sanglard9d96de42016-10-11 00:15:18 +000041#include <gui/BufferQueue.h>
42#include <gui/GuiConfig.h>
43#include <gui/IDisplayEventConnection.h>
Kalle Raitaa099a242017-01-11 11:17:29 -080044#include <gui/LayerDebugInfo.h>
Fabien Sanglard9d96de42016-10-11 00:15:18 +000045#include <gui/Surface.h>
Fabien Sanglard9d96de42016-10-11 00:15:18 +000046
47#include <ui/GraphicBufferAllocator.h>
48#include <ui/HdrCapabilities.h>
49#include <ui/PixelFormat.h>
50#include <ui/UiConfig.h>
51
52#include <utils/misc.h>
53#include <utils/String8.h>
54#include <utils/String16.h>
55#include <utils/StopWatch.h>
56#include <utils/Timers.h>
57#include <utils/Trace.h>
58
59#include <private/android_filesystem_config.h>
60#include <private/gui/SyncFeatures.h>
61
62#include <set>
63
64#include "Client.h"
65#include "clz.h"
66#include "Colorizer.h"
67#include "DdmConnection.h"
68#include "DisplayDevice.h"
69#include "DispSync.h"
70#include "EventControlThread.h"
71#include "EventThread.h"
72#include "Layer.h"
Robert Carr1f0a16a2016-10-24 16:27:39 -070073#include "LayerVector.h"
chaviw13fdc492017-06-27 12:40:18 -070074#include "ColorLayer.h"
Robert Carr1db73f62016-12-21 12:58:51 -080075#include "MonitoredProducer.h"
Fabien Sanglard9d96de42016-10-11 00:15:18 +000076#include "SurfaceFlinger.h"
77
78#include "DisplayHardware/FramebufferSurface.h"
79#include "DisplayHardware/HWComposer.h"
80#include "DisplayHardware/VirtualDisplaySurface.h"
81
82#include "Effects/Daltonizer.h"
83
84#include "RenderEngine/RenderEngine.h"
85#include <cutils/compiler.h>
86
Fabien Sanglard0cc19382017-03-06 11:54:40 -080087#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
88#include <configstore/Utils.h>
89
chaviw1d044282017-09-27 12:19:28 -070090#include <layerproto/LayerProtoParser.h>
91
Fabien Sanglard9d96de42016-10-11 00:15:18 +000092#define DISPLAY_COUNT 1
93
94/*
95 * DEBUG_SCREENSHOTS: set to true to check that screenshots are not all
96 * black pixels.
97 */
98#define DEBUG_SCREENSHOTS false
99
Jiyong Park00b15b82017-08-10 20:30:56 +0900100extern "C" EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name);
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000101
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000102namespace android {
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000103// ---------------------------------------------------------------------------
104
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800105using namespace android::hardware::configstore;
106using namespace android::hardware::configstore::V1_0;
107
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000108const String16 sHardwareTest("android.permission.HARDWARE_TEST");
109const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER");
110const String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER");
111const String16 sDump("android.permission.DUMP");
112
113// ---------------------------------------------------------------------------
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800114int64_t SurfaceFlinger::vsyncPhaseOffsetNs;
115int64_t SurfaceFlinger::sfVsyncPhaseOffsetNs;
Fabien Sanglardc93afd52017-03-13 13:02:42 -0700116bool SurfaceFlinger::useContextPriority;
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700117int64_t SurfaceFlinger::dispSyncPresentTimeOffset;
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700118bool SurfaceFlinger::useHwcForRgbToYuv;
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800119uint64_t SurfaceFlinger::maxVirtualDisplaySize;
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800120bool SurfaceFlinger::hasSyncFramework;
Fabien Sanglard1971b632017-03-10 14:50:03 -0800121int64_t SurfaceFlinger::maxFrameBufferAcquiredBuffers;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000122
123SurfaceFlinger::SurfaceFlinger()
124 : BnSurfaceComposer(),
125 mTransactionFlags(0),
126 mTransactionPending(false),
127 mAnimTransactionPending(false),
128 mLayersRemoved(false),
Robert Carr1f0a16a2016-10-24 16:27:39 -0700129 mLayersAdded(false),
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000130 mRepaintEverything(0),
131 mRenderEngine(NULL),
132 mBootTime(systemTime()),
133 mVisibleRegionsDirty(false),
134 mHwWorkListDirty(false),
135 mAnimCompositionPending(false),
136 mDebugRegion(0),
137 mDebugDDMS(0),
138 mDebugDisableHWC(0),
139 mDebugDisableTransformHint(0),
140 mDebugInSwapBuffers(0),
141 mLastSwapBufferTime(0),
142 mDebugInTransaction(0),
143 mLastTransactionTime(0),
144 mBootFinished(false),
145 mForceFullDamage(false),
Robert Carr0d480722017-01-10 16:42:54 -0800146 mInterceptor(this),
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000147 mPrimaryDispSync("PrimaryDispSync"),
148 mPrimaryHWVsyncEnabled(false),
149 mHWVsyncAvailable(false),
150 mDaltonize(false),
151 mHasColorMatrix(false),
152 mHasPoweredOff(false),
153 mFrameBuckets(),
154 mTotalTime(0),
Robert Carr1f0a16a2016-10-24 16:27:39 -0700155 mLastSwapTime(0),
156 mNumLayers(0)
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000157{
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800158 ALOGI("SurfaceFlinger is starting");
159
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800160 vsyncPhaseOffsetNs = getInt64< ISurfaceFlingerConfigs,
161 &ISurfaceFlingerConfigs::vsyncEventPhaseOffsetNs>(1000000);
162
163 sfVsyncPhaseOffsetNs = getInt64< ISurfaceFlingerConfigs,
164 &ISurfaceFlingerConfigs::vsyncSfEventPhaseOffsetNs>(1000000);
165
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800166 maxVirtualDisplaySize = getUInt64<ISurfaceFlingerConfigs,
167 &ISurfaceFlingerConfigs::maxVirtualDisplaySize>(0);
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000168
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800169 hasSyncFramework = getBool< ISurfaceFlingerConfigs,
170 &ISurfaceFlingerConfigs::hasSyncFramework>(true);
171
Fabien Sanglardc93afd52017-03-13 13:02:42 -0700172 useContextPriority = getBool< ISurfaceFlingerConfigs,
173 &ISurfaceFlingerConfigs::useContextPriority>(false);
174
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700175 dispSyncPresentTimeOffset = getInt64< ISurfaceFlingerConfigs,
176 &ISurfaceFlingerConfigs::presentTimeOffsetFromVSyncNs>(0);
177
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700178 useHwcForRgbToYuv = getBool< ISurfaceFlingerConfigs,
179 &ISurfaceFlingerConfigs::useHwcForRGBtoYUV>(false);
180
Fabien Sanglard1971b632017-03-10 14:50:03 -0800181 maxFrameBufferAcquiredBuffers = getInt64< ISurfaceFlingerConfigs,
182 &ISurfaceFlingerConfigs::maxFrameBufferAcquiredBuffers>(2);
183
Marissa Wall4dea0382017-09-18 13:26:15 -0700184 mPrimaryDispSync.init(hasSyncFramework, dispSyncPresentTimeOffset);
185
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000186 char value[PROPERTY_VALUE_MAX];
187
188 property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");
189 mGpuToCpuSupported = !atoi(value);
190
191 property_get("debug.sf.showupdates", value, "0");
192 mDebugRegion = atoi(value);
193
194 property_get("debug.sf.ddms", value, "0");
195 mDebugDDMS = atoi(value);
196 if (mDebugDDMS) {
197 if (!startDdmConnection()) {
198 // start failed, and DDMS debugging not enabled
199 mDebugDDMS = 0;
200 }
201 }
202 ALOGI_IF(mDebugRegion, "showupdates enabled");
203 ALOGI_IF(mDebugDDMS, "DDMS debugging enabled");
204
Fabien Sanglard642b23d2017-02-09 12:29:39 -0800205 property_get("debug.sf.enable_hwc_vds", value, "0");
206 mUseHwcVirtualDisplays = atoi(value);
207 ALOGI_IF(!mUseHwcVirtualDisplays, "Enabling HWC virtual displays");
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800208
Fabien Sanglardc65dafa2017-02-07 14:06:39 -0800209 property_get("ro.sf.disable_triple_buffer", value, "1");
210 mLayerTripleBufferingDisabled = atoi(value);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800211 ALOGI_IF(mLayerTripleBufferingDisabled, "Disabling Triple Buffering");
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000212}
213
214void SurfaceFlinger::onFirstRef()
215{
216 mEventQueue.init(this);
217}
218
219SurfaceFlinger::~SurfaceFlinger()
220{
221 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
222 eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
223 eglTerminate(display);
224}
225
226void SurfaceFlinger::binderDied(const wp<IBinder>& /* who */)
227{
228 // the window manager died on us. prepare its eulogy.
229
230 // restore initial conditions (default device unblank, etc)
231 initializeDisplays();
232
233 // restart the boot-animation
234 startBootAnim();
235}
236
Robert Carr1db73f62016-12-21 12:58:51 -0800237static sp<ISurfaceComposerClient> initClient(const sp<Client>& client) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000238 status_t err = client->initCheck();
239 if (err == NO_ERROR) {
Robert Carr1db73f62016-12-21 12:58:51 -0800240 return client;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000241 }
Robert Carr1db73f62016-12-21 12:58:51 -0800242 return nullptr;
243}
244
245sp<ISurfaceComposerClient> SurfaceFlinger::createConnection() {
246 return initClient(new Client(this));
247}
248
249sp<ISurfaceComposerClient> SurfaceFlinger::createScopedConnection(
250 const sp<IGraphicBufferProducer>& gbp) {
251 if (authenticateSurfaceTexture(gbp) == false) {
252 return nullptr;
253 }
254 const auto& layer = (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
255 if (layer == nullptr) {
256 return nullptr;
257 }
258
259 return initClient(new Client(this, layer));
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000260}
261
262sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName,
263 bool secure)
264{
265 class DisplayToken : public BBinder {
266 sp<SurfaceFlinger> flinger;
267 virtual ~DisplayToken() {
268 // no more references, this display must be terminated
269 Mutex::Autolock _l(flinger->mStateLock);
270 flinger->mCurrentState.displays.removeItem(this);
271 flinger->setTransactionFlags(eDisplayTransactionNeeded);
272 }
273 public:
274 explicit DisplayToken(const sp<SurfaceFlinger>& flinger)
275 : flinger(flinger) {
276 }
277 };
278
279 sp<BBinder> token = new DisplayToken(this);
280
281 Mutex::Autolock _l(mStateLock);
282 DisplayDeviceState info(DisplayDevice::DISPLAY_VIRTUAL, secure);
283 info.displayName = displayName;
284 mCurrentState.displays.add(token, info);
285 mInterceptor.saveDisplayCreation(info);
286 return token;
287}
288
289void SurfaceFlinger::destroyDisplay(const sp<IBinder>& display) {
290 Mutex::Autolock _l(mStateLock);
291
292 ssize_t idx = mCurrentState.displays.indexOfKey(display);
293 if (idx < 0) {
294 ALOGW("destroyDisplay: invalid display token");
295 return;
296 }
297
298 const DisplayDeviceState& info(mCurrentState.displays.valueAt(idx));
299 if (!info.isVirtualDisplay()) {
300 ALOGE("destroyDisplay called for non-virtual display");
301 return;
302 }
303 mInterceptor.saveDisplayDeletion(info.displayId);
304 mCurrentState.displays.removeItemsAt(idx);
305 setTransactionFlags(eDisplayTransactionNeeded);
306}
307
308void SurfaceFlinger::createBuiltinDisplayLocked(DisplayDevice::DisplayType type) {
309 ALOGW_IF(mBuiltinDisplays[type],
310 "Overwriting display token for display type %d", type);
311 mBuiltinDisplays[type] = new BBinder();
312 // All non-virtual displays are currently considered secure.
313 DisplayDeviceState info(type, true);
314 mCurrentState.displays.add(mBuiltinDisplays[type], info);
315 mInterceptor.saveDisplayCreation(info);
316}
317
318sp<IBinder> SurfaceFlinger::getBuiltInDisplay(int32_t id) {
319 if (uint32_t(id) >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
320 ALOGE("getDefaultDisplay: id=%d is not a valid default display id", id);
321 return NULL;
322 }
323 return mBuiltinDisplays[id];
324}
325
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000326void SurfaceFlinger::bootFinished()
327{
Wei Wangf9b05ee2017-07-19 20:59:39 -0700328 if (mStartPropertySetThread->join() != NO_ERROR) {
329 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800330 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000331 const nsecs_t now = systemTime();
332 const nsecs_t duration = now - mBootTime;
333 ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
334 mBootFinished = true;
335
336 // wait patiently for the window manager death
337 const String16 name("window");
338 sp<IBinder> window(defaultServiceManager()->getService(name));
339 if (window != 0) {
340 window->linkToDeath(static_cast<IBinder::DeathRecipient*>(this));
341 }
342
343 // stop boot animation
344 // formerly we would just kill the process, but we now ask it to exit so it
345 // can choose where to stop the animation.
346 property_set("service.bootanim.exit", "1");
347
348 const int LOGTAG_SF_STOP_BOOTANIM = 60110;
349 LOG_EVENT_LONG(LOGTAG_SF_STOP_BOOTANIM,
350 ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
351}
352
353void SurfaceFlinger::deleteTextureAsync(uint32_t texture) {
354 class MessageDestroyGLTexture : public MessageBase {
355 RenderEngine& engine;
356 uint32_t texture;
357 public:
358 MessageDestroyGLTexture(RenderEngine& engine, uint32_t texture)
359 : engine(engine), texture(texture) {
360 }
361 virtual bool handler() {
362 engine.deleteTextures(1, &texture);
363 return true;
364 }
365 };
366 postMessageAsync(new MessageDestroyGLTexture(getRenderEngine(), texture));
367}
368
369class DispSyncSource : public VSyncSource, private DispSync::Callback {
370public:
371 DispSyncSource(DispSync* dispSync, nsecs_t phaseOffset, bool traceVsync,
372 const char* name) :
373 mName(name),
374 mValue(0),
375 mTraceVsync(traceVsync),
376 mVsyncOnLabel(String8::format("VsyncOn-%s", name)),
377 mVsyncEventLabel(String8::format("VSYNC-%s", name)),
378 mDispSync(dispSync),
379 mCallbackMutex(),
380 mCallback(),
381 mVsyncMutex(),
382 mPhaseOffset(phaseOffset),
383 mEnabled(false) {}
384
385 virtual ~DispSyncSource() {}
386
387 virtual void setVSyncEnabled(bool enable) {
388 Mutex::Autolock lock(mVsyncMutex);
389 if (enable) {
390 status_t err = mDispSync->addEventListener(mName, mPhaseOffset,
391 static_cast<DispSync::Callback*>(this));
392 if (err != NO_ERROR) {
393 ALOGE("error registering vsync callback: %s (%d)",
394 strerror(-err), err);
395 }
396 //ATRACE_INT(mVsyncOnLabel.string(), 1);
397 } else {
398 status_t err = mDispSync->removeEventListener(
399 static_cast<DispSync::Callback*>(this));
400 if (err != NO_ERROR) {
401 ALOGE("error unregistering vsync callback: %s (%d)",
402 strerror(-err), err);
403 }
404 //ATRACE_INT(mVsyncOnLabel.string(), 0);
405 }
406 mEnabled = enable;
407 }
408
409 virtual void setCallback(const sp<VSyncSource::Callback>& callback) {
410 Mutex::Autolock lock(mCallbackMutex);
411 mCallback = callback;
412 }
413
414 virtual void setPhaseOffset(nsecs_t phaseOffset) {
415 Mutex::Autolock lock(mVsyncMutex);
416
417 // Normalize phaseOffset to [0, period)
418 auto period = mDispSync->getPeriod();
419 phaseOffset %= period;
420 if (phaseOffset < 0) {
421 // If we're here, then phaseOffset is in (-period, 0). After this
422 // operation, it will be in (0, period)
423 phaseOffset += period;
424 }
425 mPhaseOffset = phaseOffset;
426
427 // If we're not enabled, we don't need to mess with the listeners
428 if (!mEnabled) {
429 return;
430 }
431
432 // Remove the listener with the old offset
433 status_t err = mDispSync->removeEventListener(
434 static_cast<DispSync::Callback*>(this));
435 if (err != NO_ERROR) {
436 ALOGE("error unregistering vsync callback: %s (%d)",
437 strerror(-err), err);
438 }
439
440 // Add a listener with the new offset
441 err = mDispSync->addEventListener(mName, mPhaseOffset,
442 static_cast<DispSync::Callback*>(this));
443 if (err != NO_ERROR) {
444 ALOGE("error registering vsync callback: %s (%d)",
445 strerror(-err), err);
446 }
447 }
448
449private:
450 virtual void onDispSyncEvent(nsecs_t when) {
451 sp<VSyncSource::Callback> callback;
452 {
453 Mutex::Autolock lock(mCallbackMutex);
454 callback = mCallback;
455
456 if (mTraceVsync) {
457 mValue = (mValue + 1) % 2;
458 ATRACE_INT(mVsyncEventLabel.string(), mValue);
459 }
460 }
461
462 if (callback != NULL) {
463 callback->onVSyncEvent(when);
464 }
465 }
466
467 const char* const mName;
468
469 int mValue;
470
471 const bool mTraceVsync;
472 const String8 mVsyncOnLabel;
473 const String8 mVsyncEventLabel;
474
475 DispSync* mDispSync;
476
477 Mutex mCallbackMutex; // Protects the following
478 sp<VSyncSource::Callback> mCallback;
479
480 Mutex mVsyncMutex; // Protects the following
481 nsecs_t mPhaseOffset;
482 bool mEnabled;
483};
484
485class InjectVSyncSource : public VSyncSource {
486public:
487 InjectVSyncSource() {}
488
489 virtual ~InjectVSyncSource() {}
490
491 virtual void setCallback(const sp<VSyncSource::Callback>& callback) {
492 std::lock_guard<std::mutex> lock(mCallbackMutex);
493 mCallback = callback;
494 }
495
496 virtual void onInjectSyncEvent(nsecs_t when) {
497 std::lock_guard<std::mutex> lock(mCallbackMutex);
498 mCallback->onVSyncEvent(when);
499 }
500
501 virtual void setVSyncEnabled(bool) {}
502 virtual void setPhaseOffset(nsecs_t) {}
503
504private:
505 std::mutex mCallbackMutex; // Protects the following
506 sp<VSyncSource::Callback> mCallback;
507};
508
Wei Wangf9b05ee2017-07-19 20:59:39 -0700509// Do not call property_set on main thread which will be blocked by init
510// Use StartPropertySetThread instead.
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000511void SurfaceFlinger::init() {
512 ALOGI( "SurfaceFlinger's main thread ready to run. "
513 "Initializing graphics H/W...");
514
515 Mutex::Autolock _l(mStateLock);
516
517 // initialize EGL for the default display
518 mEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
519 eglInitialize(mEGLDisplay, NULL, NULL);
520
521 // start the EventThread
522 sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,
523 vsyncPhaseOffsetNs, true, "app");
524 mEventThread = new EventThread(vsyncSrc, *this, false);
525 sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,
526 sfVsyncPhaseOffsetNs, true, "sf");
527 mSFEventThread = new EventThread(sfVsyncSrc, *this, true);
528 mEventQueue.setEventThread(mSFEventThread);
529
Tim Murray22752852017-05-04 13:38:49 -0700530 // set EventThread and SFEventThread to SCHED_FIFO to minimize jitter
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000531 struct sched_param param = {0};
532 param.sched_priority = 2;
533 if (sched_setscheduler(mSFEventThread->getTid(), SCHED_FIFO, &param) != 0) {
534 ALOGE("Couldn't set SCHED_FIFO for SFEventThread");
535 }
Tim Murray22752852017-05-04 13:38:49 -0700536 if (sched_setscheduler(mEventThread->getTid(), SCHED_FIFO, &param) != 0) {
537 ALOGE("Couldn't set SCHED_FIFO for EventThread");
538 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000539
540 // Initialize the H/W composer object. There may or may not be an
541 // actual hardware composer underneath.
Steven Thomasb02664d2017-07-26 18:48:28 -0700542 mHwc.reset(new HWComposer(this,
543 *static_cast<HWComposer::EventHandler *>(this)));
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000544
545 // get a RenderEngine for the given display / config (can't fail)
Kalle Raitabbdcf1f2017-05-22 15:47:46 -0700546 mRenderEngine = RenderEngine::create(mEGLDisplay,
547 mHwc->getVisualID(), 0);
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000548
549 // retrieve the EGL context that was selected/created
550 mEGLContext = mRenderEngine->getEGLContext();
551
552 LOG_ALWAYS_FATAL_IF(mEGLContext == EGL_NO_CONTEXT,
553 "couldn't create EGLContext");
554
555 // initialize our non-virtual displays
556 for (size_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {
557 DisplayDevice::DisplayType type((DisplayDevice::DisplayType)i);
558 // set-up the displays that are already connected
559 if (mHwc->isConnected(i) || type==DisplayDevice::DISPLAY_PRIMARY) {
560 // All non-virtual displays are currently considered secure.
561 bool isSecure = true;
562 createBuiltinDisplayLocked(type);
563 wp<IBinder> token = mBuiltinDisplays[i];
564
565 sp<IGraphicBufferProducer> producer;
566 sp<IGraphicBufferConsumer> consumer;
Mathias Agopian0556d792017-03-22 15:49:32 -0700567 BufferQueue::createBufferQueue(&producer, &consumer);
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000568
569 sp<FramebufferSurface> fbs = new FramebufferSurface(*mHwc, i,
570 consumer);
571 int32_t hwcId = allocateHwcDisplayId(type);
572 sp<DisplayDevice> hw = new DisplayDevice(this,
573 type, hwcId, mHwc->getFormat(hwcId), isSecure, token,
574 fbs, producer,
Courtney Goeltzenleuchter4f20f9c2017-04-06 08:18:34 -0600575 mRenderEngine->getEGLConfig(), false);
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000576 if (i > DisplayDevice::DISPLAY_PRIMARY) {
577 // FIXME: currently we don't get blank/unblank requests
578 // for displays other than the main display, so we always
579 // assume a connected display is unblanked.
580 ALOGD("marking display %zu as acquired/unblanked", i);
581 hw->setPowerMode(HWC_POWER_MODE_NORMAL);
582 }
583 mDisplays.add(token, hw);
584 }
585 }
586
587 // make the GLContext current so that we can create textures when creating Layers
588 // (which may happens before we render something)
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700589 getDefaultDisplayDeviceLocked()->makeCurrent(mEGLDisplay, mEGLContext);
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000590
591 mEventControlThread = new EventControlThread(this);
592 mEventControlThread->run("EventControl", PRIORITY_URGENT_DISPLAY);
593
594 // set a fake vsync period if there is no HWComposer
595 if (mHwc->initCheck() != NO_ERROR) {
596 mPrimaryDispSync.setPeriod(16666667);
597 }
598
599 // initialize our drawing state
600 mDrawingState = mCurrentState;
601
602 // set initial conditions (e.g. unblank default device)
603 initializeDisplays();
604
605 mRenderEngine->primeCache();
606
Wei Wangf9b05ee2017-07-19 20:59:39 -0700607 // Inform native graphics APIs that the present timestamp is NOT supported:
608 mStartPropertySetThread = new StartPropertySetThread(false);
609 if (mStartPropertySetThread->Start() != NO_ERROR) {
610 ALOGE("Run StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800611 }
612
613 ALOGV("Done initializing");
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000614}
615
616int32_t SurfaceFlinger::allocateHwcDisplayId(DisplayDevice::DisplayType type) {
617 return (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) ?
618 type : mHwc->allocateDisplayId();
619}
620
621void SurfaceFlinger::startBootAnim() {
Wei Wangb254fa32017-01-31 17:43:23 -0800622 // Start boot animation service by setting a property mailbox
623 // if property setting thread is already running, Start() will be just a NOP
Wei Wangf9b05ee2017-07-19 20:59:39 -0700624 mStartPropertySetThread->Start();
Wei Wangb254fa32017-01-31 17:43:23 -0800625 // Wait until property was set
Wei Wangf9b05ee2017-07-19 20:59:39 -0700626 if (mStartPropertySetThread->join() != NO_ERROR) {
627 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800628 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000629}
630
631size_t SurfaceFlinger::getMaxTextureSize() const {
632 return mRenderEngine->getMaxTextureSize();
633}
634
635size_t SurfaceFlinger::getMaxViewportDims() const {
636 return mRenderEngine->getMaxViewportDims();
637}
638
639// ----------------------------------------------------------------------------
640
641bool SurfaceFlinger::authenticateSurfaceTexture(
642 const sp<IGraphicBufferProducer>& bufferProducer) const {
643 Mutex::Autolock _l(mStateLock);
Robert Carr0d480722017-01-10 16:42:54 -0800644 return authenticateSurfaceTextureLocked(bufferProducer);
645}
646
647bool SurfaceFlinger::authenticateSurfaceTextureLocked(
648 const sp<IGraphicBufferProducer>& bufferProducer) const {
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000649 sp<IBinder> surfaceTextureBinder(IInterface::asBinder(bufferProducer));
650 return mGraphicBufferProducerList.indexOf(surfaceTextureBinder) >= 0;
651}
652
Brian Anderson6b376712017-04-04 10:51:39 -0700653status_t SurfaceFlinger::getSupportedFrameTimestamps(
654 std::vector<FrameEvent>* outSupported) const {
655 *outSupported = {
656 FrameEvent::REQUESTED_PRESENT,
657 FrameEvent::ACQUIRE,
658 FrameEvent::LATCH,
659 FrameEvent::FIRST_REFRESH_START,
660 FrameEvent::LAST_REFRESH_START,
661 FrameEvent::GPU_COMPOSITION_DONE,
662 FrameEvent::DEQUEUE_READY,
663 FrameEvent::RELEASE,
664 };
665 return NO_ERROR;
666}
667
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000668status_t SurfaceFlinger::getDisplayConfigs(const sp<IBinder>& display,
669 Vector<DisplayInfo>* configs) {
670 if ((configs == NULL) || (display.get() == NULL)) {
671 return BAD_VALUE;
672 }
673
674 int32_t type = getDisplayType(display);
675 if (type < 0) return type;
676
677 // TODO: Not sure if display density should handled by SF any longer
678 class Density {
679 static int getDensityFromProperty(char const* propName) {
680 char property[PROPERTY_VALUE_MAX];
681 int density = 0;
682 if (property_get(propName, property, NULL) > 0) {
683 density = atoi(property);
684 }
685 return density;
686 }
687 public:
688 static int getEmuDensity() {
689 return getDensityFromProperty("qemu.sf.lcd_density"); }
690 static int getBuildDensity() {
691 return getDensityFromProperty("ro.sf.lcd_density"); }
692 };
693
694 configs->clear();
695
696 const Vector<HWComposer::DisplayConfig>& hwConfigs =
697 getHwComposer().getConfigs(type);
698 for (size_t c = 0; c < hwConfigs.size(); ++c) {
699 const HWComposer::DisplayConfig& hwConfig = hwConfigs[c];
700 DisplayInfo info = DisplayInfo();
701
702 float xdpi = hwConfig.xdpi;
703 float ydpi = hwConfig.ydpi;
704
705 if (type == DisplayDevice::DISPLAY_PRIMARY) {
706 // The density of the device is provided by a build property
707 float density = Density::getBuildDensity() / 160.0f;
708 if (density == 0) {
709 // the build doesn't provide a density -- this is wrong!
710 // use xdpi instead
711 ALOGE("ro.sf.lcd_density must be defined as a build property");
712 density = xdpi / 160.0f;
713 }
714 if (Density::getEmuDensity()) {
715 // if "qemu.sf.lcd_density" is specified, it overrides everything
716 xdpi = ydpi = density = Density::getEmuDensity();
717 density /= 160.0f;
718 }
719 info.density = density;
720
721 // TODO: this needs to go away (currently needed only by webkit)
722 sp<const DisplayDevice> hw(getDefaultDisplayDevice());
723 info.orientation = hw->getOrientation();
724 } else {
725 // TODO: where should this value come from?
726 static const int TV_DENSITY = 213;
727 info.density = TV_DENSITY / 160.0f;
728 info.orientation = 0;
729 }
730
731 info.w = hwConfig.width;
732 info.h = hwConfig.height;
733 info.xdpi = xdpi;
734 info.ydpi = ydpi;
735 info.fps = float(1e9 / hwConfig.refresh);
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800736 info.appVsyncOffset = vsyncPhaseOffsetNs;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000737
738 // This is how far in advance a buffer must be queued for
739 // presentation at a given time. If you want a buffer to appear
740 // on the screen at time N, you must submit the buffer before
741 // (N - presentationDeadline).
742 //
743 // Normally it's one full refresh period (to give SF a chance to
744 // latch the buffer), but this can be reduced by configuring a
745 // DispSync offset. Any additional delays introduced by the hardware
746 // composer or panel must be accounted for here.
747 //
748 // We add an additional 1ms to allow for processing time and
749 // differences between the ideal and actual refresh rate.
750 info.presentationDeadline =
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800751 hwConfig.refresh - sfVsyncPhaseOffsetNs + 1000000;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000752
753 // All non-virtual displays are currently considered secure.
754 info.secure = true;
755
756 configs->push_back(info);
757 }
758
759 return NO_ERROR;
760}
761
762status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>& /* display */,
763 DisplayStatInfo* stats) {
764 if (stats == NULL) {
765 return BAD_VALUE;
766 }
767
768 // FIXME for now we always return stats for the primary display
769 memset(stats, 0, sizeof(*stats));
770 stats->vsyncTime = mPrimaryDispSync.computeNextRefresh(0);
771 stats->vsyncPeriod = mPrimaryDispSync.getPeriod();
772 return NO_ERROR;
773}
774
775int SurfaceFlinger::getActiveConfig(const sp<IBinder>& display) {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700776 sp<const DisplayDevice> device(getDisplayDevice(display));
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000777 if (device != NULL) {
778 return device->getActiveConfig();
779 }
780 return BAD_VALUE;
781}
782
783void SurfaceFlinger::setActiveConfigInternal(const sp<DisplayDevice>& hw, int mode) {
784 ALOGD("Set active config mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(),
785 this);
786 int32_t type = hw->getDisplayType();
787 int currentMode = hw->getActiveConfig();
788
789 if (mode == currentMode) {
790 ALOGD("Screen type=%d is already mode=%d", hw->getDisplayType(), mode);
791 return;
792 }
793
794 if (type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
795 ALOGW("Trying to set config for virtual display");
796 return;
797 }
798
799 hw->setActiveConfig(mode);
800 getHwComposer().setActiveConfig(type, mode);
801}
802
803status_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& display, int mode) {
804 class MessageSetActiveConfig: public MessageBase {
805 SurfaceFlinger& mFlinger;
806 sp<IBinder> mDisplay;
807 int mMode;
808 public:
809 MessageSetActiveConfig(SurfaceFlinger& flinger, const sp<IBinder>& disp,
810 int mode) :
811 mFlinger(flinger), mDisplay(disp) { mMode = mode; }
812 virtual bool handler() {
813 Vector<DisplayInfo> configs;
814 mFlinger.getDisplayConfigs(mDisplay, &configs);
815 if (mMode < 0 || mMode >= static_cast<int>(configs.size())) {
816 ALOGE("Attempt to set active config = %d for display with %zu configs",
817 mMode, configs.size());
818 }
819 sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
820 if (hw == NULL) {
821 ALOGE("Attempt to set active config = %d for null display %p",
822 mMode, mDisplay.get());
823 } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) {
824 ALOGW("Attempt to set active config = %d for virtual display",
825 mMode);
826 } else {
827 mFlinger.setActiveConfigInternal(hw, mMode);
828 }
829 return true;
830 }
831 };
832 sp<MessageBase> msg = new MessageSetActiveConfig(*this, display, mode);
833 postMessageSync(msg);
834 return NO_ERROR;
835}
836
837status_t SurfaceFlinger::getDisplayColorModes(const sp<IBinder>& display,
838 Vector<android_color_mode_t>* outColorModes) {
839 if (outColorModes == nullptr || display.get() == nullptr) {
840 return BAD_VALUE;
841 }
842
843 int32_t type = getDisplayType(display);
844 if (type < 0) return type;
845
846 std::set<android_color_mode_t> colorModes;
847 for (const HWComposer::DisplayConfig& hwConfig : getHwComposer().getConfigs(type)) {
848 colorModes.insert(hwConfig.colorMode);
849 }
850
851 outColorModes->clear();
852 std::copy(colorModes.cbegin(), colorModes.cend(), std::back_inserter(*outColorModes));
853
854 return NO_ERROR;
855}
856
857android_color_mode_t SurfaceFlinger::getActiveColorMode(const sp<IBinder>& display) {
858 if (display.get() == nullptr) return static_cast<android_color_mode_t>(BAD_VALUE);
859
860 int32_t type = getDisplayType(display);
861 if (type < 0) return static_cast<android_color_mode_t>(type);
862
863 return getHwComposer().getColorMode(type);
864}
865
866status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& display,
867 android_color_mode_t colorMode) {
868 if (display.get() == nullptr || colorMode < 0) {
869 return BAD_VALUE;
870 }
871
872 int32_t type = getDisplayType(display);
873 if (type < 0) return type;
874 const Vector<HWComposer::DisplayConfig>& hwConfigs = getHwComposer().getConfigs(type);
875 HWComposer::DisplayConfig desiredConfig = hwConfigs[getHwComposer().getCurrentConfig(type)];
876 desiredConfig.colorMode = colorMode;
877 for (size_t c = 0; c < hwConfigs.size(); ++c) {
878 const HWComposer::DisplayConfig config = hwConfigs[c];
879 if (config == desiredConfig) {
880 return setActiveConfig(display, c);
881 }
882 }
883 return BAD_VALUE;
884}
885
886status_t SurfaceFlinger::clearAnimationFrameStats() {
887 Mutex::Autolock _l(mStateLock);
888 mAnimFrameTracker.clearStats();
889 return NO_ERROR;
890}
891
892status_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const {
893 Mutex::Autolock _l(mStateLock);
894 mAnimFrameTracker.getStats(outStats);
895 return NO_ERROR;
896}
897
898status_t SurfaceFlinger::getHdrCapabilities(const sp<IBinder>& /*display*/,
899 HdrCapabilities* outCapabilities) const {
900 // HWC1 does not provide HDR capabilities
901 *outCapabilities = HdrCapabilities();
902 return NO_ERROR;
903}
904
905status_t SurfaceFlinger::enableVSyncInjections(bool enable) {
906 if (enable == mInjectVSyncs) {
907 return NO_ERROR;
908 }
909
910 if (enable) {
911 mInjectVSyncs = enable;
912 ALOGV("VSync Injections enabled");
913 if (mVSyncInjector.get() == nullptr) {
914 mVSyncInjector = new InjectVSyncSource();
915 mInjectorEventThread = new EventThread(mVSyncInjector, *this, false);
916 }
917 mEventQueue.setEventThread(mInjectorEventThread);
918 } else {
919 mInjectVSyncs = enable;
920 ALOGV("VSync Injections disabled");
921 mEventQueue.setEventThread(mSFEventThread);
922 mVSyncInjector.clear();
923 }
924 return NO_ERROR;
925}
926
927status_t SurfaceFlinger::injectVSync(nsecs_t when) {
928 if (!mInjectVSyncs) {
929 ALOGE("VSync Injections not enabled");
930 return BAD_VALUE;
931 }
932 if (mInjectVSyncs && mInjectorEventThread.get() != nullptr) {
933 ALOGV("Injecting VSync inside SurfaceFlinger");
934 mVSyncInjector->onInjectSyncEvent(when);
935 }
936 return NO_ERROR;
937}
938
Kalle Raitaa099a242017-01-11 11:17:29 -0800939status_t SurfaceFlinger::getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const {
940 IPCThreadState* ipc = IPCThreadState::self();
941 const int pid = ipc->getCallingPid();
942 const int uid = ipc->getCallingUid();
943 if ((uid != AID_SHELL) &&
944 !PermissionCache::checkPermission(sDump, pid, uid)) {
945 ALOGE("Layer debug info permission denied for pid=%d, uid=%d", pid, uid);
946 return PERMISSION_DENIED;
947 }
948
949 // Try to acquire a lock for 1s, fail gracefully
950 status_t err = mStateLock.timedLock(s2ns(1));
951 bool locked = (err == NO_ERROR);
952 if (!locked) {
953 ALOGE("LayerDebugInfo: SurfaceFlinger unresponsive (%s [%d]) - exit", strerror(-err), err);
954 return TIMED_OUT;
955 }
956
957 outLayers->clear();
958 mCurrentState.traverseInZOrder([&](Layer* layer) {
959 outLayers->push_back(layer->getLayerDebugInfo());
960 });
961
962 mStateLock.unlock();
963
964 return NO_ERROR;
965}
966
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000967// ----------------------------------------------------------------------------
968
Jorim Jaggiaaef0982017-06-08 23:55:29 -0700969sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection(
970 ISurfaceComposer::VsyncSource vsyncSource) {
971 if (vsyncSource == eVsyncSourceSurfaceFlinger) {
972 return mSFEventThread->createEventConnection();
973 } else {
974 return mEventThread->createEventConnection();
975 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000976}
977
978// ----------------------------------------------------------------------------
979
980void SurfaceFlinger::waitForEvent() {
981 mEventQueue.waitMessage();
982}
983
984void SurfaceFlinger::signalTransaction() {
985 mEventQueue.invalidate();
986}
987
988void SurfaceFlinger::signalLayerUpdate() {
989 mEventQueue.invalidate();
990}
991
992void SurfaceFlinger::signalRefresh() {
993 mEventQueue.refresh();
994}
995
996status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,
997 nsecs_t reltime, uint32_t /* flags */) {
998 return mEventQueue.postMessage(msg, reltime);
999}
1000
1001status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
1002 nsecs_t reltime, uint32_t /* flags */) {
1003 status_t res = mEventQueue.postMessage(msg, reltime);
1004 if (res == NO_ERROR) {
1005 msg->wait();
1006 }
1007 return res;
1008}
1009
1010void SurfaceFlinger::run() {
1011 do {
1012 waitForEvent();
1013 } while (true);
1014}
1015
1016void SurfaceFlinger::enableHardwareVsync() {
1017 Mutex::Autolock _l(mHWVsyncLock);
1018 if (!mPrimaryHWVsyncEnabled && mHWVsyncAvailable) {
1019 mPrimaryDispSync.beginResync();
1020 //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true);
1021 mEventControlThread->setVsyncEnabled(true);
1022 mPrimaryHWVsyncEnabled = true;
1023 }
1024}
1025
1026void SurfaceFlinger::resyncToHardwareVsync(bool makeAvailable) {
1027 Mutex::Autolock _l(mHWVsyncLock);
1028
1029 if (makeAvailable) {
1030 mHWVsyncAvailable = true;
1031 } else if (!mHWVsyncAvailable) {
1032 // Hardware vsync is not currently available, so abort the resync
1033 // attempt for now
1034 return;
1035 }
1036
1037 const nsecs_t period =
1038 getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
1039
1040 mPrimaryDispSync.reset();
1041 mPrimaryDispSync.setPeriod(period);
1042
1043 if (!mPrimaryHWVsyncEnabled) {
1044 mPrimaryDispSync.beginResync();
1045 //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true);
1046 mEventControlThread->setVsyncEnabled(true);
1047 mPrimaryHWVsyncEnabled = true;
1048 }
1049}
1050
1051void SurfaceFlinger::disableHardwareVsync(bool makeUnavailable) {
1052 Mutex::Autolock _l(mHWVsyncLock);
1053 if (mPrimaryHWVsyncEnabled) {
1054 //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, false);
1055 mEventControlThread->setVsyncEnabled(false);
1056 mPrimaryDispSync.endResync();
1057 mPrimaryHWVsyncEnabled = false;
1058 }
1059 if (makeUnavailable) {
1060 mHWVsyncAvailable = false;
1061 }
1062}
1063
1064void SurfaceFlinger::resyncWithRateLimit() {
1065 static constexpr nsecs_t kIgnoreDelay = ms2ns(500);
1066 if (systemTime() - mLastSwapTime > kIgnoreDelay) {
1067 resyncToHardwareVsync(false);
1068 }
1069}
1070
Steven Thomas3cfac282017-02-06 12:29:30 -08001071void SurfaceFlinger::onVSyncReceived(HWComposer* /*composer*/, int type,
1072 nsecs_t timestamp) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001073 bool needsHwVsync = false;
1074
1075 { // Scope for the lock
1076 Mutex::Autolock _l(mHWVsyncLock);
1077 if (type == 0 && mPrimaryHWVsyncEnabled) {
1078 needsHwVsync = mPrimaryDispSync.addResyncSample(timestamp);
1079 }
1080 }
1081
1082 if (needsHwVsync) {
1083 enableHardwareVsync();
1084 } else {
1085 disableHardwareVsync(false);
1086 }
1087}
1088
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001089void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
Brian Andersond0010582017-03-07 13:20:31 -08001090 std::lock_guard<std::mutex> lock(mCompositorTimingLock);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001091 *compositorTiming = mCompositorTiming;
1092}
1093
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001094void SurfaceFlinger::onHotplugReceived(HWComposer* /*composer*/, int type, bool connected) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001095 if (mEventThread == NULL) {
1096 // This is a temporary workaround for b/7145521. A non-null pointer
1097 // does not mean EventThread has finished initializing, so this
1098 // is not a correct fix.
1099 ALOGW("WARNING: EventThread not started, ignoring hotplug");
1100 return;
1101 }
1102
1103 if (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
1104 Mutex::Autolock _l(mStateLock);
1105 if (connected) {
1106 createBuiltinDisplayLocked((DisplayDevice::DisplayType)type);
1107 } else {
1108 mCurrentState.displays.removeItem(mBuiltinDisplays[type]);
1109 mBuiltinDisplays[type].clear();
1110 }
1111 setTransactionFlags(eDisplayTransactionNeeded);
1112
1113 // Defer EventThread notification until SF has updated mDisplays.
1114 }
1115}
1116
Steven Thomas3cfac282017-02-06 12:29:30 -08001117void SurfaceFlinger::onInvalidateReceived(HWComposer* /*composer*/) {
1118 repaintEverything();
1119}
1120
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001121void SurfaceFlinger::eventControl(int disp, int event, int enabled) {
1122 ATRACE_CALL();
1123 getHwComposer().eventControl(disp, event, enabled);
1124}
1125
1126void SurfaceFlinger::onMessageReceived(int32_t what) {
1127 ATRACE_CALL();
1128 switch (what) {
1129 case MessageQueue::INVALIDATE: {
1130 bool refreshNeeded = handleMessageTransaction();
1131 refreshNeeded |= handleMessageInvalidate();
1132 refreshNeeded |= mRepaintEverything;
1133 if (refreshNeeded) {
1134 // Signal a refresh if a transaction modified the window state,
1135 // a new buffer was latched, or if HWC has requested a full
1136 // repaint
1137 signalRefresh();
1138 }
1139 break;
1140 }
1141 case MessageQueue::REFRESH: {
1142 handleMessageRefresh();
1143 break;
1144 }
1145 }
1146}
1147
1148bool SurfaceFlinger::handleMessageTransaction() {
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08001149 uint32_t transactionFlags = peekTransactionFlags();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001150 if (transactionFlags) {
1151 handleTransaction(transactionFlags);
1152 return true;
1153 }
1154 return false;
1155}
1156
1157bool SurfaceFlinger::handleMessageInvalidate() {
1158 ATRACE_CALL();
1159 return handlePageFlip();
1160}
1161
1162void SurfaceFlinger::handleMessageRefresh() {
1163 ATRACE_CALL();
1164
1165 nsecs_t refreshStartTime = systemTime(SYSTEM_TIME_MONOTONIC);
1166
Brian Andersond6927fb2016-07-23 23:37:30 -07001167 preComposition(refreshStartTime);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001168 rebuildLayerStacks();
1169 setUpHWComposer();
1170 doDebugFlashRegions();
1171 doComposition();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001172 postComposition(refreshStartTime);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001173}
1174
1175void SurfaceFlinger::doDebugFlashRegions()
1176{
1177 // is debugging enabled
1178 if (CC_LIKELY(!mDebugRegion))
1179 return;
1180
1181 const bool repaintEverything = mRepaintEverything;
1182 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1183 const sp<DisplayDevice>& hw(mDisplays[dpy]);
1184 if (hw->isDisplayOn()) {
1185 // transform the dirty region into this screen's coordinate space
1186 const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
1187 if (!dirtyRegion.isEmpty()) {
1188 // redraw the whole screen
1189 doComposeSurfaces(hw, Region(hw->bounds()));
1190
1191 // and draw the dirty region
1192 const int32_t height = hw->getHeight();
1193 RenderEngine& engine(getRenderEngine());
1194 engine.fillRegionWithColor(dirtyRegion, height, 1, 0, 1, 1);
1195
1196 hw->compositionComplete();
1197 hw->swapBuffers(getHwComposer());
1198 }
1199 }
1200 }
1201
1202 postFramebuffer();
1203
1204 if (mDebugRegion > 1) {
1205 usleep(mDebugRegion * 1000);
1206 }
1207
1208 HWComposer& hwc(getHwComposer());
1209 if (hwc.initCheck() == NO_ERROR) {
1210 status_t err = hwc.prepare();
1211 ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
1212 }
1213}
1214
Brian Andersond6927fb2016-07-23 23:37:30 -07001215void SurfaceFlinger::preComposition(nsecs_t refreshStartTime)
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001216{
1217 bool needExtraInvalidate = false;
Robert Carr2047fae2016-11-28 14:09:09 -08001218 mDrawingState.traverseInZOrder([&](Layer* layer) {
1219 if (layer->onPreComposition(refreshStartTime)) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001220 needExtraInvalidate = true;
1221 }
Robert Carr2047fae2016-11-28 14:09:09 -08001222 });
1223
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001224 if (needExtraInvalidate) {
1225 signalLayerUpdate();
1226 }
1227}
1228
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001229void SurfaceFlinger::updateCompositorTiming(
1230 nsecs_t vsyncPhase, nsecs_t vsyncInterval, nsecs_t compositeTime,
1231 std::shared_ptr<FenceTime>& presentFenceTime) {
1232 // Update queue of past composite+present times and determine the
1233 // most recently known composite to present latency.
1234 mCompositePresentTimes.push({compositeTime, presentFenceTime});
1235 nsecs_t compositeToPresentLatency = -1;
1236 while (!mCompositePresentTimes.empty()) {
1237 CompositePresentTime& cpt = mCompositePresentTimes.front();
1238 // Cached values should have been updated before calling this method,
1239 // which helps avoid duplicate syscalls.
1240 nsecs_t displayTime = cpt.display->getCachedSignalTime();
1241 if (displayTime == Fence::SIGNAL_TIME_PENDING) {
1242 break;
1243 }
1244 compositeToPresentLatency = displayTime - cpt.composite;
1245 mCompositePresentTimes.pop();
1246 }
1247
1248 // Don't let mCompositePresentTimes grow unbounded, just in case.
1249 while (mCompositePresentTimes.size() > 16) {
1250 mCompositePresentTimes.pop();
1251 }
1252
Brian Andersond0010582017-03-07 13:20:31 -08001253 setCompositorTimingSnapped(
1254 vsyncPhase, vsyncInterval, compositeToPresentLatency);
1255}
1256
1257void SurfaceFlinger::setCompositorTimingSnapped(nsecs_t vsyncPhase,
1258 nsecs_t vsyncInterval, nsecs_t compositeToPresentLatency) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001259 // Integer division and modulo round toward 0 not -inf, so we need to
1260 // treat negative and positive offsets differently.
Brian Andersond0010582017-03-07 13:20:31 -08001261 nsecs_t idealLatency = (sfVsyncPhaseOffsetNs > 0) ?
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001262 (vsyncInterval - (sfVsyncPhaseOffsetNs % vsyncInterval)) :
1263 ((-sfVsyncPhaseOffsetNs) % vsyncInterval);
1264
Brian Andersond0010582017-03-07 13:20:31 -08001265 // Just in case sfVsyncPhaseOffsetNs == -vsyncInterval.
1266 if (idealLatency <= 0) {
1267 idealLatency = vsyncInterval;
1268 }
1269
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001270 // Snap the latency to a value that removes scheduling jitter from the
1271 // composition and present times, which often have >1ms of jitter.
1272 // Reducing jitter is important if an app attempts to extrapolate
1273 // something (such as user input) to an accurate diasplay time.
1274 // Snapping also allows an app to precisely calculate sfVsyncPhaseOffsetNs
1275 // with (presentLatency % interval).
Brian Andersond0010582017-03-07 13:20:31 -08001276 nsecs_t bias = vsyncInterval / 2;
1277 int64_t extraVsyncs =
1278 (compositeToPresentLatency - idealLatency + bias) / vsyncInterval;
1279 nsecs_t snappedCompositeToPresentLatency = (extraVsyncs > 0) ?
1280 idealLatency + (extraVsyncs * vsyncInterval) : idealLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001281
Brian Andersond0010582017-03-07 13:20:31 -08001282 std::lock_guard<std::mutex> lock(mCompositorTimingLock);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001283 mCompositorTiming.deadline = vsyncPhase - idealLatency;
1284 mCompositorTiming.interval = vsyncInterval;
Brian Andersond0010582017-03-07 13:20:31 -08001285 mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001286}
1287
1288void SurfaceFlinger::postComposition(nsecs_t refreshStartTime)
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001289{
Brian Andersond6927fb2016-07-23 23:37:30 -07001290 const HWComposer& hwc = getHwComposer();
1291 const sp<const DisplayDevice> hw(getDefaultDisplayDevice());
1292
Brian Andersonfbc80ae2017-05-26 16:23:54 -07001293 mGlCompositionDoneTimeline.updateSignalTimes();
Brian Anderson3d4039d2016-09-23 16:31:30 -07001294 std::shared_ptr<FenceTime> glCompositionDoneFenceTime;
1295 if (getHwComposer().hasGlesComposition(hw->getHwcDisplayId())) {
1296 glCompositionDoneFenceTime =
1297 std::make_shared<FenceTime>(hw->getClientTargetAcquireFence());
1298 mGlCompositionDoneTimeline.push(glCompositionDoneFenceTime);
1299 } else {
1300 glCompositionDoneFenceTime = FenceTime::NO_FENCE;
1301 }
Brian Anderson3d4039d2016-09-23 16:31:30 -07001302
Brian Andersonfbc80ae2017-05-26 16:23:54 -07001303 mDisplayTimeline.updateSignalTimes();
Brian Anderson4e606e32017-03-16 15:34:57 -07001304 sp<Fence> retireFence = mHwc->getDisplayFence(HWC_DISPLAY_PRIMARY);
1305 auto retireFenceTime = std::make_shared<FenceTime>(retireFence);
Brian Anderson3d4039d2016-09-23 16:31:30 -07001306 mDisplayTimeline.push(retireFenceTime);
Brian Andersond6927fb2016-07-23 23:37:30 -07001307
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001308 nsecs_t vsyncPhase = mPrimaryDispSync.computeNextRefresh(0);
1309 nsecs_t vsyncInterval = mPrimaryDispSync.getPeriod();
1310
1311 // We use the refreshStartTime which might be sampled a little later than
1312 // when we started doing work for this frame, but that should be okay
1313 // since updateCompositorTiming has snapping logic.
1314 updateCompositorTiming(
1315 vsyncPhase, vsyncInterval, refreshStartTime, retireFenceTime);
Brian Andersond0010582017-03-07 13:20:31 -08001316 CompositorTiming compositorTiming;
1317 {
1318 std::lock_guard<std::mutex> lock(mCompositorTimingLock);
1319 compositorTiming = mCompositorTiming;
1320 }
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001321
Robert Carr2047fae2016-11-28 14:09:09 -08001322 mDrawingState.traverseInZOrder([&](Layer* layer) {
Brian Anderson4e606e32017-03-16 15:34:57 -07001323 // TODO(brianderson): The retire fence is incorrectly passed in as the
1324 // present fence. Fix this if this file lives on.
Robert Carr2047fae2016-11-28 14:09:09 -08001325 bool frameLatched = layer->onPostComposition(glCompositionDoneFenceTime,
Brian Anderson4e606e32017-03-16 15:34:57 -07001326 retireFenceTime, compositorTiming);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001327 if (frameLatched) {
Robert Carr2047fae2016-11-28 14:09:09 -08001328 recordBufferingStats(layer->getName().string(),
1329 layer->getOccupancyHistory(false));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001330 }
Robert Carr2047fae2016-11-28 14:09:09 -08001331 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001332
Brian Anderson4e606e32017-03-16 15:34:57 -07001333 if (retireFence->isValid()) {
Brian Andersonfbc80ae2017-05-26 16:23:54 -07001334 if (mPrimaryDispSync.addPresentFence(retireFenceTime)) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001335 enableHardwareVsync();
1336 } else {
1337 disableHardwareVsync(false);
1338 }
1339 }
1340
Fabien Sanglardcbf153b2017-03-10 17:57:12 -08001341 if (!hasSyncFramework) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001342 if (hw->isDisplayOn()) {
1343 enableHardwareVsync();
1344 }
1345 }
1346
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001347 if (mAnimCompositionPending) {
1348 mAnimCompositionPending = false;
1349
Brian Anderson3d4039d2016-09-23 16:31:30 -07001350 if (retireFenceTime->isValid()) {
1351 mAnimFrameTracker.setActualPresentFence(std::move(retireFenceTime));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001352 } else {
1353 // The HWC doesn't support present fences, so use the refresh
1354 // timestamp instead.
1355 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY);
1356 mAnimFrameTracker.setActualPresentTime(presentTime);
1357 }
1358 mAnimFrameTracker.advanceFrame();
1359 }
1360
1361 if (hw->getPowerMode() == HWC_POWER_MODE_OFF) {
1362 return;
1363 }
1364
1365 nsecs_t currentTime = systemTime();
1366 if (mHasPoweredOff) {
1367 mHasPoweredOff = false;
1368 } else {
1369 nsecs_t period = mPrimaryDispSync.getPeriod();
1370 nsecs_t elapsedTime = currentTime - mLastSwapTime;
1371 size_t numPeriods = static_cast<size_t>(elapsedTime / period);
1372 if (numPeriods < NUM_BUCKETS - 1) {
1373 mFrameBuckets[numPeriods] += elapsedTime;
1374 } else {
1375 mFrameBuckets[NUM_BUCKETS - 1] += elapsedTime;
1376 }
1377 mTotalTime += elapsedTime;
1378 }
1379 mLastSwapTime = currentTime;
1380}
1381
1382void SurfaceFlinger::rebuildLayerStacks() {
1383 // rebuild the visible layer list per screen
1384 if (CC_UNLIKELY(mVisibleRegionsDirty)) {
1385 ATRACE_CALL();
1386 mVisibleRegionsDirty = false;
1387 invalidateHwcGeometry();
1388
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001389 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1390 Region opaqueRegion;
1391 Region dirtyRegion;
1392 Vector< sp<Layer> > layersSortedByZ;
1393 const sp<DisplayDevice>& hw(mDisplays[dpy]);
1394 const Transform& tr(hw->getTransform());
1395 const Rect bounds(hw->getBounds());
1396 if (hw->isDisplayOn()) {
Chia-I Wuab0c3192017-08-01 11:29:00 -07001397 computeVisibleRegions(hw, dirtyRegion, opaqueRegion);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001398
Robert Carr2047fae2016-11-28 14:09:09 -08001399 mDrawingState.traverseInZOrder([&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07001400 if (layer->getLayerStack() == hw->getLayerStack()) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001401 Region drawRegion(tr.transform(
1402 layer->visibleNonTransparentRegion));
1403 drawRegion.andSelf(bounds);
1404 if (!drawRegion.isEmpty()) {
1405 layersSortedByZ.add(layer);
1406 }
1407 }
Robert Carr2047fae2016-11-28 14:09:09 -08001408 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001409 }
1410 hw->setVisibleLayersSortedByZ(layersSortedByZ);
1411 hw->undefinedRegion.set(bounds);
1412 hw->undefinedRegion.subtractSelf(tr.transform(opaqueRegion));
1413 hw->dirtyRegion.orSelf(dirtyRegion);
1414 }
1415 }
1416}
1417
1418void SurfaceFlinger::setUpHWComposer() {
1419 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1420 bool dirty = !mDisplays[dpy]->getDirtyRegion(false).isEmpty();
1421 bool empty = mDisplays[dpy]->getVisibleLayersSortedByZ().size() == 0;
1422 bool wasEmpty = !mDisplays[dpy]->lastCompositionHadVisibleLayers;
1423
1424 // If nothing has changed (!dirty), don't recompose.
1425 // If something changed, but we don't currently have any visible layers,
1426 // and didn't when we last did a composition, then skip it this time.
1427 // The second rule does two things:
1428 // - When all layers are removed from a display, we'll emit one black
1429 // frame, then nothing more until we get new layers.
1430 // - When a display is created with a private layer stack, we won't
1431 // emit any black frames until a layer is added to the layer stack.
1432 bool mustRecompose = dirty && !(empty && wasEmpty);
1433
1434 ALOGV_IF(mDisplays[dpy]->getDisplayType() == DisplayDevice::DISPLAY_VIRTUAL,
1435 "dpy[%zu]: %s composition (%sdirty %sempty %swasEmpty)", dpy,
1436 mustRecompose ? "doing" : "skipping",
1437 dirty ? "+" : "-",
1438 empty ? "+" : "-",
1439 wasEmpty ? "+" : "-");
1440
1441 mDisplays[dpy]->beginFrame(mustRecompose);
1442
1443 if (mustRecompose) {
1444 mDisplays[dpy]->lastCompositionHadVisibleLayers = !empty;
1445 }
1446 }
1447
1448 HWComposer& hwc(getHwComposer());
1449 if (hwc.initCheck() == NO_ERROR) {
1450 // build the h/w work list
1451 if (CC_UNLIKELY(mHwWorkListDirty)) {
1452 mHwWorkListDirty = false;
1453 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1454 sp<const DisplayDevice> hw(mDisplays[dpy]);
1455 const int32_t id = hw->getHwcDisplayId();
1456 if (id >= 0) {
1457 const Vector< sp<Layer> >& currentLayers(
1458 hw->getVisibleLayersSortedByZ());
1459 const size_t count = currentLayers.size();
1460 if (hwc.createWorkList(id, count) == NO_ERROR) {
1461 HWComposer::LayerListIterator cur = hwc.begin(id);
1462 const HWComposer::LayerListIterator end = hwc.end(id);
1463 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1464 const sp<Layer>& layer(currentLayers[i]);
1465 layer->setGeometry(hw, *cur);
1466 if (mDebugDisableHWC || mDebugRegion || mDaltonize || mHasColorMatrix) {
1467 cur->setSkip(true);
1468 }
1469 }
1470 }
1471 }
1472 }
1473 }
1474
1475 // set the per-frame data
1476 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1477 sp<const DisplayDevice> hw(mDisplays[dpy]);
1478 const int32_t id = hw->getHwcDisplayId();
1479 if (id >= 0) {
1480 const Vector< sp<Layer> >& currentLayers(
1481 hw->getVisibleLayersSortedByZ());
1482 const size_t count = currentLayers.size();
1483 HWComposer::LayerListIterator cur = hwc.begin(id);
1484 const HWComposer::LayerListIterator end = hwc.end(id);
1485 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1486 /*
1487 * update the per-frame h/w composer data for each layer
1488 * and build the transparent region of the FB
1489 */
1490 const sp<Layer>& layer(currentLayers[i]);
1491 layer->setPerFrameData(hw, *cur);
1492 }
1493 }
1494 }
1495
1496 // If possible, attempt to use the cursor overlay on each display.
1497 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1498 sp<const DisplayDevice> hw(mDisplays[dpy]);
1499 const int32_t id = hw->getHwcDisplayId();
1500 if (id >= 0) {
1501 const Vector< sp<Layer> >& currentLayers(
1502 hw->getVisibleLayersSortedByZ());
1503 const size_t count = currentLayers.size();
1504 HWComposer::LayerListIterator cur = hwc.begin(id);
1505 const HWComposer::LayerListIterator end = hwc.end(id);
1506 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1507 const sp<Layer>& layer(currentLayers[i]);
1508 if (layer->isPotentialCursor()) {
1509 cur->setIsCursorLayerHint();
1510 break;
1511 }
1512 }
1513 }
1514 }
1515
1516 status_t err = hwc.prepare();
1517 ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
1518
1519 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1520 sp<const DisplayDevice> hw(mDisplays[dpy]);
1521 hw->prepareFrame(hwc);
1522 }
1523 }
1524}
1525
1526void SurfaceFlinger::doComposition() {
1527 ATRACE_CALL();
1528 const bool repaintEverything = android_atomic_and(0, &mRepaintEverything);
1529 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1530 const sp<DisplayDevice>& hw(mDisplays[dpy]);
1531 if (hw->isDisplayOn()) {
1532 // transform the dirty region into this screen's coordinate space
1533 const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
1534
1535 // repaint the framebuffer (if needed)
1536 doDisplayComposition(hw, dirtyRegion);
1537
1538 hw->dirtyRegion.clear();
1539 hw->flip(hw->swapRegion);
1540 hw->swapRegion.clear();
1541 }
1542 // inform the h/w that we're done compositing
1543 hw->compositionComplete();
1544 }
1545 postFramebuffer();
1546}
1547
1548void SurfaceFlinger::postFramebuffer()
1549{
1550 ATRACE_CALL();
1551
1552 const nsecs_t now = systemTime();
1553 mDebugInSwapBuffers = now;
1554
1555 HWComposer& hwc(getHwComposer());
1556 if (hwc.initCheck() == NO_ERROR) {
1557 if (!hwc.supportsFramebufferTarget()) {
1558 // EGL spec says:
1559 // "surface must be bound to the calling thread's current context,
1560 // for the current rendering API."
1561 getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
1562 }
1563 hwc.commit();
1564 }
1565
1566 // make the default display current because the VirtualDisplayDevice code cannot
1567 // deal with dequeueBuffer() being called outside of the composition loop; however
1568 // the code below can call glFlush() which is allowed (and does in some case) call
1569 // dequeueBuffer().
1570 getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
1571
1572 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1573 sp<const DisplayDevice> hw(mDisplays[dpy]);
1574 const Vector< sp<Layer> >& currentLayers(hw->getVisibleLayersSortedByZ());
1575 hw->onSwapBuffersCompleted(hwc);
1576 const size_t count = currentLayers.size();
1577 int32_t id = hw->getHwcDisplayId();
1578 if (id >=0 && hwc.initCheck() == NO_ERROR) {
1579 HWComposer::LayerListIterator cur = hwc.begin(id);
1580 const HWComposer::LayerListIterator end = hwc.end(id);
1581 for (size_t i = 0; cur != end && i < count; ++i, ++cur) {
1582 currentLayers[i]->onLayerDisplayed(hw, &*cur);
1583 }
1584 } else {
1585 for (size_t i = 0; i < count; i++) {
1586 currentLayers[i]->onLayerDisplayed(hw, NULL);
1587 }
1588 }
1589 }
1590
1591 mLastSwapBufferTime = systemTime() - now;
1592 mDebugInSwapBuffers = 0;
1593
1594 uint32_t flipCount = getDefaultDisplayDevice()->getPageFlipCount();
1595 if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
1596 logFrameStats();
1597 }
1598}
1599
1600void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
1601{
1602 ATRACE_CALL();
1603
1604 // here we keep a copy of the drawing state (that is the state that's
1605 // going to be overwritten by handleTransactionLocked()) outside of
1606 // mStateLock so that the side-effects of the State assignment
1607 // don't happen with mStateLock held (which can cause deadlocks).
1608 State drawingState(mDrawingState);
1609
1610 Mutex::Autolock _l(mStateLock);
1611 const nsecs_t now = systemTime();
1612 mDebugInTransaction = now;
1613
1614 // Here we're guaranteed that some transaction flags are set
1615 // so we can call handleTransactionLocked() unconditionally.
1616 // We call getTransactionFlags(), which will also clear the flags,
1617 // with mStateLock held to guarantee that mCurrentState won't change
1618 // until the transaction is committed.
1619
1620 transactionFlags = getTransactionFlags(eTransactionMask);
1621 handleTransactionLocked(transactionFlags);
1622
1623 mLastTransactionTime = systemTime() - now;
1624 mDebugInTransaction = 0;
1625 invalidateHwcGeometry();
1626 // here the transaction has been committed
1627}
1628
1629void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
1630{
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001631 // Notify all layers of available frames
Robert Carr2047fae2016-11-28 14:09:09 -08001632 mCurrentState.traverseInZOrder([](Layer* layer) {
1633 layer->notifyAvailableFrames();
1634 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001635
1636 /*
1637 * Traversal of the children
1638 * (perform the transaction for each of them if needed)
1639 */
1640
1641 if (transactionFlags & eTraversalNeeded) {
Robert Carr2047fae2016-11-28 14:09:09 -08001642 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001643 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
Robert Carr2047fae2016-11-28 14:09:09 -08001644 if (!trFlags) return;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001645
1646 const uint32_t flags = layer->doTransaction(0);
1647 if (flags & Layer::eVisibleRegion)
1648 mVisibleRegionsDirty = true;
Robert Carr2047fae2016-11-28 14:09:09 -08001649 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001650 }
1651
1652 /*
1653 * Perform display own transactions if needed
1654 */
1655
1656 if (transactionFlags & eDisplayTransactionNeeded) {
1657 // here we take advantage of Vector's copy-on-write semantics to
1658 // improve performance by skipping the transaction entirely when
1659 // know that the lists are identical
1660 const KeyedVector< wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
1661 const KeyedVector< wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
1662 if (!curr.isIdenticalTo(draw)) {
1663 mVisibleRegionsDirty = true;
1664 const size_t cc = curr.size();
1665 size_t dc = draw.size();
1666
1667 // find the displays that were removed
1668 // (ie: in drawing state but not in current state)
1669 // also handle displays that changed
1670 // (ie: displays that are in both lists)
1671 for (size_t i=0 ; i<dc ; i++) {
1672 const ssize_t j = curr.indexOfKey(draw.keyAt(i));
1673 if (j < 0) {
1674 // in drawing state but not in current state
1675 if (!draw[i].isMainDisplay()) {
1676 // Call makeCurrent() on the primary display so we can
1677 // be sure that nothing associated with this display
1678 // is current.
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001679 const sp<const DisplayDevice> defaultDisplay(getDefaultDisplayDeviceLocked());
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001680 defaultDisplay->makeCurrent(mEGLDisplay, mEGLContext);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001681 sp<DisplayDevice> hw(getDisplayDeviceLocked(draw.keyAt(i)));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001682 if (hw != NULL)
1683 hw->disconnect(getHwComposer());
1684 if (draw[i].type < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES)
1685 mEventThread->onHotplugReceived(draw[i].type, false);
1686 mDisplays.removeItem(draw.keyAt(i));
1687 } else {
1688 ALOGW("trying to remove the main display");
1689 }
1690 } else {
1691 // this display is in both lists. see if something changed.
1692 const DisplayDeviceState& state(curr[j]);
1693 const wp<IBinder>& display(curr.keyAt(j));
1694 const sp<IBinder> state_binder = IInterface::asBinder(state.surface);
1695 const sp<IBinder> draw_binder = IInterface::asBinder(draw[i].surface);
1696 if (state_binder != draw_binder) {
1697 // changing the surface is like destroying and
1698 // recreating the DisplayDevice, so we just remove it
1699 // from the drawing state, so that it get re-added
1700 // below.
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001701 sp<DisplayDevice> hw(getDisplayDeviceLocked(display));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001702 if (hw != NULL)
1703 hw->disconnect(getHwComposer());
1704 mDisplays.removeItem(display);
1705 mDrawingState.displays.removeItemsAt(i);
1706 dc--; i--;
1707 // at this point we must loop to the next item
1708 continue;
1709 }
1710
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001711 const sp<DisplayDevice> disp(getDisplayDeviceLocked(display));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001712 if (disp != NULL) {
1713 if (state.layerStack != draw[i].layerStack) {
1714 disp->setLayerStack(state.layerStack);
1715 }
1716 if ((state.orientation != draw[i].orientation)
1717 || (state.viewport != draw[i].viewport)
1718 || (state.frame != draw[i].frame))
1719 {
1720 disp->setProjection(state.orientation,
1721 state.viewport, state.frame);
1722 }
1723 if (state.width != draw[i].width || state.height != draw[i].height) {
1724 disp->setDisplaySize(state.width, state.height);
1725 }
1726 }
1727 }
1728 }
1729
1730 // find displays that were added
1731 // (ie: in current state but not in drawing state)
1732 for (size_t i=0 ; i<cc ; i++) {
1733 if (draw.indexOfKey(curr.keyAt(i)) < 0) {
1734 const DisplayDeviceState& state(curr[i]);
1735
1736 sp<DisplaySurface> dispSurface;
1737 sp<IGraphicBufferProducer> producer;
1738 sp<IGraphicBufferProducer> bqProducer;
1739 sp<IGraphicBufferConsumer> bqConsumer;
Mathias Agopian0556d792017-03-22 15:49:32 -07001740 BufferQueue::createBufferQueue(&bqProducer, &bqConsumer);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001741
1742 int32_t hwcDisplayId = -1;
1743 if (state.isVirtualDisplay()) {
1744 // Virtual displays without a surface are dormant:
1745 // they have external state (layer stack, projection,
1746 // etc.) but no internal state (i.e. a DisplayDevice).
1747 if (state.surface != NULL) {
1748
1749 int width = 0;
1750 int status = state.surface->query(
1751 NATIVE_WINDOW_WIDTH, &width);
1752 ALOGE_IF(status != NO_ERROR,
1753 "Unable to query width (%d)", status);
1754 int height = 0;
1755 status = state.surface->query(
1756 NATIVE_WINDOW_HEIGHT, &height);
1757 ALOGE_IF(status != NO_ERROR,
1758 "Unable to query height (%d)", status);
1759 if (mUseHwcVirtualDisplays &&
Fabien Sanglardc8e387e2017-03-10 10:30:28 -08001760 (SurfaceFlinger::maxVirtualDisplaySize == 0 ||
1761 (width <= static_cast<int>(SurfaceFlinger::maxVirtualDisplaySize) &&
1762 height <= static_cast<int>(SurfaceFlinger::maxVirtualDisplaySize)))) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001763 hwcDisplayId = allocateHwcDisplayId(state.type);
1764 }
1765
1766 sp<VirtualDisplaySurface> vds = new VirtualDisplaySurface(
1767 *mHwc, hwcDisplayId, state.surface,
1768 bqProducer, bqConsumer, state.displayName);
1769
1770 dispSurface = vds;
1771 producer = vds;
1772 }
1773 } else {
1774 ALOGE_IF(state.surface!=NULL,
1775 "adding a supported display, but rendering "
1776 "surface is provided (%p), ignoring it",
1777 state.surface.get());
1778 hwcDisplayId = allocateHwcDisplayId(state.type);
1779 // for supported (by hwc) displays we provide our
1780 // own rendering surface
1781 dispSurface = new FramebufferSurface(*mHwc, state.type,
1782 bqConsumer);
1783 producer = bqProducer;
1784 }
1785
1786 const wp<IBinder>& display(curr.keyAt(i));
1787 if (dispSurface != NULL) {
1788 sp<DisplayDevice> hw = new DisplayDevice(this,
1789 state.type, hwcDisplayId,
1790 mHwc->getFormat(hwcDisplayId), state.isSecure,
1791 display, dispSurface, producer,
Courtney Goeltzenleuchter4f20f9c2017-04-06 08:18:34 -06001792 mRenderEngine->getEGLConfig(), false);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001793 hw->setLayerStack(state.layerStack);
1794 hw->setProjection(state.orientation,
1795 state.viewport, state.frame);
1796 hw->setDisplayName(state.displayName);
1797 mDisplays.add(display, hw);
1798 if (state.isVirtualDisplay()) {
1799 if (hwcDisplayId >= 0) {
1800 mHwc->setVirtualDisplayProperties(hwcDisplayId,
1801 hw->getWidth(), hw->getHeight(),
1802 hw->getFormat());
1803 }
1804 } else {
1805 mEventThread->onHotplugReceived(state.type, true);
1806 }
1807 }
1808 }
1809 }
1810 }
1811 }
1812
1813 if (transactionFlags & (eTraversalNeeded|eDisplayTransactionNeeded)) {
1814 // The transform hint might have changed for some layers
1815 // (either because a display has changed, or because a layer
1816 // as changed).
1817 //
1818 // Walk through all the layers in currentLayers,
1819 // and update their transform hint.
1820 //
1821 // If a layer is visible only on a single display, then that
1822 // display is used to calculate the hint, otherwise we use the
1823 // default display.
1824 //
1825 // NOTE: we do this here, rather than in rebuildLayerStacks() so that
1826 // the hint is set before we acquire a buffer from the surface texture.
1827 //
1828 // NOTE: layer transactions have taken place already, so we use their
1829 // drawing state. However, SurfaceFlinger's own transaction has not
1830 // happened yet, so we must use the current state layer list
1831 // (soon to become the drawing state list).
1832 //
1833 sp<const DisplayDevice> disp;
1834 uint32_t currentlayerStack = 0;
Robert Carr2047fae2016-11-28 14:09:09 -08001835 bool first = true;
1836 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001837 // NOTE: we rely on the fact that layers are sorted by
1838 // layerStack first (so we don't have to traverse the list
1839 // of displays for every layer).
Robert Carr1f0a16a2016-10-24 16:27:39 -07001840 uint32_t layerStack = layer->getLayerStack();
Robert Carr2047fae2016-11-28 14:09:09 -08001841 if (first || currentlayerStack != layerStack) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001842 currentlayerStack = layerStack;
1843 // figure out if this layerstack is mirrored
1844 // (more than one display) if so, pick the default display,
1845 // if not, pick the only display it's on.
1846 disp.clear();
1847 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1848 sp<const DisplayDevice> hw(mDisplays[dpy]);
1849 if (hw->getLayerStack() == currentlayerStack) {
1850 if (disp == NULL) {
1851 disp = hw;
1852 } else {
1853 disp = NULL;
1854 break;
1855 }
1856 }
1857 }
1858 }
1859 if (disp == NULL) {
1860 // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
1861 // redraw after transform hint changes. See bug 8508397.
1862
1863 // could be null when this layer is using a layerStack
1864 // that is not visible on any display. Also can occur at
1865 // screen off/on times.
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001866 disp = getDefaultDisplayDeviceLocked();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001867 }
1868 layer->updateTransformHint(disp);
Robert Carr2047fae2016-11-28 14:09:09 -08001869
1870 first = false;
1871 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001872 }
1873
1874
1875 /*
1876 * Perform our own transaction if needed
1877 */
Robert Carr1f0a16a2016-10-24 16:27:39 -07001878
1879 if (mLayersAdded) {
1880 mLayersAdded = false;
1881 // Layers have been added.
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001882 mVisibleRegionsDirty = true;
1883 }
1884
1885 // some layers might have been removed, so
1886 // we need to update the regions they're exposing.
1887 if (mLayersRemoved) {
1888 mLayersRemoved = false;
1889 mVisibleRegionsDirty = true;
Robert Carr2047fae2016-11-28 14:09:09 -08001890 mDrawingState.traverseInZOrder([&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07001891 if (mLayersPendingRemoval.indexOf(layer) >= 0) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001892 // this layer is not visible anymore
1893 // TODO: we could traverse the tree from front to back and
1894 // compute the actual visible region
1895 // TODO: we could cache the transformed region
Robert Carr1f0a16a2016-10-24 16:27:39 -07001896 Region visibleReg;
1897 visibleReg.set(layer->computeScreenBounds());
Chia-I Wuab0c3192017-08-01 11:29:00 -07001898 invalidateLayerStack(layer, visibleReg);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001899 }
Robert Carr2047fae2016-11-28 14:09:09 -08001900 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001901 }
1902
1903 commitTransaction();
1904
1905 updateCursorAsync();
1906}
1907
1908void SurfaceFlinger::updateCursorAsync()
1909{
1910 HWComposer& hwc(getHwComposer());
1911 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1912 sp<const DisplayDevice> hw(mDisplays[dpy]);
1913 const int32_t id = hw->getHwcDisplayId();
1914 if (id < 0) {
1915 continue;
1916 }
1917 const Vector< sp<Layer> >& currentLayers(
1918 hw->getVisibleLayersSortedByZ());
1919 const size_t count = currentLayers.size();
1920 HWComposer::LayerListIterator cur = hwc.begin(id);
1921 const HWComposer::LayerListIterator end = hwc.end(id);
1922 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1923 if (cur->getCompositionType() != HWC_CURSOR_OVERLAY) {
1924 continue;
1925 }
1926 const sp<Layer>& layer(currentLayers[i]);
1927 Rect cursorPos = layer->getPosition(hw);
1928 hwc.setCursorPositionAsync(id, cursorPos);
1929 break;
1930 }
1931 }
1932}
1933
1934void SurfaceFlinger::commitTransaction()
1935{
1936 if (!mLayersPendingRemoval.isEmpty()) {
1937 // Notify removed layers now that they can't be drawn from
Robert Carr1f0a16a2016-10-24 16:27:39 -07001938 for (const auto& l : mLayersPendingRemoval) {
1939 recordBufferingStats(l->getName().string(),
1940 l->getOccupancyHistory(true));
1941 l->onRemoved();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001942 }
1943 mLayersPendingRemoval.clear();
1944 }
1945
1946 // If this transaction is part of a window animation then the next frame
1947 // we composite should be considered an animation as well.
1948 mAnimCompositionPending = mAnimTransactionPending;
1949
1950 mDrawingState = mCurrentState;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001951 mDrawingState.traverseInZOrder([](Layer* layer) {
1952 layer->commitChildList();
1953 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001954 mTransactionPending = false;
1955 mAnimTransactionPending = false;
1956 mTransactionCV.broadcast();
1957}
1958
Chia-I Wuab0c3192017-08-01 11:29:00 -07001959void SurfaceFlinger::computeVisibleRegions(const sp<const DisplayDevice>& displayDevice,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001960 Region& outDirtyRegion, Region& outOpaqueRegion)
1961{
1962 ATRACE_CALL();
1963
1964 Region aboveOpaqueLayers;
1965 Region aboveCoveredLayers;
1966 Region dirty;
1967
1968 outDirtyRegion.clear();
1969
Robert Carr2047fae2016-11-28 14:09:09 -08001970 mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001971 // start with the whole surface at its current location
1972 const Layer::State& s(layer->getDrawingState());
1973
1974 // only consider the layers on the given layer stack
Chia-I Wuab0c3192017-08-01 11:29:00 -07001975 if (layer->getLayerStack() != displayDevice->getLayerStack())
Robert Carr2047fae2016-11-28 14:09:09 -08001976 return;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001977
1978 /*
1979 * opaqueRegion: area of a surface that is fully opaque.
1980 */
1981 Region opaqueRegion;
1982
1983 /*
1984 * visibleRegion: area of a surface that is visible on screen
1985 * and not fully transparent. This is essentially the layer's
1986 * footprint minus the opaque regions above it.
1987 * Areas covered by a translucent surface are considered visible.
1988 */
1989 Region visibleRegion;
1990
1991 /*
1992 * coveredRegion: area of a surface that is covered by all
1993 * visible regions above it (which includes the translucent areas).
1994 */
1995 Region coveredRegion;
1996
1997 /*
1998 * transparentRegion: area of a surface that is hinted to be completely
1999 * transparent. This is only used to tell when the layer has no visible
2000 * non-transparent regions and can be removed from the layer list. It
2001 * does not affect the visibleRegion of this layer or any layers
2002 * beneath it. The hint may not be correct if apps don't respect the
2003 * SurfaceView restrictions (which, sadly, some don't).
2004 */
2005 Region transparentRegion;
2006
2007
2008 // handle hidden surfaces by setting the visible region to empty
2009 if (CC_LIKELY(layer->isVisible())) {
2010 const bool translucent = !layer->isOpaque(s);
Robert Carr1f0a16a2016-10-24 16:27:39 -07002011 Rect bounds(layer->computeScreenBounds());
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002012 visibleRegion.set(bounds);
Robert Carr1f0a16a2016-10-24 16:27:39 -07002013 Transform tr = layer->getTransform();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002014 if (!visibleRegion.isEmpty()) {
2015 // Remove the transparent area from the visible region
2016 if (translucent) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002017 if (tr.preserveRects()) {
2018 // transform the transparent region
2019 transparentRegion = tr.transform(s.activeTransparentRegion);
2020 } else {
2021 // transformation too complex, can't do the
2022 // transparent region optimization.
2023 transparentRegion.clear();
2024 }
2025 }
2026
2027 // compute the opaque region
Robert Carr1f0a16a2016-10-24 16:27:39 -07002028 const int32_t layerOrientation = tr.getOrientation();
chaviw13fdc492017-06-27 12:40:18 -07002029 if (layer->getAlpha()==1.0f && !translucent &&
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002030 ((layerOrientation & Transform::ROT_INVALID) == false)) {
2031 // the opaque region is the layer's footprint
2032 opaqueRegion = visibleRegion;
2033 }
2034 }
2035 }
2036
2037 // Clip the covered region to the visible region
2038 coveredRegion = aboveCoveredLayers.intersect(visibleRegion);
2039
2040 // Update aboveCoveredLayers for next (lower) layer
2041 aboveCoveredLayers.orSelf(visibleRegion);
2042
2043 // subtract the opaque region covered by the layers above us
2044 visibleRegion.subtractSelf(aboveOpaqueLayers);
2045
2046 // compute this layer's dirty region
2047 if (layer->contentDirty) {
2048 // we need to invalidate the whole region
2049 dirty = visibleRegion;
2050 // as well, as the old visible region
2051 dirty.orSelf(layer->visibleRegion);
2052 layer->contentDirty = false;
2053 } else {
2054 /* compute the exposed region:
2055 * the exposed region consists of two components:
2056 * 1) what's VISIBLE now and was COVERED before
2057 * 2) what's EXPOSED now less what was EXPOSED before
2058 *
2059 * note that (1) is conservative, we start with the whole
2060 * visible region but only keep what used to be covered by
2061 * something -- which mean it may have been exposed.
2062 *
2063 * (2) handles areas that were not covered by anything but got
2064 * exposed because of a resize.
2065 */
2066 const Region newExposed = visibleRegion - coveredRegion;
2067 const Region oldVisibleRegion = layer->visibleRegion;
2068 const Region oldCoveredRegion = layer->coveredRegion;
2069 const Region oldExposed = oldVisibleRegion - oldCoveredRegion;
2070 dirty = (visibleRegion&oldCoveredRegion) | (newExposed-oldExposed);
2071 }
2072 dirty.subtractSelf(aboveOpaqueLayers);
2073
2074 // accumulate to the screen dirty region
2075 outDirtyRegion.orSelf(dirty);
2076
2077 // Update aboveOpaqueLayers for next (lower) layer
2078 aboveOpaqueLayers.orSelf(opaqueRegion);
2079
2080 // Store the visible region in screen space
2081 layer->setVisibleRegion(visibleRegion);
2082 layer->setCoveredRegion(coveredRegion);
2083 layer->setVisibleNonTransparentRegion(
2084 visibleRegion.subtract(transparentRegion));
Robert Carr2047fae2016-11-28 14:09:09 -08002085 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002086
2087 outOpaqueRegion = aboveOpaqueLayers;
2088}
2089
Chia-I Wuab0c3192017-08-01 11:29:00 -07002090void SurfaceFlinger::invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty) {
2091 uint32_t layerStack = layer->getLayerStack();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002092 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
2093 const sp<DisplayDevice>& hw(mDisplays[dpy]);
2094 if (hw->getLayerStack() == layerStack) {
2095 hw->dirtyRegion.orSelf(dirty);
2096 }
2097 }
2098}
2099
2100bool SurfaceFlinger::handlePageFlip()
2101{
Brian Andersond6927fb2016-07-23 23:37:30 -07002102 nsecs_t latchTime = systemTime();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002103 Region dirtyRegion;
2104
2105 bool visibleRegions = false;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002106 bool frameQueued = false;
2107
2108 // Store the set of layers that need updates. This set must not change as
2109 // buffers are being latched, as this could result in a deadlock.
2110 // Example: Two producers share the same command stream and:
2111 // 1.) Layer 0 is latched
2112 // 2.) Layer 0 gets a new frame
2113 // 2.) Layer 1 gets a new frame
2114 // 3.) Layer 1 is latched.
2115 // Display is now waiting on Layer 1's frame, which is behind layer 0's
2116 // second frame. But layer 0's second frame could be waiting on display.
2117 Vector<Layer*> layersWithQueuedFrames;
Robert Carr2047fae2016-11-28 14:09:09 -08002118 mDrawingState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002119 if (layer->hasQueuedFrame()) {
2120 frameQueued = true;
2121 if (layer->shouldPresentNow(mPrimaryDispSync)) {
Robert Carr2047fae2016-11-28 14:09:09 -08002122 layersWithQueuedFrames.push_back(layer);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002123 } else {
2124 layer->useEmptyDamage();
2125 }
2126 } else {
2127 layer->useEmptyDamage();
2128 }
Robert Carr2047fae2016-11-28 14:09:09 -08002129 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002130 for (size_t i = 0, count = layersWithQueuedFrames.size() ; i<count ; i++) {
2131 Layer* layer = layersWithQueuedFrames[i];
Brian Andersond6927fb2016-07-23 23:37:30 -07002132 const Region dirty(layer->latchBuffer(visibleRegions, latchTime));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002133 layer->useSurfaceDamage();
Chia-I Wuab0c3192017-08-01 11:29:00 -07002134 invalidateLayerStack(layer, dirty);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002135 }
2136
2137 mVisibleRegionsDirty |= visibleRegions;
2138
2139 // If we will need to wake up at some time in the future to deal with a
2140 // queued frame that shouldn't be displayed during this vsync period, wake
2141 // up during the next vsync period to check again.
2142 if (frameQueued && layersWithQueuedFrames.empty()) {
2143 signalLayerUpdate();
2144 }
2145
2146 // Only continue with the refresh if there is actually new work to do
2147 return !layersWithQueuedFrames.empty();
2148}
2149
2150void SurfaceFlinger::invalidateHwcGeometry()
2151{
2152 mHwWorkListDirty = true;
2153}
2154
2155
2156void SurfaceFlinger::doDisplayComposition(const sp<const DisplayDevice>& hw,
2157 const Region& inDirtyRegion)
2158{
2159 // We only need to actually compose the display if:
2160 // 1) It is being handled by hardware composer, which may need this to
2161 // keep its virtual display state machine in sync, or
2162 // 2) There is work to be done (the dirty region isn't empty)
2163 bool isHwcDisplay = hw->getHwcDisplayId() >= 0;
2164 if (!isHwcDisplay && inDirtyRegion.isEmpty()) {
2165 return;
2166 }
2167
2168 Region dirtyRegion(inDirtyRegion);
2169
2170 // compute the invalid region
2171 hw->swapRegion.orSelf(dirtyRegion);
2172
2173 uint32_t flags = hw->getFlags();
2174 if (flags & DisplayDevice::SWAP_RECTANGLE) {
2175 // we can redraw only what's dirty, but since SWAP_RECTANGLE only
2176 // takes a rectangle, we must make sure to update that whole
2177 // rectangle in that case
2178 dirtyRegion.set(hw->swapRegion.bounds());
2179 } else {
2180 if (flags & DisplayDevice::PARTIAL_UPDATES) {
2181 // We need to redraw the rectangle that will be updated
2182 // (pushed to the framebuffer).
2183 // This is needed because PARTIAL_UPDATES only takes one
2184 // rectangle instead of a region (see DisplayDevice::flip())
2185 dirtyRegion.set(hw->swapRegion.bounds());
2186 } else {
2187 // we need to redraw everything (the whole screen)
2188 dirtyRegion.set(hw->bounds());
2189 hw->swapRegion = dirtyRegion;
2190 }
2191 }
2192
2193 if (CC_LIKELY(!mDaltonize && !mHasColorMatrix)) {
2194 if (!doComposeSurfaces(hw, dirtyRegion)) return;
2195 } else {
2196 RenderEngine& engine(getRenderEngine());
2197 mat4 colorMatrix = mColorMatrix;
2198 if (mDaltonize) {
2199 colorMatrix = colorMatrix * mDaltonizer();
2200 }
2201 mat4 oldMatrix = engine.setupColorTransform(colorMatrix);
2202 doComposeSurfaces(hw, dirtyRegion);
2203 engine.setupColorTransform(oldMatrix);
2204 }
2205
2206 // update the swap region and clear the dirty region
2207 hw->swapRegion.orSelf(dirtyRegion);
2208
2209 // swap buffers (presentation)
2210 hw->swapBuffers(getHwComposer());
2211}
2212
2213bool SurfaceFlinger::doComposeSurfaces(const sp<const DisplayDevice>& hw, const Region& dirty)
2214{
chaviwa76b2712017-09-20 12:02:26 -07002215 DisplayRenderArea renderArea(hw);
2216
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002217 RenderEngine& engine(getRenderEngine());
2218 const int32_t id = hw->getHwcDisplayId();
2219 HWComposer& hwc(getHwComposer());
2220 HWComposer::LayerListIterator cur = hwc.begin(id);
2221 const HWComposer::LayerListIterator end = hwc.end(id);
2222
2223 bool hasGlesComposition = hwc.hasGlesComposition(id);
2224 if (hasGlesComposition) {
2225 if (!hw->makeCurrent(mEGLDisplay, mEGLContext)) {
2226 ALOGW("DisplayDevice::makeCurrent failed. Aborting surface composition for display %s",
2227 hw->getDisplayName().string());
2228 eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
2229 if(!getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext)) {
2230 ALOGE("DisplayDevice::makeCurrent on default display failed. Aborting.");
2231 }
2232 return false;
2233 }
2234
2235 // Never touch the framebuffer if we don't have any framebuffer layers
2236 const bool hasHwcComposition = hwc.hasHwcComposition(id);
2237 if (hasHwcComposition) {
2238 // when using overlays, we assume a fully transparent framebuffer
2239 // NOTE: we could reduce how much we need to clear, for instance
2240 // remove where there are opaque FB layers. however, on some
2241 // GPUs doing a "clean slate" clear might be more efficient.
2242 // We'll revisit later if needed.
2243 engine.clearWithColor(0, 0, 0, 0);
2244 } else {
2245 // we start with the whole screen area
2246 const Region bounds(hw->getBounds());
2247
2248 // we remove the scissor part
2249 // we're left with the letterbox region
2250 // (common case is that letterbox ends-up being empty)
2251 const Region letterbox(bounds.subtract(hw->getScissor()));
2252
2253 // compute the area to clear
2254 Region region(hw->undefinedRegion.merge(letterbox));
2255
2256 // but limit it to the dirty region
2257 region.andSelf(dirty);
2258
2259 // screen is already cleared here
2260 if (!region.isEmpty()) {
2261 // can happen with SurfaceView
2262 drawWormhole(hw, region);
2263 }
2264 }
2265
2266 if (hw->getDisplayType() != DisplayDevice::DISPLAY_PRIMARY) {
2267 // just to be on the safe side, we don't set the
2268 // scissor on the main display. It should never be needed
2269 // anyways (though in theory it could since the API allows it).
2270 const Rect& bounds(hw->getBounds());
2271 const Rect& scissor(hw->getScissor());
2272 if (scissor != bounds) {
2273 // scissor doesn't match the screen's dimensions, so we
2274 // need to clear everything outside of it and enable
2275 // the GL scissor so we don't draw anything where we shouldn't
2276
2277 // enable scissor for this frame
2278 const uint32_t height = hw->getHeight();
2279 engine.setScissor(scissor.left, height - scissor.bottom,
2280 scissor.getWidth(), scissor.getHeight());
2281 }
2282 }
2283 }
2284
2285 /*
2286 * and then, render the layers targeted at the framebuffer
2287 */
2288
2289 const Vector< sp<Layer> >& layers(hw->getVisibleLayersSortedByZ());
2290 const size_t count = layers.size();
2291 const Transform& tr = hw->getTransform();
2292 if (cur != end) {
2293 // we're using h/w composer
2294 for (size_t i=0 ; i<count && cur!=end ; ++i, ++cur) {
2295 const sp<Layer>& layer(layers[i]);
2296 const Region clip(dirty.intersect(tr.transform(layer->visibleRegion)));
2297 if (!clip.isEmpty()) {
2298 switch (cur->getCompositionType()) {
2299 case HWC_CURSOR_OVERLAY:
2300 case HWC_OVERLAY: {
2301 const Layer::State& state(layer->getDrawingState());
2302 if ((cur->getHints() & HWC_HINT_CLEAR_FB)
2303 && i
chaviw13fdc492017-06-27 12:40:18 -07002304 && layer->isOpaque(state) && (state.color.a == 1.0f)
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002305 && hasGlesComposition) {
2306 // never clear the very first layer since we're
2307 // guaranteed the FB is already cleared
chaviwa76b2712017-09-20 12:02:26 -07002308 layer->clearWithOpenGL(renderArea);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002309 }
2310 break;
2311 }
2312 case HWC_FRAMEBUFFER: {
chaviwa76b2712017-09-20 12:02:26 -07002313 layer->draw(renderArea, clip);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002314 break;
2315 }
2316 case HWC_FRAMEBUFFER_TARGET: {
2317 // this should not happen as the iterator shouldn't
2318 // let us get there.
2319 ALOGW("HWC_FRAMEBUFFER_TARGET found in hwc list (index=%zu)", i);
2320 break;
2321 }
2322 }
2323 }
2324 layer->setAcquireFence(hw, *cur);
2325 }
2326 } else {
2327 // we're not using h/w composer
2328 for (size_t i=0 ; i<count ; ++i) {
2329 const sp<Layer>& layer(layers[i]);
2330 const Region clip(dirty.intersect(
2331 tr.transform(layer->visibleRegion)));
2332 if (!clip.isEmpty()) {
chaviwa76b2712017-09-20 12:02:26 -07002333 layer->draw(renderArea, clip);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002334 }
2335 }
2336 }
2337
2338 // disable scissor at the end of the frame
2339 engine.disableScissor();
2340 return true;
2341}
2342
2343void SurfaceFlinger::drawWormhole(const sp<const DisplayDevice>& hw, const Region& region) const {
2344 const int32_t height = hw->getHeight();
2345 RenderEngine& engine(getRenderEngine());
2346 engine.fillRegionWithColor(region, height, 0, 0, 0, 0);
2347}
2348
2349status_t SurfaceFlinger::addClientLayer(const sp<Client>& client,
2350 const sp<IBinder>& handle,
2351 const sp<IGraphicBufferProducer>& gbc,
Robert Carr1f0a16a2016-10-24 16:27:39 -07002352 const sp<Layer>& lbc,
2353 const sp<Layer>& parent)
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002354{
2355 // add this layer to the current state list
2356 {
2357 Mutex::Autolock _l(mStateLock);
Robert Carr1f0a16a2016-10-24 16:27:39 -07002358 if (mNumLayers >= MAX_LAYERS) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002359 return NO_MEMORY;
2360 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07002361 if (parent == nullptr) {
2362 mCurrentState.layersSortedByZ.add(lbc);
2363 } else {
Chia-I Wufae51c42017-06-15 12:53:59 -07002364 if (mCurrentState.layersSortedByZ.indexOf(parent) < 0) {
2365 ALOGE("addClientLayer called with a removed parent");
2366 return NAME_NOT_FOUND;
2367 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07002368 parent->addChild(lbc);
2369 }
Chia-I Wufae51c42017-06-15 12:53:59 -07002370
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002371 mGraphicBufferProducerList.add(IInterface::asBinder(gbc));
Robert Carr1f0a16a2016-10-24 16:27:39 -07002372 mLayersAdded = true;
2373 mNumLayers++;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002374 }
2375
2376 // attach this layer to the client
2377 client->attachLayer(handle, lbc);
2378
2379 return NO_ERROR;
2380}
2381
Chia-I Wu515dc9c2017-06-15 12:53:59 -07002382status_t SurfaceFlinger::removeLayer(const sp<Layer>& layer, bool topLevelOnly) {
Robert Carr7f9b8992017-03-10 11:08:39 -08002383 Mutex::Autolock _l(mStateLock);
2384
Robert Carr1f0a16a2016-10-24 16:27:39 -07002385 const auto& p = layer->getParent();
Chia-I Wu515dc9c2017-06-15 12:53:59 -07002386 ssize_t index;
2387 if (p != nullptr) {
2388 if (topLevelOnly) {
2389 return NO_ERROR;
2390 }
2391
Chia-I Wufae51c42017-06-15 12:53:59 -07002392 sp<Layer> ancestor = p;
2393 while (ancestor->getParent() != nullptr) {
2394 ancestor = ancestor->getParent();
2395 }
2396 if (mCurrentState.layersSortedByZ.indexOf(ancestor) < 0) {
2397 ALOGE("removeLayer called with a layer whose parent has been removed");
2398 return NAME_NOT_FOUND;
2399 }
2400
Chia-I Wu515dc9c2017-06-15 12:53:59 -07002401 index = p->removeChild(layer);
2402 } else {
2403 index = mCurrentState.layersSortedByZ.remove(layer);
2404 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07002405
Robert Carr136e2f62017-02-08 17:54:29 -08002406 // As a matter of normal operation, the LayerCleaner will produce a second
2407 // attempt to remove the surface. The Layer will be kept alive in mDrawingState
2408 // so we will succeed in promoting it, but it's already been removed
2409 // from mCurrentState. As long as we can find it in mDrawingState we have no problem
2410 // otherwise something has gone wrong and we are leaking the layer.
2411 if (index < 0 && mDrawingState.layersSortedByZ.indexOf(layer) < 0) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07002412 ALOGE("Failed to find layer (%s) in layer parent (%s).",
2413 layer->getName().string(),
2414 (p != nullptr) ? p->getName().string() : "no-parent");
2415 return BAD_VALUE;
Robert Carr136e2f62017-02-08 17:54:29 -08002416 } else if (index < 0) {
2417 return NO_ERROR;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002418 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07002419
Chia-I Wuc6657022017-08-15 11:18:17 -07002420 layer->onRemovedFromCurrentState();
Robert Carr1f0a16a2016-10-24 16:27:39 -07002421 mLayersPendingRemoval.add(layer);
2422 mLayersRemoved = true;
Chia-I Wufae51c42017-06-15 12:53:59 -07002423 mNumLayers -= 1 + layer->getChildrenCount();
Robert Carr1f0a16a2016-10-24 16:27:39 -07002424 setTransactionFlags(eTransactionNeeded);
2425 return NO_ERROR;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002426}
2427
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08002428uint32_t SurfaceFlinger::peekTransactionFlags() {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002429 return android_atomic_release_load(&mTransactionFlags);
2430}
2431
2432uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) {
2433 return android_atomic_and(~flags, &mTransactionFlags) & flags;
2434}
2435
2436uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) {
2437 uint32_t old = android_atomic_or(flags, &mTransactionFlags);
2438 if ((old & flags)==0) { // wake the server up
2439 signalTransaction();
2440 }
2441 return old;
2442}
2443
2444void SurfaceFlinger::setTransactionState(
2445 const Vector<ComposerState>& state,
2446 const Vector<DisplayState>& displays,
2447 uint32_t flags)
2448{
2449 ATRACE_CALL();
2450 Mutex::Autolock _l(mStateLock);
2451 uint32_t transactionFlags = 0;
2452
2453 if (flags & eAnimation) {
2454 // For window updates that are part of an animation we must wait for
2455 // previous animation "frames" to be handled.
2456 while (mAnimTransactionPending) {
2457 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
2458 if (CC_UNLIKELY(err != NO_ERROR)) {
2459 // just in case something goes wrong in SF, return to the
2460 // caller after a few seconds.
2461 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out "
2462 "waiting for previous animation frame");
2463 mAnimTransactionPending = false;
2464 break;
2465 }
2466 }
2467 }
2468
2469 size_t count = displays.size();
2470 for (size_t i=0 ; i<count ; i++) {
2471 const DisplayState& s(displays[i]);
2472 transactionFlags |= setDisplayStateLocked(s);
2473 }
2474
2475 count = state.size();
2476 for (size_t i=0 ; i<count ; i++) {
2477 const ComposerState& s(state[i]);
2478 // Here we need to check that the interface we're given is indeed
2479 // one of our own. A malicious client could give us a NULL
2480 // IInterface, or one of its own or even one of our own but a
2481 // different type. All these situations would cause us to crash.
2482 //
2483 // NOTE: it would be better to use RTTI as we could directly check
2484 // that we have a Client*. however, RTTI is disabled in Android.
2485 if (s.client != NULL) {
2486 sp<IBinder> binder = IInterface::asBinder(s.client);
2487 if (binder != NULL) {
Fabien Sanglard45b20252017-01-18 16:43:18 -08002488 if (binder->queryLocalInterface(ISurfaceComposerClient::descriptor) != NULL) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002489 sp<Client> client( static_cast<Client *>(s.client.get()) );
2490 transactionFlags |= setClientStateLocked(client, s.state);
2491 }
2492 }
2493 }
2494 }
2495
2496 // If a synchronous transaction is explicitly requested without any changes,
2497 // force a transaction anyway. This can be used as a flush mechanism for
2498 // previous async transactions.
2499 if (transactionFlags == 0 && (flags & eSynchronous)) {
2500 transactionFlags = eTransactionNeeded;
2501 }
2502
2503 if (transactionFlags) {
2504 if (mInterceptor.isEnabled()) {
2505 mInterceptor.saveTransaction(state, mCurrentState.displays, displays, flags);
2506 }
2507
2508 // this triggers the transaction
2509 setTransactionFlags(transactionFlags);
2510
2511 // if this is a synchronous transaction, wait for it to take effect
2512 // before returning.
2513 if (flags & eSynchronous) {
2514 mTransactionPending = true;
2515 }
2516 if (flags & eAnimation) {
2517 mAnimTransactionPending = true;
2518 }
2519 while (mTransactionPending) {
2520 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
2521 if (CC_UNLIKELY(err != NO_ERROR)) {
2522 // just in case something goes wrong in SF, return to the
2523 // called after a few seconds.
2524 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");
2525 mTransactionPending = false;
2526 break;
2527 }
2528 }
2529 }
2530}
2531
2532uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s)
2533{
2534 ssize_t dpyIdx = mCurrentState.displays.indexOfKey(s.token);
2535 if (dpyIdx < 0)
2536 return 0;
2537
2538 uint32_t flags = 0;
2539 DisplayDeviceState& disp(mCurrentState.displays.editValueAt(dpyIdx));
2540 if (disp.isValid()) {
2541 const uint32_t what = s.what;
2542 if (what & DisplayState::eSurfaceChanged) {
2543 if (IInterface::asBinder(disp.surface) != IInterface::asBinder(s.surface)) {
2544 disp.surface = s.surface;
2545 flags |= eDisplayTransactionNeeded;
2546 }
2547 }
2548 if (what & DisplayState::eLayerStackChanged) {
2549 if (disp.layerStack != s.layerStack) {
2550 disp.layerStack = s.layerStack;
2551 flags |= eDisplayTransactionNeeded;
2552 }
2553 }
2554 if (what & DisplayState::eDisplayProjectionChanged) {
2555 if (disp.orientation != s.orientation) {
2556 disp.orientation = s.orientation;
2557 flags |= eDisplayTransactionNeeded;
2558 }
2559 if (disp.frame != s.frame) {
2560 disp.frame = s.frame;
2561 flags |= eDisplayTransactionNeeded;
2562 }
2563 if (disp.viewport != s.viewport) {
2564 disp.viewport = s.viewport;
2565 flags |= eDisplayTransactionNeeded;
2566 }
2567 }
2568 if (what & DisplayState::eDisplaySizeChanged) {
2569 if (disp.width != s.width) {
2570 disp.width = s.width;
2571 flags |= eDisplayTransactionNeeded;
2572 }
2573 if (disp.height != s.height) {
2574 disp.height = s.height;
2575 flags |= eDisplayTransactionNeeded;
2576 }
2577 }
2578 }
2579 return flags;
2580}
2581
2582uint32_t SurfaceFlinger::setClientStateLocked(
2583 const sp<Client>& client,
2584 const layer_state_t& s)
2585{
2586 uint32_t flags = 0;
2587 sp<Layer> layer(client->getLayerUser(s.surface));
2588 if (layer != 0) {
2589 const uint32_t what = s.what;
2590 bool geometryAppliesWithResize =
2591 what & layer_state_t::eGeometryAppliesWithResize;
2592 if (what & layer_state_t::ePositionChanged) {
2593 if (layer->setPosition(s.x, s.y, !geometryAppliesWithResize)) {
2594 flags |= eTraversalNeeded;
2595 }
2596 }
2597 if (what & layer_state_t::eLayerChanged) {
2598 // NOTE: index needs to be calculated before we update the state
Robert Carr1f0a16a2016-10-24 16:27:39 -07002599 const auto& p = layer->getParent();
2600 if (p == nullptr) {
2601 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
2602 if (layer->setLayer(s.z) && idx >= 0) {
2603 mCurrentState.layersSortedByZ.removeAt(idx);
2604 mCurrentState.layersSortedByZ.add(layer);
2605 // we need traversal (state changed)
2606 // AND transaction (list changed)
2607 flags |= eTransactionNeeded|eTraversalNeeded;
2608 }
2609 } else {
2610 if (p->setChildLayer(layer, s.z)) {
2611 flags |= eTransactionNeeded|eTraversalNeeded;
2612 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002613 }
2614 }
chaviw64f7b422017-07-12 10:31:58 -07002615 if (what & layer_state_t::eRelativeLayerChanged) {
2616 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
2617 if (layer->setRelativeLayer(s.relativeLayerHandle, s.z)) {
2618 mCurrentState.layersSortedByZ.removeAt(idx);
2619 mCurrentState.layersSortedByZ.add(layer);
2620 flags |= eTransactionNeeded|eTraversalNeeded;
2621 }
2622 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002623 if (what & layer_state_t::eSizeChanged) {
2624 if (layer->setSize(s.w, s.h)) {
2625 flags |= eTraversalNeeded;
2626 }
2627 }
2628 if (what & layer_state_t::eAlphaChanged) {
chaviw13fdc492017-06-27 12:40:18 -07002629 if (layer->setAlpha(s.alpha))
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002630 flags |= eTraversalNeeded;
2631 }
chaviw13fdc492017-06-27 12:40:18 -07002632 if (what & layer_state_t::eColorChanged) {
2633 if (layer->setColor(s.color)) {
2634 flags |= eTraversalNeeded;
2635 }
2636 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002637 if (what & layer_state_t::eMatrixChanged) {
2638 if (layer->setMatrix(s.matrix))
2639 flags |= eTraversalNeeded;
2640 }
2641 if (what & layer_state_t::eTransparentRegionChanged) {
2642 if (layer->setTransparentRegionHint(s.transparentRegion))
2643 flags |= eTraversalNeeded;
2644 }
2645 if (what & layer_state_t::eFlagsChanged) {
2646 if (layer->setFlags(s.flags, s.mask))
2647 flags |= eTraversalNeeded;
2648 }
2649 if (what & layer_state_t::eCropChanged) {
2650 if (layer->setCrop(s.crop, !geometryAppliesWithResize))
2651 flags |= eTraversalNeeded;
2652 }
2653 if (what & layer_state_t::eFinalCropChanged) {
Robert Carr6fb9ca72017-03-22 18:23:23 -07002654 if (layer->setFinalCrop(s.finalCrop, !geometryAppliesWithResize))
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002655 flags |= eTraversalNeeded;
2656 }
2657 if (what & layer_state_t::eLayerStackChanged) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002658 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
Robert Carr1f0a16a2016-10-24 16:27:39 -07002659 // We only allow setting layer stacks for top level layers,
2660 // everything else inherits layer stack from its parent.
2661 if (layer->hasParent()) {
2662 ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
2663 layer->getName().string());
2664 } else if (idx < 0) {
2665 ALOGE("Attempt to set layer stack on layer without parent (%s) that "
2666 "that also does not appear in the top level layer list. Something"
2667 " has gone wrong.", layer->getName().string());
2668 } else if (layer->setLayerStack(s.layerStack)) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002669 mCurrentState.layersSortedByZ.removeAt(idx);
2670 mCurrentState.layersSortedByZ.add(layer);
2671 // we need traversal (state changed)
2672 // AND transaction (list changed)
2673 flags |= eTransactionNeeded|eTraversalNeeded;
2674 }
2675 }
2676 if (what & layer_state_t::eDeferTransaction) {
Robert Carr0d480722017-01-10 16:42:54 -08002677 if (s.barrierHandle != nullptr) {
2678 layer->deferTransactionUntil(s.barrierHandle, s.frameNumber);
2679 } else if (s.barrierGbp != nullptr) {
2680 const sp<IGraphicBufferProducer>& gbp = s.barrierGbp;
2681 if (authenticateSurfaceTextureLocked(gbp)) {
2682 const auto& otherLayer =
2683 (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
2684 layer->deferTransactionUntil(otherLayer, s.frameNumber);
2685 } else {
2686 ALOGE("Attempt to defer transaction to to an"
2687 " unrecognized GraphicBufferProducer");
2688 }
2689 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002690 // We don't trigger a traversal here because if no other state is
2691 // changed, we don't want this to cause any more work
2692 }
chaviwf1961f72017-09-18 16:41:07 -07002693 if (what & layer_state_t::eReparent) {
2694 if (layer->reparent(s.parentHandleForChild)) {
chaviw06178942017-07-27 10:25:59 -07002695 flags |= eTransactionNeeded|eTraversalNeeded;
2696 }
2697 }
Robert Carr1db73f62016-12-21 12:58:51 -08002698 if (what & layer_state_t::eReparentChildren) {
2699 if (layer->reparentChildren(s.reparentHandle)) {
2700 flags |= eTransactionNeeded|eTraversalNeeded;
2701 }
2702 }
Robert Carr9524cb32017-02-13 11:32:32 -08002703 if (what & layer_state_t::eDetachChildren) {
2704 layer->detachChildren();
2705 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002706 if (what & layer_state_t::eOverrideScalingModeChanged) {
2707 layer->setOverrideScalingMode(s.overrideScalingMode);
2708 // We don't trigger a traversal here because if no other state is
2709 // changed, we don't want this to cause any more work
2710 }
2711 }
2712 return flags;
2713}
2714
2715status_t SurfaceFlinger::createLayer(
2716 const String8& name,
2717 const sp<Client>& client,
2718 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
Albert Chaulk479c60c2017-01-27 14:21:34 -05002719 uint32_t windowType, uint32_t ownerUid, sp<IBinder>* handle,
2720 sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent)
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002721{
2722 if (int32_t(w|h) < 0) {
2723 ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
2724 int(w), int(h));
2725 return BAD_VALUE;
2726 }
2727
2728 status_t result = NO_ERROR;
2729
2730 sp<Layer> layer;
2731
Cody Northropbc755282017-03-31 12:00:08 -06002732 String8 uniqueName = getUniqueLayerName(name);
2733
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002734 switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
2735 case ISurfaceComposerClient::eFXSurfaceNormal:
2736 result = createNormalLayer(client,
Cody Northropbc755282017-03-31 12:00:08 -06002737 uniqueName, w, h, flags, format,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002738 handle, gbp, &layer);
2739 break;
chaviw13fdc492017-06-27 12:40:18 -07002740 case ISurfaceComposerClient::eFXSurfaceColor:
2741 result = createColorLayer(client,
Cody Northropbc755282017-03-31 12:00:08 -06002742 uniqueName, w, h, flags,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002743 handle, gbp, &layer);
2744 break;
2745 default:
2746 result = BAD_VALUE;
2747 break;
2748 }
2749
2750 if (result != NO_ERROR) {
2751 return result;
2752 }
2753
Albert Chaulk479c60c2017-01-27 14:21:34 -05002754 layer->setInfo(windowType, ownerUid);
2755
Robert Carr1f0a16a2016-10-24 16:27:39 -07002756 result = addClientLayer(client, *handle, *gbp, layer, *parent);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002757 if (result != NO_ERROR) {
2758 return result;
2759 }
2760 mInterceptor.saveSurfaceCreation(layer);
2761
2762 setTransactionFlags(eTransactionNeeded);
2763 return result;
2764}
2765
Cody Northropbc755282017-03-31 12:00:08 -06002766String8 SurfaceFlinger::getUniqueLayerName(const String8& name)
2767{
2768 bool matchFound = true;
2769 uint32_t dupeCounter = 0;
2770
2771 // Tack on our counter whether there is a hit or not, so everyone gets a tag
2772 String8 uniqueName = name + "#" + String8(std::to_string(dupeCounter).c_str());
2773
2774 // Loop over layers until we're sure there is no matching name
2775 while (matchFound) {
2776 matchFound = false;
2777 mDrawingState.traverseInZOrder([&](Layer* layer) {
2778 if (layer->getName() == uniqueName) {
2779 matchFound = true;
2780 uniqueName = name + "#" + String8(std::to_string(++dupeCounter).c_str());
2781 }
2782 });
2783 }
2784
2785 ALOGD_IF(dupeCounter > 0, "duplicate layer name: changing %s to %s", name.c_str(), uniqueName.c_str());
2786
2787 return uniqueName;
2788}
2789
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002790status_t SurfaceFlinger::createNormalLayer(const sp<Client>& client,
2791 const String8& name, uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
2792 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
2793{
2794 // initialize the surfaces
2795 switch (format) {
2796 case PIXEL_FORMAT_TRANSPARENT:
2797 case PIXEL_FORMAT_TRANSLUCENT:
2798 format = PIXEL_FORMAT_RGBA_8888;
2799 break;
2800 case PIXEL_FORMAT_OPAQUE:
2801 format = PIXEL_FORMAT_RGBX_8888;
2802 break;
2803 }
2804
2805 *outLayer = new Layer(this, client, name, w, h, flags);
2806 status_t err = (*outLayer)->setBuffers(w, h, format, flags);
2807 if (err == NO_ERROR) {
2808 *handle = (*outLayer)->getHandle();
2809 *gbp = (*outLayer)->getProducer();
2810 }
2811
2812 ALOGE_IF(err, "createNormalLayer() failed (%s)", strerror(-err));
2813 return err;
2814}
2815
chaviw13fdc492017-06-27 12:40:18 -07002816status_t SurfaceFlinger::createColorLayer(const sp<Client>& client,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002817 const String8& name, uint32_t w, uint32_t h, uint32_t flags,
2818 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
2819{
chaviw13fdc492017-06-27 12:40:18 -07002820 *outLayer = new ColorLayer(this, client, name, w, h, flags);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002821 *handle = (*outLayer)->getHandle();
2822 *gbp = (*outLayer)->getProducer();
2823 return NO_ERROR;
2824}
2825
2826status_t SurfaceFlinger::onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle)
2827{
Robert Carr9524cb32017-02-13 11:32:32 -08002828 // called by a client when it wants to remove a Layer
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002829 status_t err = NO_ERROR;
2830 sp<Layer> l(client->getLayerUser(handle));
2831 if (l != NULL) {
2832 mInterceptor.saveSurfaceDeletion(l);
2833 err = removeLayer(l);
2834 ALOGE_IF(err<0 && err != NAME_NOT_FOUND,
2835 "error removing layer=%p (%s)", l.get(), strerror(-err));
2836 }
2837 return err;
2838}
2839
2840status_t SurfaceFlinger::onLayerDestroyed(const wp<Layer>& layer)
2841{
2842 // called by ~LayerCleaner() when all references to the IBinder (handle)
2843 // are gone
Robert Carr9524cb32017-02-13 11:32:32 -08002844 sp<Layer> l = layer.promote();
2845 if (l == nullptr) {
2846 // The layer has already been removed, carry on
2847 return NO_ERROR;
Robert Carr9524cb32017-02-13 11:32:32 -08002848 }
Chia-I Wu515dc9c2017-06-15 12:53:59 -07002849 // If we have a parent, then we can continue to live as long as it does.
2850 return removeLayer(l, true);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002851}
2852
2853// ---------------------------------------------------------------------------
2854
2855void SurfaceFlinger::onInitializeDisplays() {
2856 // reset screen orientation and use primary layer stack
2857 Vector<ComposerState> state;
2858 Vector<DisplayState> displays;
2859 DisplayState d;
2860 d.what = DisplayState::eDisplayProjectionChanged |
2861 DisplayState::eLayerStackChanged;
2862 d.token = mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY];
2863 d.layerStack = 0;
2864 d.orientation = DisplayState::eOrientationDefault;
2865 d.frame.makeInvalid();
2866 d.viewport.makeInvalid();
2867 d.width = 0;
2868 d.height = 0;
2869 displays.add(d);
2870 setTransactionState(state, displays, 0);
2871 setPowerModeInternal(getDisplayDevice(d.token), HWC_POWER_MODE_NORMAL);
2872
2873 const nsecs_t period =
2874 getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
2875 mAnimFrameTracker.setDisplayRefreshPeriod(period);
Brian Andersond0010582017-03-07 13:20:31 -08002876
2877 // Use phase of 0 since phase is not known.
2878 // Use latency of 0, which will snap to the ideal latency.
2879 setCompositorTimingSnapped(0, period, 0);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002880}
2881
2882void SurfaceFlinger::initializeDisplays() {
2883 class MessageScreenInitialized : public MessageBase {
2884 SurfaceFlinger* flinger;
2885 public:
2886 explicit MessageScreenInitialized(SurfaceFlinger* flinger) : flinger(flinger) { }
2887 virtual bool handler() {
2888 flinger->onInitializeDisplays();
2889 return true;
2890 }
2891 };
2892 sp<MessageBase> msg = new MessageScreenInitialized(this);
2893 postMessageAsync(msg); // we may be called from main thread, use async message
2894}
2895
2896void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& hw,
2897 int mode) {
2898 ALOGD("Set power mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(),
2899 this);
2900 int32_t type = hw->getDisplayType();
2901 int currentMode = hw->getPowerMode();
2902
2903 if (mode == currentMode) {
2904 ALOGD("Screen type=%d is already mode=%d", hw->getDisplayType(), mode);
2905 return;
2906 }
2907
2908 hw->setPowerMode(mode);
2909 if (type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
2910 ALOGW("Trying to set power mode for virtual display");
2911 return;
2912 }
2913
2914 if (mInterceptor.isEnabled()) {
2915 Mutex::Autolock _l(mStateLock);
2916 ssize_t idx = mCurrentState.displays.indexOfKey(hw->getDisplayToken());
2917 if (idx < 0) {
2918 ALOGW("Surface Interceptor SavePowerMode: invalid display token");
2919 return;
2920 }
2921 mInterceptor.savePowerModeUpdate(mCurrentState.displays.valueAt(idx).displayId, mode);
2922 }
2923
2924 if (currentMode == HWC_POWER_MODE_OFF) {
2925 // Turn on the display
2926 getHwComposer().setPowerMode(type, mode);
Matthew Bouyack38d49612017-05-12 12:49:32 -07002927 if (type == DisplayDevice::DISPLAY_PRIMARY &&
2928 mode != HWC_POWER_MODE_DOZE_SUSPEND) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002929 // FIXME: eventthread only knows about the main display right now
2930 mEventThread->onScreenAcquired();
2931 resyncToHardwareVsync(true);
2932 }
2933
2934 mVisibleRegionsDirty = true;
2935 mHasPoweredOff = true;
2936 repaintEverything();
2937
2938 struct sched_param param = {0};
2939 param.sched_priority = 1;
2940 if (sched_setscheduler(0, SCHED_FIFO, &param) != 0) {
2941 ALOGW("Couldn't set SCHED_FIFO on display on");
2942 }
2943 } else if (mode == HWC_POWER_MODE_OFF) {
2944 // Turn off the display
2945 struct sched_param param = {0};
2946 if (sched_setscheduler(0, SCHED_OTHER, &param) != 0) {
2947 ALOGW("Couldn't set SCHED_OTHER on display off");
2948 }
2949
2950 if (type == DisplayDevice::DISPLAY_PRIMARY) {
2951 disableHardwareVsync(true); // also cancels any in-progress resync
2952
2953 // FIXME: eventthread only knows about the main display right now
2954 mEventThread->onScreenReleased();
2955 }
2956
2957 getHwComposer().setPowerMode(type, mode);
2958 mVisibleRegionsDirty = true;
2959 // from this point on, SF will stop drawing on this display
Matthew Bouyack38d49612017-05-12 12:49:32 -07002960 } else if (mode == HWC_POWER_MODE_DOZE ||
2961 mode == HWC_POWER_MODE_NORMAL) {
Zheng Zhang8a43fe62017-03-17 11:19:39 +01002962 // Update display while dozing
2963 getHwComposer().setPowerMode(type, mode);
2964 if (type == DisplayDevice::DISPLAY_PRIMARY) {
2965 // FIXME: eventthread only knows about the main display right now
2966 mEventThread->onScreenAcquired();
2967 resyncToHardwareVsync(true);
2968 }
2969 } else if (mode == HWC_POWER_MODE_DOZE_SUSPEND) {
2970 // Leave display going to doze
2971 if (type == DisplayDevice::DISPLAY_PRIMARY) {
2972 disableHardwareVsync(true); // also cancels any in-progress resync
2973 // FIXME: eventthread only knows about the main display right now
2974 mEventThread->onScreenReleased();
2975 }
2976 getHwComposer().setPowerMode(type, mode);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002977 } else {
Matthew Bouyack38d49612017-05-12 12:49:32 -07002978 ALOGE("Attempting to set unknown power mode: %d\n", mode);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002979 getHwComposer().setPowerMode(type, mode);
2980 }
2981}
2982
2983void SurfaceFlinger::setPowerMode(const sp<IBinder>& display, int mode) {
2984 class MessageSetPowerMode: public MessageBase {
2985 SurfaceFlinger& mFlinger;
2986 sp<IBinder> mDisplay;
2987 int mMode;
2988 public:
2989 MessageSetPowerMode(SurfaceFlinger& flinger,
2990 const sp<IBinder>& disp, int mode) : mFlinger(flinger),
2991 mDisplay(disp) { mMode = mode; }
2992 virtual bool handler() {
2993 sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
2994 if (hw == NULL) {
2995 ALOGE("Attempt to set power mode = %d for null display %p",
2996 mMode, mDisplay.get());
2997 } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) {
2998 ALOGW("Attempt to set power mode = %d for virtual display",
2999 mMode);
3000 } else {
3001 mFlinger.setPowerModeInternal(hw, mMode);
3002 }
3003 return true;
3004 }
3005 };
3006 sp<MessageBase> msg = new MessageSetPowerMode(*this, display, mode);
3007 postMessageSync(msg);
3008}
3009
3010// ---------------------------------------------------------------------------
3011
Vishnu Nair6a408532017-10-24 09:11:27 -07003012status_t SurfaceFlinger::doDump(int fd, const Vector<String16>& args, bool asProto) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003013 String8 result;
3014
3015 IPCThreadState* ipc = IPCThreadState::self();
3016 const int pid = ipc->getCallingPid();
3017 const int uid = ipc->getCallingUid();
Vishnu Nair6a408532017-10-24 09:11:27 -07003018
3019 if (asProto) {
3020 // Return early as SurfaceFlinger does not support dumping sections in proto format
3021 return OK;
3022 }
3023
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003024 if ((uid != AID_SHELL) &&
3025 !PermissionCache::checkPermission(sDump, pid, uid)) {
3026 result.appendFormat("Permission Denial: "
3027 "can't dump SurfaceFlinger from pid=%d, uid=%d\n", pid, uid);
3028 } else {
3029 // Try to get the main lock, but give up after one second
3030 // (this would indicate SF is stuck, but we want to be able to
3031 // print something in dumpsys).
3032 status_t err = mStateLock.timedLock(s2ns(1));
3033 bool locked = (err == NO_ERROR);
3034 if (!locked) {
3035 result.appendFormat(
3036 "SurfaceFlinger appears to be unresponsive (%s [%d]), "
3037 "dumping anyways (no locks held)\n", strerror(-err), err);
3038 }
3039
3040 bool dumpAll = true;
3041 size_t index = 0;
3042 size_t numArgs = args.size();
3043 if (numArgs) {
3044 if ((index < numArgs) &&
3045 (args[index] == String16("--list"))) {
3046 index++;
3047 listLayersLocked(args, index, result);
3048 dumpAll = false;
3049 }
3050
3051 if ((index < numArgs) &&
3052 (args[index] == String16("--latency"))) {
3053 index++;
3054 dumpStatsLocked(args, index, result);
3055 dumpAll = false;
3056 }
3057
3058 if ((index < numArgs) &&
3059 (args[index] == String16("--latency-clear"))) {
3060 index++;
3061 clearStatsLocked(args, index, result);
3062 dumpAll = false;
3063 }
3064
3065 if ((index < numArgs) &&
3066 (args[index] == String16("--dispsync"))) {
3067 index++;
3068 mPrimaryDispSync.dump(result);
3069 dumpAll = false;
3070 }
3071
3072 if ((index < numArgs) &&
3073 (args[index] == String16("--static-screen"))) {
3074 index++;
3075 dumpStaticScreenStats(result);
3076 dumpAll = false;
3077 }
3078
3079 if ((index < numArgs) &&
Brian Andersond6927fb2016-07-23 23:37:30 -07003080 (args[index] == String16("--frame-events"))) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003081 index++;
Brian Andersond6927fb2016-07-23 23:37:30 -07003082 dumpFrameEventsLocked(result);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003083 dumpAll = false;
3084 }
chaviw1d044282017-09-27 12:19:28 -07003085
3086 if ((index < numArgs) && (args[index] == String16("--proto"))) {
3087 index++;
3088 LayersProto layersProto = dumpProtoInfo();
3089 result.append(layersProto.SerializeAsString().c_str(), layersProto.ByteSize());
3090 dumpAll = false;
3091 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003092 }
3093
3094 if (dumpAll) {
3095 dumpAllLocked(args, index, result);
3096 }
3097
3098 if (locked) {
3099 mStateLock.unlock();
3100 }
3101 }
3102 write(fd, result.string(), result.size());
3103 return NO_ERROR;
3104}
3105
3106void SurfaceFlinger::listLayersLocked(const Vector<String16>& /* args */,
3107 size_t& /* index */, String8& result) const
3108{
Robert Carr2047fae2016-11-28 14:09:09 -08003109 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003110 result.appendFormat("%s\n", layer->getName().string());
Robert Carr2047fae2016-11-28 14:09:09 -08003111 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003112}
3113
3114void SurfaceFlinger::dumpStatsLocked(const Vector<String16>& args, size_t& index,
3115 String8& result) const
3116{
3117 String8 name;
3118 if (index < args.size()) {
3119 name = String8(args[index]);
3120 index++;
3121 }
3122
3123 const nsecs_t period =
3124 getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
3125 result.appendFormat("%" PRId64 "\n", period);
3126
3127 if (name.isEmpty()) {
3128 mAnimFrameTracker.dumpStats(result);
3129 } else {
Robert Carr2047fae2016-11-28 14:09:09 -08003130 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003131 if (name == layer->getName()) {
3132 layer->dumpFrameStats(result);
3133 }
Robert Carr2047fae2016-11-28 14:09:09 -08003134 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003135 }
3136}
3137
3138void SurfaceFlinger::clearStatsLocked(const Vector<String16>& args, size_t& index,
3139 String8& /* result */)
3140{
3141 String8 name;
3142 if (index < args.size()) {
3143 name = String8(args[index]);
3144 index++;
3145 }
3146
Robert Carr2047fae2016-11-28 14:09:09 -08003147 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003148 if (name.isEmpty() || (name == layer->getName())) {
3149 layer->clearFrameStats();
3150 }
Robert Carr2047fae2016-11-28 14:09:09 -08003151 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003152
3153 mAnimFrameTracker.clearStats();
3154}
3155
3156// This should only be called from the main thread. Otherwise it would need
3157// the lock and should use mCurrentState rather than mDrawingState.
3158void SurfaceFlinger::logFrameStats() {
Robert Carr2047fae2016-11-28 14:09:09 -08003159 mDrawingState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003160 layer->logFrameStats();
Robert Carr2047fae2016-11-28 14:09:09 -08003161 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003162
3163 mAnimFrameTracker.logAndResetStats(String8("<win-anim>"));
3164}
3165
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08003166void SurfaceFlinger::appendSfConfigString(String8& result) const
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003167{
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08003168 result.append(" [sf");
Fabien Sanglardc93afd52017-03-13 13:02:42 -07003169 result.appendFormat(" HAS_CONTEXT_PRIORITY=%d", useContextPriority);
3170
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08003171 if (isLayerTripleBufferingDisabled())
3172 result.append(" DISABLE_TRIPLE_BUFFERING");
Fabien Sanglarda34ed632017-03-14 11:43:52 -07003173
Fabien Sanglardc45a7d92017-03-14 13:24:22 -07003174 result.appendFormat(" PRESENT_TIME_OFFSET=%" PRId64, dispSyncPresentTimeOffset);
Fabien Sanglarda34ed632017-03-14 11:43:52 -07003175 result.appendFormat(" FORCE_HWC_FOR_RBG_TO_YUV=%d", useHwcForRgbToYuv);
Fabien Sanglardc8e387e2017-03-10 10:30:28 -08003176 result.appendFormat(" MAX_VIRT_DISPLAY_DIM=%" PRIu64, maxVirtualDisplaySize);
Fabien Sanglardcbf153b2017-03-10 17:57:12 -08003177 result.appendFormat(" RUNNING_WITHOUT_SYNC_FRAMEWORK=%d", !hasSyncFramework);
Fabien Sanglard1971b632017-03-10 14:50:03 -08003178 result.appendFormat(" NUM_FRAMEBUFFER_SURFACE_BUFFERS=%" PRId64,
3179 maxFrameBufferAcquiredBuffers);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08003180 result.append("]");
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003181}
3182
3183void SurfaceFlinger::dumpStaticScreenStats(String8& result) const
3184{
3185 result.appendFormat("Static screen stats:\n");
3186 for (size_t b = 0; b < NUM_BUCKETS - 1; ++b) {
3187 float bucketTimeSec = mFrameBuckets[b] / 1e9;
3188 float percent = 100.0f *
3189 static_cast<float>(mFrameBuckets[b]) / mTotalTime;
3190 result.appendFormat(" < %zd frames: %.3f s (%.1f%%)\n",
3191 b + 1, bucketTimeSec, percent);
3192 }
3193 float bucketTimeSec = mFrameBuckets[NUM_BUCKETS - 1] / 1e9;
3194 float percent = 100.0f *
3195 static_cast<float>(mFrameBuckets[NUM_BUCKETS - 1]) / mTotalTime;
3196 result.appendFormat(" %zd+ frames: %.3f s (%.1f%%)\n",
3197 NUM_BUCKETS - 1, bucketTimeSec, percent);
3198}
3199
Brian Andersond6927fb2016-07-23 23:37:30 -07003200void SurfaceFlinger::dumpFrameEventsLocked(String8& result) {
3201 result.appendFormat("Layer frame timestamps:\n");
3202
3203 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
3204 const size_t count = currentLayers.size();
3205 for (size_t i=0 ; i<count ; i++) {
3206 currentLayers[i]->dumpFrameEvents(result);
3207 }
3208}
3209
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003210void SurfaceFlinger::recordBufferingStats(const char* layerName,
3211 std::vector<OccupancyTracker::Segment>&& history) {
3212 Mutex::Autolock lock(mBufferingStatsMutex);
3213 auto& stats = mBufferingStats[layerName];
3214 for (const auto& segment : history) {
3215 if (!segment.usedThirdBuffer) {
3216 stats.twoBufferTime += segment.totalTime;
3217 }
3218 if (segment.occupancyAverage < 1.0f) {
3219 stats.doubleBufferedTime += segment.totalTime;
3220 } else if (segment.occupancyAverage < 2.0f) {
3221 stats.tripleBufferedTime += segment.totalTime;
3222 }
3223 ++stats.numSegments;
3224 stats.totalTime += segment.totalTime;
3225 }
3226}
3227
3228void SurfaceFlinger::dumpBufferingStats(String8& result) const {
3229 result.append("Buffering stats:\n");
3230 result.append(" [Layer name] <Active time> <Two buffer> "
3231 "<Double buffered> <Triple buffered>\n");
3232 Mutex::Autolock lock(mBufferingStatsMutex);
3233 typedef std::tuple<std::string, float, float, float> BufferTuple;
3234 std::map<float, BufferTuple, std::greater<float>> sorted;
3235 for (const auto& statsPair : mBufferingStats) {
3236 const char* name = statsPair.first.c_str();
3237 const BufferingStats& stats = statsPair.second;
3238 if (stats.numSegments == 0) {
3239 continue;
3240 }
3241 float activeTime = ns2ms(stats.totalTime) / 1000.0f;
3242 float twoBufferRatio = static_cast<float>(stats.twoBufferTime) /
3243 stats.totalTime;
3244 float doubleBufferRatio = static_cast<float>(
3245 stats.doubleBufferedTime) / stats.totalTime;
3246 float tripleBufferRatio = static_cast<float>(
3247 stats.tripleBufferedTime) / stats.totalTime;
3248 sorted.insert({activeTime, {name, twoBufferRatio,
3249 doubleBufferRatio, tripleBufferRatio}});
3250 }
3251 for (const auto& sortedPair : sorted) {
3252 float activeTime = sortedPair.first;
3253 const BufferTuple& values = sortedPair.second;
3254 result.appendFormat(" [%s] %.2f %.3f %.3f %.3f\n",
3255 std::get<0>(values).c_str(), activeTime,
3256 std::get<1>(values), std::get<2>(values),
3257 std::get<3>(values));
3258 }
3259 result.append("\n");
3260}
3261
chaviw1d044282017-09-27 12:19:28 -07003262LayersProto SurfaceFlinger::dumpProtoInfo() const {
3263 LayersProto layersProto;
3264 mCurrentState.traverseInZOrder([&](Layer* layer) {
3265 LayerProto* layerProto = layersProto.add_layers();
3266 layer->writeToProto(layerProto, LayerVector::StateSet::Current);
3267 });
3268
3269 return layersProto;
3270}
3271
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003272void SurfaceFlinger::dumpAllLocked(const Vector<String16>& args, size_t& index,
3273 String8& result) const
3274{
3275 bool colorize = false;
3276 if (index < args.size()
3277 && (args[index] == String16("--color"))) {
3278 colorize = true;
3279 index++;
3280 }
3281
3282 Colorizer colorizer(colorize);
3283
3284 // figure out if we're stuck somewhere
3285 const nsecs_t now = systemTime();
3286 const nsecs_t inSwapBuffers(mDebugInSwapBuffers);
3287 const nsecs_t inTransaction(mDebugInTransaction);
3288 nsecs_t inSwapBuffersDuration = (inSwapBuffers) ? now-inSwapBuffers : 0;
3289 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
3290
3291 /*
3292 * Dump library configuration.
3293 */
3294
3295 colorizer.bold(result);
3296 result.append("Build configuration:");
3297 colorizer.reset(result);
3298 appendSfConfigString(result);
3299 appendUiConfigString(result);
3300 appendGuiConfigString(result);
3301 result.append("\n");
3302
3303 colorizer.bold(result);
3304 result.append("Sync configuration: ");
3305 colorizer.reset(result);
3306 result.append(SyncFeatures::getInstance().toString());
3307 result.append("\n");
3308
3309 colorizer.bold(result);
3310 result.append("DispSync configuration: ");
3311 colorizer.reset(result);
3312 result.appendFormat("app phase %" PRId64 " ns, sf phase %" PRId64 " ns, "
Fabien Sanglardc45a7d92017-03-14 13:24:22 -07003313 "present offset %" PRId64 " ns (refresh %" PRId64 " ns)",
3314 vsyncPhaseOffsetNs, sfVsyncPhaseOffsetNs, dispSyncPresentTimeOffset,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003315 mHwc->getRefreshPeriod(HWC_DISPLAY_PRIMARY));
3316 result.append("\n");
3317
3318 // Dump static screen stats
3319 result.append("\n");
3320 dumpStaticScreenStats(result);
3321 result.append("\n");
3322
3323 dumpBufferingStats(result);
3324
3325 /*
3326 * Dump the visible layer list
3327 */
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003328 colorizer.bold(result);
Robert Carr1f0a16a2016-10-24 16:27:39 -07003329 result.appendFormat("Visible layers (count = %zu)\n", mNumLayers);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003330 colorizer.reset(result);
chaviw1d044282017-09-27 12:19:28 -07003331
3332 LayersProto layersProto = dumpProtoInfo();
3333 auto layerTree = LayerProtoParser::generateLayerTree(layersProto);
3334 result.append(LayerProtoParser::layersToString(layerTree).c_str());
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003335
3336 /*
3337 * Dump Display state
3338 */
3339
3340 colorizer.bold(result);
3341 result.appendFormat("Displays (%zu entries)\n", mDisplays.size());
3342 colorizer.reset(result);
3343 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
3344 const sp<const DisplayDevice>& hw(mDisplays[dpy]);
3345 hw->dump(result);
3346 }
3347
3348 /*
3349 * Dump SurfaceFlinger global state
3350 */
3351
3352 colorizer.bold(result);
3353 result.append("SurfaceFlinger global state:\n");
3354 colorizer.reset(result);
3355
3356 HWComposer& hwc(getHwComposer());
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07003357 sp<const DisplayDevice> hw(getDefaultDisplayDeviceLocked());
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003358
3359 colorizer.bold(result);
3360 result.appendFormat("EGL implementation : %s\n",
3361 eglQueryStringImplementationANDROID(mEGLDisplay, EGL_VERSION));
3362 colorizer.reset(result);
3363 result.appendFormat("%s\n",
3364 eglQueryStringImplementationANDROID(mEGLDisplay, EGL_EXTENSIONS));
3365
3366 mRenderEngine->dump(result);
3367
3368 hw->undefinedRegion.dump(result, "undefinedRegion");
3369 result.appendFormat(" orientation=%d, isDisplayOn=%d\n",
3370 hw->getOrientation(), hw->isDisplayOn());
3371 result.appendFormat(
3372 " last eglSwapBuffers() time: %f us\n"
3373 " last transaction time : %f us\n"
3374 " transaction-flags : %08x\n"
3375 " refresh-rate : %f fps\n"
3376 " x-dpi : %f\n"
3377 " y-dpi : %f\n"
3378 " gpu_to_cpu_unsupported : %d\n"
3379 ,
3380 mLastSwapBufferTime/1000.0,
3381 mLastTransactionTime/1000.0,
3382 mTransactionFlags,
3383 1e9 / hwc.getRefreshPeriod(HWC_DISPLAY_PRIMARY),
3384 hwc.getDpiX(HWC_DISPLAY_PRIMARY),
3385 hwc.getDpiY(HWC_DISPLAY_PRIMARY),
3386 !mGpuToCpuSupported);
3387
3388 result.appendFormat(" eglSwapBuffers time: %f us\n",
3389 inSwapBuffersDuration/1000.0);
3390
3391 result.appendFormat(" transaction time: %f us\n",
3392 inTransactionDuration/1000.0);
3393
3394 /*
3395 * VSYNC state
3396 */
3397 mEventThread->dump(result);
3398
3399 /*
3400 * Dump HWComposer state
3401 */
3402 colorizer.bold(result);
3403 result.append("h/w composer state:\n");
3404 colorizer.reset(result);
3405 result.appendFormat(" h/w composer %s and %s\n",
3406 hwc.initCheck()==NO_ERROR ? "present" : "not present",
3407 (mDebugDisableHWC || mDebugRegion || mDaltonize
3408 || mHasColorMatrix) ? "disabled" : "enabled");
3409 hwc.dump(result);
3410
3411 /*
3412 * Dump gralloc state
3413 */
3414 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
3415 alloc.dump(result);
3416}
3417
3418const Vector< sp<Layer> >&
3419SurfaceFlinger::getLayerSortedByZForHwcDisplay(int id) {
3420 // Note: mStateLock is held here
3421 wp<IBinder> dpy;
3422 for (size_t i=0 ; i<mDisplays.size() ; i++) {
3423 if (mDisplays.valueAt(i)->getHwcDisplayId() == id) {
3424 dpy = mDisplays.keyAt(i);
3425 break;
3426 }
3427 }
3428 if (dpy == NULL) {
3429 ALOGE("getLayerSortedByZForHwcDisplay: invalid hwc display id %d", id);
3430 // Just use the primary display so we have something to return
3431 dpy = getBuiltInDisplay(DisplayDevice::DISPLAY_PRIMARY);
3432 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07003433 return getDisplayDeviceLocked(dpy)->getVisibleLayersSortedByZ();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003434}
3435
3436bool SurfaceFlinger::startDdmConnection()
3437{
3438 void* libddmconnection_dso =
3439 dlopen("libsurfaceflinger_ddmconnection.so", RTLD_NOW);
3440 if (!libddmconnection_dso) {
3441 return false;
3442 }
3443 void (*DdmConnection_start)(const char* name);
3444 DdmConnection_start =
3445 (decltype(DdmConnection_start))dlsym(libddmconnection_dso, "DdmConnection_start");
3446 if (!DdmConnection_start) {
3447 dlclose(libddmconnection_dso);
3448 return false;
3449 }
3450 (*DdmConnection_start)(getServiceName());
3451 return true;
3452}
3453
3454status_t SurfaceFlinger::onTransact(
3455 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
3456{
3457 switch (code) {
3458 case CREATE_CONNECTION:
3459 case CREATE_DISPLAY:
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003460 case BOOT_FINISHED:
3461 case CLEAR_ANIMATION_FRAME_STATS:
3462 case GET_ANIMATION_FRAME_STATS:
3463 case SET_POWER_MODE:
3464 case GET_HDR_CAPABILITIES:
3465 {
3466 // codes that require permission check
3467 IPCThreadState* ipc = IPCThreadState::self();
3468 const int pid = ipc->getCallingPid();
3469 const int uid = ipc->getCallingUid();
3470 if ((uid != AID_GRAPHICS && uid != AID_SYSTEM) &&
3471 !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)) {
3472 ALOGE("Permission Denial: "
3473 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
3474 return PERMISSION_DENIED;
3475 }
3476 break;
3477 }
Robert Carr1db73f62016-12-21 12:58:51 -08003478 /*
3479 * Calling setTransactionState is safe, because you need to have been
3480 * granted a reference to Client* and Handle* to do anything with it.
3481 *
3482 * Creating a scoped connection is safe, as per discussion in ISurfaceComposer.h
3483 */
3484 case SET_TRANSACTION_STATE:
3485 case CREATE_SCOPED_CONNECTION:
3486 {
3487 break;
3488 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003489 case CAPTURE_SCREEN:
3490 {
3491 // codes that require permission check
3492 IPCThreadState* ipc = IPCThreadState::self();
3493 const int pid = ipc->getCallingPid();
3494 const int uid = ipc->getCallingUid();
3495 if ((uid != AID_GRAPHICS) &&
3496 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
3497 ALOGE("Permission Denial: "
3498 "can't read framebuffer pid=%d, uid=%d", pid, uid);
3499 return PERMISSION_DENIED;
3500 }
3501 break;
3502 }
chaviwa76b2712017-09-20 12:02:26 -07003503 case CAPTURE_LAYERS:
3504 {
3505 IPCThreadState* ipc = IPCThreadState::self();
3506 const int pid = ipc->getCallingPid();
3507 const int uid = ipc->getCallingUid();
3508 if ((uid != AID_GRAPHICS) &&
3509 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
3510 ALOGE("Permission Denial: can't read framebuffer pid=%d, uid=%d", pid, uid);
3511 return PERMISSION_DENIED;
3512 }
3513 break;
3514 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003515 }
3516
3517 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
3518 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
3519 CHECK_INTERFACE(ISurfaceComposer, data, reply);
3520 if (CC_UNLIKELY(!PermissionCache::checkCallingPermission(sHardwareTest))) {
3521 IPCThreadState* ipc = IPCThreadState::self();
3522 const int pid = ipc->getCallingPid();
3523 const int uid = ipc->getCallingUid();
3524 ALOGE("Permission Denial: "
3525 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
3526 return PERMISSION_DENIED;
3527 }
3528 int n;
3529 switch (code) {
3530 case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
3531 case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
3532 return NO_ERROR;
3533 case 1002: // SHOW_UPDATES
3534 n = data.readInt32();
3535 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
3536 invalidateHwcGeometry();
3537 repaintEverything();
3538 return NO_ERROR;
3539 case 1004:{ // repaint everything
3540 repaintEverything();
3541 return NO_ERROR;
3542 }
3543 case 1005:{ // force transaction
3544 setTransactionFlags(
3545 eTransactionNeeded|
3546 eDisplayTransactionNeeded|
3547 eTraversalNeeded);
3548 return NO_ERROR;
3549 }
3550 case 1006:{ // send empty update
3551 signalRefresh();
3552 return NO_ERROR;
3553 }
3554 case 1008: // toggle use of hw composer
3555 n = data.readInt32();
3556 mDebugDisableHWC = n ? 1 : 0;
3557 invalidateHwcGeometry();
3558 repaintEverything();
3559 return NO_ERROR;
3560 case 1009: // toggle use of transform hint
3561 n = data.readInt32();
3562 mDebugDisableTransformHint = n ? 1 : 0;
3563 invalidateHwcGeometry();
3564 repaintEverything();
3565 return NO_ERROR;
3566 case 1010: // interrogate.
3567 reply->writeInt32(0);
3568 reply->writeInt32(0);
3569 reply->writeInt32(mDebugRegion);
3570 reply->writeInt32(0);
3571 reply->writeInt32(mDebugDisableHWC);
3572 return NO_ERROR;
3573 case 1013: {
3574 Mutex::Autolock _l(mStateLock);
3575 sp<const DisplayDevice> hw(getDefaultDisplayDevice());
3576 reply->writeInt32(hw->getPageFlipCount());
3577 return NO_ERROR;
3578 }
3579 case 1014: {
3580 // daltonize
3581 n = data.readInt32();
3582 switch (n % 10) {
3583 case 1:
3584 mDaltonizer.setType(ColorBlindnessType::Protanomaly);
3585 break;
3586 case 2:
3587 mDaltonizer.setType(ColorBlindnessType::Deuteranomaly);
3588 break;
3589 case 3:
3590 mDaltonizer.setType(ColorBlindnessType::Tritanomaly);
3591 break;
3592 }
3593 if (n >= 10) {
3594 mDaltonizer.setMode(ColorBlindnessMode::Correction);
3595 } else {
3596 mDaltonizer.setMode(ColorBlindnessMode::Simulation);
3597 }
3598 mDaltonize = n > 0;
3599 invalidateHwcGeometry();
3600 repaintEverything();
3601 return NO_ERROR;
3602 }
3603 case 1015: {
3604 // apply a color matrix
3605 n = data.readInt32();
3606 mHasColorMatrix = n ? 1 : 0;
3607 if (n) {
3608 // color matrix is sent as mat3 matrix followed by vec3
3609 // offset, then packed into a mat4 where the last row is
3610 // the offset and extra values are 0
3611 for (size_t i = 0 ; i < 4; i++) {
3612 for (size_t j = 0; j < 4; j++) {
3613 mColorMatrix[i][j] = data.readFloat();
3614 }
3615 }
3616 } else {
3617 mColorMatrix = mat4();
3618 }
3619 invalidateHwcGeometry();
3620 repaintEverything();
3621 return NO_ERROR;
3622 }
3623 // This is an experimental interface
3624 // Needs to be shifted to proper binder interface when we productize
3625 case 1016: {
3626 n = data.readInt32();
3627 mPrimaryDispSync.setRefreshSkipCount(n);
3628 return NO_ERROR;
3629 }
3630 case 1017: {
3631 n = data.readInt32();
3632 mForceFullDamage = static_cast<bool>(n);
3633 return NO_ERROR;
3634 }
3635 case 1018: { // Modify Choreographer's phase offset
3636 n = data.readInt32();
3637 mEventThread->setPhaseOffset(static_cast<nsecs_t>(n));
3638 return NO_ERROR;
3639 }
3640 case 1019: { // Modify SurfaceFlinger's phase offset
3641 n = data.readInt32();
3642 mSFEventThread->setPhaseOffset(static_cast<nsecs_t>(n));
3643 return NO_ERROR;
3644 }
3645 case 1020: { // Layer updates interceptor
3646 n = data.readInt32();
3647 if (n) {
3648 ALOGV("Interceptor enabled");
3649 mInterceptor.enable(mDrawingState.layersSortedByZ, mDrawingState.displays);
3650 }
3651 else{
3652 ALOGV("Interceptor disabled");
3653 mInterceptor.disable();
3654 }
3655 return NO_ERROR;
3656 }
3657 case 1021: { // Disable HWC virtual displays
3658 n = data.readInt32();
3659 mUseHwcVirtualDisplays = !n;
3660 return NO_ERROR;
3661 }
3662 }
3663 }
3664 return err;
3665}
3666
3667void SurfaceFlinger::repaintEverything() {
3668 android_atomic_or(1, &mRepaintEverything);
3669 signalTransaction();
3670}
3671
3672// ---------------------------------------------------------------------------
3673// Capture screen into an IGraphiBufferProducer
3674// ---------------------------------------------------------------------------
3675
3676/* The code below is here to handle b/8734824
3677 *
3678 * We create a IGraphicBufferProducer wrapper that forwards all calls
3679 * from the surfaceflinger thread to the calling binder thread, where they
3680 * are executed. This allows the calling thread in the calling process to be
3681 * reused and not depend on having "enough" binder threads to handle the
3682 * requests.
3683 */
3684class GraphicProducerWrapper : public BBinder, public MessageHandler {
3685 /* Parts of GraphicProducerWrapper are run on two different threads,
3686 * communicating by sending messages via Looper but also by shared member
3687 * data. Coherence maintenance is subtle and in places implicit (ugh).
3688 *
3689 * Don't rely on Looper's sendMessage/handleMessage providing
3690 * release/acquire semantics for any data not actually in the Message.
3691 * Data going from surfaceflinger to binder threads needs to be
3692 * synchronized explicitly.
3693 *
3694 * Barrier open/wait do provide release/acquire semantics. This provides
3695 * implicit synchronization for data coming back from binder to
3696 * surfaceflinger threads.
3697 */
3698
3699 sp<IGraphicBufferProducer> impl;
3700 sp<Looper> looper;
3701 status_t result;
3702 bool exitPending;
3703 bool exitRequested;
3704 Barrier barrier;
3705 uint32_t code;
3706 Parcel const* data;
3707 Parcel* reply;
3708
3709 enum {
3710 MSG_API_CALL,
3711 MSG_EXIT
3712 };
3713
3714 /*
3715 * Called on surfaceflinger thread. This is called by our "fake"
3716 * BpGraphicBufferProducer. We package the data and reply Parcel and
3717 * forward them to the binder thread.
3718 */
3719 virtual status_t transact(uint32_t code,
3720 const Parcel& data, Parcel* reply, uint32_t /* flags */) {
3721 this->code = code;
3722 this->data = &data;
3723 this->reply = reply;
3724 if (exitPending) {
3725 // if we've exited, we run the message synchronously right here.
3726 // note (JH): as far as I can tell from looking at the code, this
3727 // never actually happens. if it does, i'm not sure if it happens
3728 // on the surfaceflinger or binder thread.
3729 handleMessage(Message(MSG_API_CALL));
3730 } else {
3731 barrier.close();
3732 // Prevent stores to this->{code, data, reply} from being
3733 // reordered later than the construction of Message.
3734 atomic_thread_fence(memory_order_release);
3735 looper->sendMessage(this, Message(MSG_API_CALL));
3736 barrier.wait();
3737 }
3738 return result;
3739 }
3740
3741 /*
3742 * here we run on the binder thread. All we've got to do is
3743 * call the real BpGraphicBufferProducer.
3744 */
3745 virtual void handleMessage(const Message& message) {
3746 int what = message.what;
3747 // Prevent reads below from happening before the read from Message
3748 atomic_thread_fence(memory_order_acquire);
3749 if (what == MSG_API_CALL) {
3750 result = IInterface::asBinder(impl)->transact(code, data[0], reply);
3751 barrier.open();
3752 } else if (what == MSG_EXIT) {
3753 exitRequested = true;
3754 }
3755 }
3756
3757public:
3758 explicit GraphicProducerWrapper(const sp<IGraphicBufferProducer>& impl)
3759 : impl(impl),
3760 looper(new Looper(true)),
3761 result(NO_ERROR),
3762 exitPending(false),
3763 exitRequested(false),
3764 code(0),
3765 data(NULL),
3766 reply(NULL)
3767 {}
3768
3769 // Binder thread
3770 status_t waitForResponse() {
3771 do {
3772 looper->pollOnce(-1);
3773 } while (!exitRequested);
3774 return result;
3775 }
3776
3777 // Client thread
3778 void exit(status_t result) {
3779 this->result = result;
3780 exitPending = true;
3781 // Ensure this->result is visible to the binder thread before it
3782 // handles the message.
3783 atomic_thread_fence(memory_order_release);
3784 looper->sendMessage(this, Message(MSG_EXIT));
3785 }
3786};
3787
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003788status_t SurfaceFlinger::captureScreen(const sp<IBinder>& display,
chaviwa76b2712017-09-20 12:02:26 -07003789 const sp<IGraphicBufferProducer>& producer,
3790 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
3791 int32_t minLayerZ, int32_t maxLayerZ,
3792 bool useIdentityTransform, ISurfaceComposer::Rotation rotation) {
3793 ATRACE_CALL();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003794 if (CC_UNLIKELY(display == 0))
3795 return BAD_VALUE;
3796
chaviwa76b2712017-09-20 12:02:26 -07003797 const sp<const DisplayDevice> device(getDisplayDeviceLocked(display));
3798 DisplayRenderArea renderArea(device, sourceCrop, reqHeight, reqWidth, rotation);
3799
3800 auto traverseLayers = std::bind(std::mem_fn(&SurfaceFlinger::traverseLayersInDisplay), this,
3801 device, minLayerZ, maxLayerZ, std::placeholders::_1);
3802 return captureScreenCommon(renderArea, traverseLayers, producer, useIdentityTransform);
3803}
3804
3805status_t SurfaceFlinger::captureLayers(const sp<IBinder>& layerHandleBinder,
3806 const sp<IGraphicBufferProducer>& producer,
3807 ISurfaceComposer::Rotation rotation) {
3808 ATRACE_CALL();
3809 class LayerRenderArea : public RenderArea {
3810 public:
3811 LayerRenderArea(const sp<Layer>& layer, ISurfaceComposer::Rotation rotation)
3812 : RenderArea(layer->getCurrentState().active.h, layer->getCurrentState().active.w,
3813 rotation),
3814 mLayer(layer) {}
3815 const Transform& getTransform() const override {
3816 // Make the top level transform the inverse the transform and it's parent so it sets
3817 // the whole capture back to 0,0
3818 return *new Transform(mLayer->getTransform().inverse());
3819 }
3820 Rect getBounds() const override {
3821 const Layer::State& layerState(mLayer->getDrawingState());
3822 return Rect(layerState.active.w, layerState.active.h);
3823 }
3824 int getHeight() const override { return mLayer->getDrawingState().active.h; }
3825 int getWidth() const override { return mLayer->getDrawingState().active.w; }
3826 bool isSecure() const override { return false; }
3827 bool needsFiltering() const override { return false; }
3828
3829 Rect getSourceCrop() const override { return getBounds(); }
3830
3831 private:
3832 const sp<Layer>& mLayer;
3833 };
3834
3835 auto layerHandle = reinterpret_cast<Layer::Handle*>(layerHandleBinder.get());
3836 auto parent = layerHandle->owner.promote();
3837
3838 LayerRenderArea renderArea(parent, rotation);
3839 auto traverseLayers = [parent](const LayerVector::Visitor& visitor) {
3840 parent->traverseChildrenInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
3841 if (!layer->isVisible()) {
3842 return;
3843 }
3844 visitor(layer);
3845 });
3846 };
3847 return captureScreenCommon(renderArea, traverseLayers, producer, false);
3848}
3849
3850status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea,
3851 TraverseLayersFunction traverseLayers,
3852 const sp<IGraphicBufferProducer>& producer,
3853 bool useIdentityTransform) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003854 if (CC_UNLIKELY(producer == 0))
3855 return BAD_VALUE;
3856
3857 // if we have secure windows on this display, never allow the screen capture
3858 // unless the producer interface is local (i.e.: we can take a screenshot for
3859 // ourselves).
3860 bool isLocalScreenshot = IInterface::asBinder(producer)->localBinder();
3861
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003862 class MessageCaptureScreen : public MessageBase {
3863 SurfaceFlinger* flinger;
chaviwa76b2712017-09-20 12:02:26 -07003864 const RenderArea* renderArea;
3865 TraverseLayersFunction traverseLayers;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003866 sp<IGraphicBufferProducer> producer;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003867 bool useIdentityTransform;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003868 status_t result;
3869 bool isLocalScreenshot;
3870 public:
chaviwa76b2712017-09-20 12:02:26 -07003871 MessageCaptureScreen(SurfaceFlinger* flinger, const RenderArea* renderArea,
3872 TraverseLayersFunction traverseLayers,
3873 const sp<IGraphicBufferProducer>& producer, bool useIdentityTransform,
3874 bool isLocalScreenshot)
3875 : flinger(flinger),
3876 renderArea(renderArea),
3877 traverseLayers(traverseLayers),
3878 producer(producer),
3879 useIdentityTransform(useIdentityTransform),
3880 result(PERMISSION_DENIED),
3881 isLocalScreenshot(isLocalScreenshot) {}
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003882 status_t getResult() const {
3883 return result;
3884 }
3885 virtual bool handler() {
3886 Mutex::Autolock _l(flinger->mStateLock);
chaviwa76b2712017-09-20 12:02:26 -07003887 result = flinger->captureScreenImplLocked(*renderArea, traverseLayers, producer,
3888 useIdentityTransform, isLocalScreenshot);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003889 static_cast<GraphicProducerWrapper*>(IInterface::asBinder(producer).get())->exit(result);
3890 return true;
3891 }
3892 };
3893
3894 // this creates a "fake" BBinder which will serve as a "fake" remote
3895 // binder to receive the marshaled calls and forward them to the
3896 // real remote (a BpGraphicBufferProducer)
3897 sp<GraphicProducerWrapper> wrapper = new GraphicProducerWrapper(producer);
3898
3899 // the asInterface() call below creates our "fake" BpGraphicBufferProducer
3900 // which does the marshaling work forwards to our "fake remote" above.
3901 sp<MessageBase> msg = new MessageCaptureScreen(this,
chaviwa76b2712017-09-20 12:02:26 -07003902 &renderArea, traverseLayers, IGraphicBufferProducer::asInterface( wrapper ),
3903 useIdentityTransform, isLocalScreenshot);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003904
3905 status_t res = postMessageAsync(msg);
3906 if (res == NO_ERROR) {
3907 res = wrapper->waitForResponse();
3908 }
3909 return res;
3910}
3911
chaviwa76b2712017-09-20 12:02:26 -07003912void SurfaceFlinger::renderScreenImplLocked(const RenderArea& renderArea, TraverseLayersFunction traverseLayers,
3913 bool yswap, bool useIdentityTransform)
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003914{
3915 ATRACE_CALL();
3916 RenderEngine& engine(getRenderEngine());
3917
3918 // get screen geometry
chaviwa76b2712017-09-20 12:02:26 -07003919 const auto raWidth = renderArea.getWidth();
3920 const auto raHeight = renderArea.getHeight();
3921
3922 const auto reqWidth = renderArea.getReqWidth();
3923 const auto reqHeight = renderArea.getReqHeight();
3924 Rect sourceCrop = renderArea.getSourceCrop();
3925
3926 const bool filtering = static_cast<int32_t>(reqWidth) != raWidth ||
3927 static_cast<int32_t>(reqHeight) != raHeight;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003928
3929 // if a default or invalid sourceCrop is passed in, set reasonable values
3930 if (sourceCrop.width() == 0 || sourceCrop.height() == 0 ||
3931 !sourceCrop.isValid()) {
3932 sourceCrop.setLeftTop(Point(0, 0));
chaviwa76b2712017-09-20 12:02:26 -07003933 sourceCrop.setRightBottom(Point(raWidth, raHeight));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003934 }
3935
3936 // ensure that sourceCrop is inside screen
3937 if (sourceCrop.left < 0) {
3938 ALOGE("Invalid crop rect: l = %d (< 0)", sourceCrop.left);
3939 }
chaviwa76b2712017-09-20 12:02:26 -07003940 if (sourceCrop.right > raWidth) {
3941 ALOGE("Invalid crop rect: r = %d (> %d)", sourceCrop.right, raWidth);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003942 }
3943 if (sourceCrop.top < 0) {
3944 ALOGE("Invalid crop rect: t = %d (< 0)", sourceCrop.top);
3945 }
chaviwa76b2712017-09-20 12:02:26 -07003946 if (sourceCrop.bottom > raHeight) {
3947 ALOGE("Invalid crop rect: b = %d (> %d)", sourceCrop.bottom, raHeight);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003948 }
3949
3950 // make sure to clear all GL error flags
3951 engine.checkErrors();
3952
3953 // set-up our viewport
3954 engine.setViewportAndProjection(
chaviwa76b2712017-09-20 12:02:26 -07003955 reqWidth, reqHeight, sourceCrop, raHeight, yswap, renderArea.getRotationFlags());
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003956 engine.disableTexturing();
3957
3958 // redraw the screen entirely...
3959 engine.clearWithColor(0, 0, 0, 1);
3960
chaviwa76b2712017-09-20 12:02:26 -07003961 traverseLayers([&](Layer* layer) {
3962 if (filtering) layer->setFiltering(true);
3963 layer->draw(renderArea, useIdentityTransform);
3964 if (filtering) layer->setFiltering(false);
3965 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003966
3967 // compositionComplete is needed for older driver
chaviwa76b2712017-09-20 12:02:26 -07003968// hw->compositionComplete();
3969// hw->setViewportAndProjection();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003970}
3971
chaviwa76b2712017-09-20 12:02:26 -07003972status_t SurfaceFlinger::captureScreenImplLocked(const RenderArea& renderArea,
3973 TraverseLayersFunction traverseLayers,
3974 const sp<IGraphicBufferProducer>& producer,
3975 bool useIdentityTransform,
3976 bool isLocalScreenshot) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003977 ATRACE_CALL();
3978
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003979 bool secureLayerIsVisible = false;
chaviwa76b2712017-09-20 12:02:26 -07003980 traverseLayers([&](Layer *layer) {
3981 secureLayerIsVisible = secureLayerIsVisible || (layer->isVisible() &&
3982 layer->isSecure());
3983 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003984
3985 if (!isLocalScreenshot && secureLayerIsVisible) {
3986 ALOGW("FB is protected: PERMISSION_DENIED");
3987 return PERMISSION_DENIED;
3988 }
3989
3990 // create a surface (because we're a producer, and we need to
3991 // dequeue/queue a buffer)
3992 sp<Surface> sur = new Surface(producer, false);
3993 ANativeWindow* window = sur.get();
3994
3995 status_t result = native_window_api_connect(window, NATIVE_WINDOW_API_EGL);
3996 if (result == NO_ERROR) {
3997 uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
3998 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
3999
4000 int err = 0;
chaviwa76b2712017-09-20 12:02:26 -07004001 err = native_window_set_buffers_dimensions(window, renderArea.getReqWidth(),
4002 renderArea.getReqHeight());
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004003 err |= native_window_set_scaling_mode(window, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
4004 err |= native_window_set_buffers_format(window, HAL_PIXEL_FORMAT_RGBA_8888);
4005 err |= native_window_set_usage(window, usage);
4006
4007 if (err == NO_ERROR) {
4008 ANativeWindowBuffer* buffer;
4009 /* TODO: Once we have the sync framework everywhere this can use
4010 * server-side waits on the fence that dequeueBuffer returns.
4011 */
4012 result = native_window_dequeue_buffer_and_wait(window, &buffer);
4013 if (result == NO_ERROR) {
4014 int syncFd = -1;
4015 // create an EGLImage from the buffer so we can later
4016 // turn it into a texture
4017 EGLImageKHR image = eglCreateImageKHR(mEGLDisplay, EGL_NO_CONTEXT,
4018 EGL_NATIVE_BUFFER_ANDROID, buffer, NULL);
4019 if (image != EGL_NO_IMAGE_KHR) {
4020 // this binds the given EGLImage as a framebuffer for the
4021 // duration of this scope.
4022 RenderEngine::BindImageAsFramebuffer imageBond(getRenderEngine(), image);
4023 if (imageBond.getStatus() == NO_ERROR) {
4024 // this will in fact render into our dequeued buffer
4025 // via an FBO, which means we didn't have to create
4026 // an EGLSurface and therefore we're not
4027 // dependent on the context's EGLConfig.
chaviwa76b2712017-09-20 12:02:26 -07004028 renderScreenImplLocked(renderArea, traverseLayers, true, useIdentityTransform);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004029
4030 // Attempt to create a sync khr object that can produce a sync point. If that
4031 // isn't available, create a non-dupable sync object in the fallback path and
4032 // wait on it directly.
4033 EGLSyncKHR sync;
4034 if (!DEBUG_SCREENSHOTS) {
4035 sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, NULL);
4036 // native fence fd will not be populated until flush() is done.
4037 getRenderEngine().flush();
4038 } else {
4039 sync = EGL_NO_SYNC_KHR;
4040 }
4041 if (sync != EGL_NO_SYNC_KHR) {
4042 // get the sync fd
4043 syncFd = eglDupNativeFenceFDANDROID(mEGLDisplay, sync);
4044 if (syncFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
4045 ALOGW("captureScreen: failed to dup sync khr object");
4046 syncFd = -1;
4047 }
4048 eglDestroySyncKHR(mEGLDisplay, sync);
4049 } else {
4050 // fallback path
4051 sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, NULL);
4052 if (sync != EGL_NO_SYNC_KHR) {
4053 EGLint result = eglClientWaitSyncKHR(mEGLDisplay, sync,
4054 EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, 2000000000 /*2 sec*/);
4055 EGLint eglErr = eglGetError();
4056 if (result == EGL_TIMEOUT_EXPIRED_KHR) {
4057 ALOGW("captureScreen: fence wait timed out");
4058 } else {
4059 ALOGW_IF(eglErr != EGL_SUCCESS,
4060 "captureScreen: error waiting on EGL fence: %#x", eglErr);
4061 }
4062 eglDestroySyncKHR(mEGLDisplay, sync);
4063 } else {
4064 ALOGW("captureScreen: error creating EGL fence: %#x", eglGetError());
4065 }
4066 }
4067 if (DEBUG_SCREENSHOTS) {
chaviwa76b2712017-09-20 12:02:26 -07004068 uint32_t* pixels = new uint32_t[renderArea.getReqWidth() *
4069 renderArea.getReqHeight()];
4070 getRenderEngine().readPixels(0, 0, renderArea.getReqWidth(),
4071 renderArea.getReqHeight(), pixels);
4072 checkScreenshot(renderArea.getReqWidth(), renderArea.getReqHeight(),
4073 renderArea.getReqWidth(), pixels, traverseLayers);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004074 delete [] pixels;
4075 }
4076
4077 } else {
4078 ALOGE("got GL_FRAMEBUFFER_COMPLETE_OES error while taking screenshot");
4079 result = INVALID_OPERATION;
4080 window->cancelBuffer(window, buffer, syncFd);
4081 buffer = NULL;
4082 }
4083 // destroy our image
4084 eglDestroyImageKHR(mEGLDisplay, image);
4085 } else {
4086 result = BAD_VALUE;
4087 }
4088 if (buffer) {
4089 // queueBuffer takes ownership of syncFd
4090 result = window->queueBuffer(window, buffer, syncFd);
4091 }
4092 }
4093 } else {
4094 result = BAD_VALUE;
4095 }
4096 native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
4097 }
4098
4099 return result;
4100}
4101
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004102void SurfaceFlinger::checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
chaviwa76b2712017-09-20 12:02:26 -07004103 TraverseLayersFunction traverseLayers) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004104 if (DEBUG_SCREENSHOTS) {
4105 for (size_t y=0 ; y<h ; y++) {
4106 uint32_t const * p = (uint32_t const *)vaddr + y*s;
4107 for (size_t x=0 ; x<w ; x++) {
4108 if (p[x] != 0xFF000000) return;
4109 }
4110 }
chaviwa76b2712017-09-20 12:02:26 -07004111 ALOGE("*** we just took a black screenshot ***");
4112
Robert Carr2047fae2016-11-28 14:09:09 -08004113 size_t i = 0;
chaviwa76b2712017-09-20 12:02:26 -07004114 traverseLayers([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004115 const Layer::State& state(layer->getDrawingState());
chaviwa76b2712017-09-20 12:02:26 -07004116 ALOGE("%c index=%zu, name=%s, layerStack=%d, z=%d, visible=%d, flags=%x, alpha=%.3f",
4117 layer->isVisible() ? '+' : '-',
4118 i, layer->getName().string(), layer->getLayerStack(), state.z,
4119 layer->isVisible(), state.flags, static_cast<float>(state.color.a));
4120 i++;
4121 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004122 }
4123}
4124
4125// ---------------------------------------------------------------------------
4126
Dan Stoza412903f2017-04-27 13:42:17 -07004127void SurfaceFlinger::State::traverseInZOrder(const LayerVector::Visitor& visitor) const {
4128 layersSortedByZ.traverseInZOrder(stateSet, visitor);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004129}
4130
Dan Stoza412903f2017-04-27 13:42:17 -07004131void SurfaceFlinger::State::traverseInReverseZOrder(const LayerVector::Visitor& visitor) const {
4132 layersSortedByZ.traverseInReverseZOrder(stateSet, visitor);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004133}
4134
chaviwa76b2712017-09-20 12:02:26 -07004135void SurfaceFlinger::traverseLayersInDisplay(const sp<const DisplayDevice>& hw,
4136 int32_t minLayerZ, int32_t maxLayerZ, const LayerVector::Visitor& visitor) {
4137
4138 // We loop through the first level of layers without traversing,
4139 // as we need to interpret min/max layer Z in the top level Z space.
4140 for (const auto& layer : mDrawingState.layersSortedByZ) {
4141 if (!layer->belongsToDisplay(hw->getLayerStack(), false)) {
4142 continue;
4143 }
4144 const Layer::State& state(layer->getDrawingState());
4145 if (state.z < minLayerZ || state.z > maxLayerZ) {
4146 continue;
4147 }
4148 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
4149 if (!layer->isVisible()) {
4150 return;
4151 }
4152 visitor(layer);
4153 });
4154 }
4155}
4156
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004157}; // namespace android
4158
4159
4160#if defined(__gl_h_)
4161#error "don't include gl/gl.h in this file"
4162#endif
4163
4164#if defined(__gl2_h_)
4165#error "don't include gl2/gl2.h in this file"
4166#endif