blob: 2b56928c3d7f1e6d5f69b6323ce139fe41af1cba [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>
44#include <gui/Surface.h>
Fabien Sanglard9d96de42016-10-11 00:15:18 +000045
46#include <ui/GraphicBufferAllocator.h>
47#include <ui/HdrCapabilities.h>
48#include <ui/PixelFormat.h>
49#include <ui/UiConfig.h>
50
51#include <utils/misc.h>
52#include <utils/String8.h>
53#include <utils/String16.h>
54#include <utils/StopWatch.h>
55#include <utils/Timers.h>
56#include <utils/Trace.h>
57
58#include <private/android_filesystem_config.h>
59#include <private/gui/SyncFeatures.h>
60
61#include <set>
62
63#include "Client.h"
64#include "clz.h"
65#include "Colorizer.h"
66#include "DdmConnection.h"
67#include "DisplayDevice.h"
68#include "DispSync.h"
69#include "EventControlThread.h"
70#include "EventThread.h"
71#include "Layer.h"
Robert Carr1f0a16a2016-10-24 16:27:39 -070072#include "LayerVector.h"
Fabien Sanglard9d96de42016-10-11 00:15:18 +000073#include "LayerDim.h"
Robert Carr1db73f62016-12-21 12:58:51 -080074#include "MonitoredProducer.h"
Fabien Sanglard9d96de42016-10-11 00:15:18 +000075#include "SurfaceFlinger.h"
76
77#include "DisplayHardware/FramebufferSurface.h"
78#include "DisplayHardware/HWComposer.h"
79#include "DisplayHardware/VirtualDisplaySurface.h"
80
81#include "Effects/Daltonizer.h"
82
83#include "RenderEngine/RenderEngine.h"
84#include <cutils/compiler.h>
85
Fabien Sanglard0cc19382017-03-06 11:54:40 -080086#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
87#include <configstore/Utils.h>
88
Fabien Sanglard9d96de42016-10-11 00:15:18 +000089#define DISPLAY_COUNT 1
90
91/*
92 * DEBUG_SCREENSHOTS: set to true to check that screenshots are not all
93 * black pixels.
94 */
95#define DEBUG_SCREENSHOTS false
96
97EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name);
98
Fabien Sanglard9d96de42016-10-11 00:15:18 +000099namespace android {
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000100// ---------------------------------------------------------------------------
101
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800102using namespace android::hardware::configstore;
103using namespace android::hardware::configstore::V1_0;
104
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000105const String16 sHardwareTest("android.permission.HARDWARE_TEST");
106const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER");
107const String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER");
108const String16 sDump("android.permission.DUMP");
109
110// ---------------------------------------------------------------------------
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800111int64_t SurfaceFlinger::vsyncPhaseOffsetNs;
112int64_t SurfaceFlinger::sfVsyncPhaseOffsetNs;
Fabien Sanglardc93afd52017-03-13 13:02:42 -0700113bool SurfaceFlinger::useContextPriority;
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700114int64_t SurfaceFlinger::dispSyncPresentTimeOffset;
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700115bool SurfaceFlinger::useHwcForRgbToYuv;
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800116uint64_t SurfaceFlinger::maxVirtualDisplaySize;
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800117bool SurfaceFlinger::hasSyncFramework;
Fabien Sanglard1971b632017-03-10 14:50:03 -0800118int64_t SurfaceFlinger::maxFrameBufferAcquiredBuffers;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000119
120SurfaceFlinger::SurfaceFlinger()
121 : BnSurfaceComposer(),
122 mTransactionFlags(0),
123 mTransactionPending(false),
124 mAnimTransactionPending(false),
125 mLayersRemoved(false),
Robert Carr1f0a16a2016-10-24 16:27:39 -0700126 mLayersAdded(false),
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000127 mRepaintEverything(0),
128 mRenderEngine(NULL),
129 mBootTime(systemTime()),
130 mVisibleRegionsDirty(false),
131 mHwWorkListDirty(false),
132 mAnimCompositionPending(false),
133 mDebugRegion(0),
134 mDebugDDMS(0),
135 mDebugDisableHWC(0),
136 mDebugDisableTransformHint(0),
137 mDebugInSwapBuffers(0),
138 mLastSwapBufferTime(0),
139 mDebugInTransaction(0),
140 mLastTransactionTime(0),
141 mBootFinished(false),
142 mForceFullDamage(false),
Robert Carr0d480722017-01-10 16:42:54 -0800143 mInterceptor(this),
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000144 mPrimaryDispSync("PrimaryDispSync"),
145 mPrimaryHWVsyncEnabled(false),
146 mHWVsyncAvailable(false),
147 mDaltonize(false),
148 mHasColorMatrix(false),
149 mHasPoweredOff(false),
150 mFrameBuckets(),
151 mTotalTime(0),
Robert Carr1f0a16a2016-10-24 16:27:39 -0700152 mLastSwapTime(0),
153 mNumLayers(0)
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000154{
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800155 ALOGI("SurfaceFlinger is starting");
156
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800157 vsyncPhaseOffsetNs = getInt64< ISurfaceFlingerConfigs,
158 &ISurfaceFlingerConfigs::vsyncEventPhaseOffsetNs>(1000000);
159
160 sfVsyncPhaseOffsetNs = getInt64< ISurfaceFlingerConfigs,
161 &ISurfaceFlingerConfigs::vsyncSfEventPhaseOffsetNs>(1000000);
162
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800163 maxVirtualDisplaySize = getUInt64<ISurfaceFlingerConfigs,
164 &ISurfaceFlingerConfigs::maxVirtualDisplaySize>(0);
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000165
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800166 hasSyncFramework = getBool< ISurfaceFlingerConfigs,
167 &ISurfaceFlingerConfigs::hasSyncFramework>(true);
168
Fabien Sanglardc93afd52017-03-13 13:02:42 -0700169 useContextPriority = getBool< ISurfaceFlingerConfigs,
170 &ISurfaceFlingerConfigs::useContextPriority>(false);
171
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700172 dispSyncPresentTimeOffset = getInt64< ISurfaceFlingerConfigs,
173 &ISurfaceFlingerConfigs::presentTimeOffsetFromVSyncNs>(0);
174
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700175 useHwcForRgbToYuv = getBool< ISurfaceFlingerConfigs,
176 &ISurfaceFlingerConfigs::useHwcForRGBtoYUV>(false);
177
Fabien Sanglard1971b632017-03-10 14:50:03 -0800178 maxFrameBufferAcquiredBuffers = getInt64< ISurfaceFlingerConfigs,
179 &ISurfaceFlingerConfigs::maxFrameBufferAcquiredBuffers>(2);
180
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000181 char value[PROPERTY_VALUE_MAX];
182
183 property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");
184 mGpuToCpuSupported = !atoi(value);
185
186 property_get("debug.sf.showupdates", value, "0");
187 mDebugRegion = atoi(value);
188
189 property_get("debug.sf.ddms", value, "0");
190 mDebugDDMS = atoi(value);
191 if (mDebugDDMS) {
192 if (!startDdmConnection()) {
193 // start failed, and DDMS debugging not enabled
194 mDebugDDMS = 0;
195 }
196 }
197 ALOGI_IF(mDebugRegion, "showupdates enabled");
198 ALOGI_IF(mDebugDDMS, "DDMS debugging enabled");
199
Fabien Sanglard642b23d2017-02-09 12:29:39 -0800200 property_get("debug.sf.enable_hwc_vds", value, "0");
201 mUseHwcVirtualDisplays = atoi(value);
202 ALOGI_IF(!mUseHwcVirtualDisplays, "Enabling HWC virtual displays");
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800203
Fabien Sanglardc65dafa2017-02-07 14:06:39 -0800204 property_get("ro.sf.disable_triple_buffer", value, "1");
205 mLayerTripleBufferingDisabled = atoi(value);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800206 ALOGI_IF(mLayerTripleBufferingDisabled, "Disabling Triple Buffering");
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000207}
208
209void SurfaceFlinger::onFirstRef()
210{
211 mEventQueue.init(this);
212}
213
214SurfaceFlinger::~SurfaceFlinger()
215{
216 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
217 eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
218 eglTerminate(display);
219}
220
221void SurfaceFlinger::binderDied(const wp<IBinder>& /* who */)
222{
223 // the window manager died on us. prepare its eulogy.
224
225 // restore initial conditions (default device unblank, etc)
226 initializeDisplays();
227
228 // restart the boot-animation
229 startBootAnim();
230}
231
Robert Carr1db73f62016-12-21 12:58:51 -0800232static sp<ISurfaceComposerClient> initClient(const sp<Client>& client) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000233 status_t err = client->initCheck();
234 if (err == NO_ERROR) {
Robert Carr1db73f62016-12-21 12:58:51 -0800235 return client;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000236 }
Robert Carr1db73f62016-12-21 12:58:51 -0800237 return nullptr;
238}
239
240sp<ISurfaceComposerClient> SurfaceFlinger::createConnection() {
241 return initClient(new Client(this));
242}
243
244sp<ISurfaceComposerClient> SurfaceFlinger::createScopedConnection(
245 const sp<IGraphicBufferProducer>& gbp) {
246 if (authenticateSurfaceTexture(gbp) == false) {
247 return nullptr;
248 }
249 const auto& layer = (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
250 if (layer == nullptr) {
251 return nullptr;
252 }
253
254 return initClient(new Client(this, layer));
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000255}
256
257sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName,
258 bool secure)
259{
260 class DisplayToken : public BBinder {
261 sp<SurfaceFlinger> flinger;
262 virtual ~DisplayToken() {
263 // no more references, this display must be terminated
264 Mutex::Autolock _l(flinger->mStateLock);
265 flinger->mCurrentState.displays.removeItem(this);
266 flinger->setTransactionFlags(eDisplayTransactionNeeded);
267 }
268 public:
269 explicit DisplayToken(const sp<SurfaceFlinger>& flinger)
270 : flinger(flinger) {
271 }
272 };
273
274 sp<BBinder> token = new DisplayToken(this);
275
276 Mutex::Autolock _l(mStateLock);
277 DisplayDeviceState info(DisplayDevice::DISPLAY_VIRTUAL, secure);
278 info.displayName = displayName;
279 mCurrentState.displays.add(token, info);
280 mInterceptor.saveDisplayCreation(info);
281 return token;
282}
283
284void SurfaceFlinger::destroyDisplay(const sp<IBinder>& display) {
285 Mutex::Autolock _l(mStateLock);
286
287 ssize_t idx = mCurrentState.displays.indexOfKey(display);
288 if (idx < 0) {
289 ALOGW("destroyDisplay: invalid display token");
290 return;
291 }
292
293 const DisplayDeviceState& info(mCurrentState.displays.valueAt(idx));
294 if (!info.isVirtualDisplay()) {
295 ALOGE("destroyDisplay called for non-virtual display");
296 return;
297 }
298 mInterceptor.saveDisplayDeletion(info.displayId);
299 mCurrentState.displays.removeItemsAt(idx);
300 setTransactionFlags(eDisplayTransactionNeeded);
301}
302
303void SurfaceFlinger::createBuiltinDisplayLocked(DisplayDevice::DisplayType type) {
304 ALOGW_IF(mBuiltinDisplays[type],
305 "Overwriting display token for display type %d", type);
306 mBuiltinDisplays[type] = new BBinder();
307 // All non-virtual displays are currently considered secure.
308 DisplayDeviceState info(type, true);
309 mCurrentState.displays.add(mBuiltinDisplays[type], info);
310 mInterceptor.saveDisplayCreation(info);
311}
312
313sp<IBinder> SurfaceFlinger::getBuiltInDisplay(int32_t id) {
314 if (uint32_t(id) >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
315 ALOGE("getDefaultDisplay: id=%d is not a valid default display id", id);
316 return NULL;
317 }
318 return mBuiltinDisplays[id];
319}
320
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000321void SurfaceFlinger::bootFinished()
322{
Wei Wangf9b05ee2017-07-19 20:59:39 -0700323 if (mStartPropertySetThread->join() != NO_ERROR) {
324 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800325 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000326 const nsecs_t now = systemTime();
327 const nsecs_t duration = now - mBootTime;
328 ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
329 mBootFinished = true;
330
331 // wait patiently for the window manager death
332 const String16 name("window");
333 sp<IBinder> window(defaultServiceManager()->getService(name));
334 if (window != 0) {
335 window->linkToDeath(static_cast<IBinder::DeathRecipient*>(this));
336 }
337
338 // stop boot animation
339 // formerly we would just kill the process, but we now ask it to exit so it
340 // can choose where to stop the animation.
341 property_set("service.bootanim.exit", "1");
342
343 const int LOGTAG_SF_STOP_BOOTANIM = 60110;
344 LOG_EVENT_LONG(LOGTAG_SF_STOP_BOOTANIM,
345 ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
346}
347
348void SurfaceFlinger::deleteTextureAsync(uint32_t texture) {
349 class MessageDestroyGLTexture : public MessageBase {
350 RenderEngine& engine;
351 uint32_t texture;
352 public:
353 MessageDestroyGLTexture(RenderEngine& engine, uint32_t texture)
354 : engine(engine), texture(texture) {
355 }
356 virtual bool handler() {
357 engine.deleteTextures(1, &texture);
358 return true;
359 }
360 };
361 postMessageAsync(new MessageDestroyGLTexture(getRenderEngine(), texture));
362}
363
364class DispSyncSource : public VSyncSource, private DispSync::Callback {
365public:
366 DispSyncSource(DispSync* dispSync, nsecs_t phaseOffset, bool traceVsync,
367 const char* name) :
368 mName(name),
369 mValue(0),
370 mTraceVsync(traceVsync),
371 mVsyncOnLabel(String8::format("VsyncOn-%s", name)),
372 mVsyncEventLabel(String8::format("VSYNC-%s", name)),
373 mDispSync(dispSync),
374 mCallbackMutex(),
375 mCallback(),
376 mVsyncMutex(),
377 mPhaseOffset(phaseOffset),
378 mEnabled(false) {}
379
380 virtual ~DispSyncSource() {}
381
382 virtual void setVSyncEnabled(bool enable) {
383 Mutex::Autolock lock(mVsyncMutex);
384 if (enable) {
385 status_t err = mDispSync->addEventListener(mName, mPhaseOffset,
386 static_cast<DispSync::Callback*>(this));
387 if (err != NO_ERROR) {
388 ALOGE("error registering vsync callback: %s (%d)",
389 strerror(-err), err);
390 }
391 //ATRACE_INT(mVsyncOnLabel.string(), 1);
392 } else {
393 status_t err = mDispSync->removeEventListener(
394 static_cast<DispSync::Callback*>(this));
395 if (err != NO_ERROR) {
396 ALOGE("error unregistering vsync callback: %s (%d)",
397 strerror(-err), err);
398 }
399 //ATRACE_INT(mVsyncOnLabel.string(), 0);
400 }
401 mEnabled = enable;
402 }
403
404 virtual void setCallback(const sp<VSyncSource::Callback>& callback) {
405 Mutex::Autolock lock(mCallbackMutex);
406 mCallback = callback;
407 }
408
409 virtual void setPhaseOffset(nsecs_t phaseOffset) {
410 Mutex::Autolock lock(mVsyncMutex);
411
412 // Normalize phaseOffset to [0, period)
413 auto period = mDispSync->getPeriod();
414 phaseOffset %= period;
415 if (phaseOffset < 0) {
416 // If we're here, then phaseOffset is in (-period, 0). After this
417 // operation, it will be in (0, period)
418 phaseOffset += period;
419 }
420 mPhaseOffset = phaseOffset;
421
422 // If we're not enabled, we don't need to mess with the listeners
423 if (!mEnabled) {
424 return;
425 }
426
427 // Remove the listener with the old offset
428 status_t err = mDispSync->removeEventListener(
429 static_cast<DispSync::Callback*>(this));
430 if (err != NO_ERROR) {
431 ALOGE("error unregistering vsync callback: %s (%d)",
432 strerror(-err), err);
433 }
434
435 // Add a listener with the new offset
436 err = mDispSync->addEventListener(mName, mPhaseOffset,
437 static_cast<DispSync::Callback*>(this));
438 if (err != NO_ERROR) {
439 ALOGE("error registering vsync callback: %s (%d)",
440 strerror(-err), err);
441 }
442 }
443
444private:
445 virtual void onDispSyncEvent(nsecs_t when) {
446 sp<VSyncSource::Callback> callback;
447 {
448 Mutex::Autolock lock(mCallbackMutex);
449 callback = mCallback;
450
451 if (mTraceVsync) {
452 mValue = (mValue + 1) % 2;
453 ATRACE_INT(mVsyncEventLabel.string(), mValue);
454 }
455 }
456
457 if (callback != NULL) {
458 callback->onVSyncEvent(when);
459 }
460 }
461
462 const char* const mName;
463
464 int mValue;
465
466 const bool mTraceVsync;
467 const String8 mVsyncOnLabel;
468 const String8 mVsyncEventLabel;
469
470 DispSync* mDispSync;
471
472 Mutex mCallbackMutex; // Protects the following
473 sp<VSyncSource::Callback> mCallback;
474
475 Mutex mVsyncMutex; // Protects the following
476 nsecs_t mPhaseOffset;
477 bool mEnabled;
478};
479
480class InjectVSyncSource : public VSyncSource {
481public:
482 InjectVSyncSource() {}
483
484 virtual ~InjectVSyncSource() {}
485
486 virtual void setCallback(const sp<VSyncSource::Callback>& callback) {
487 std::lock_guard<std::mutex> lock(mCallbackMutex);
488 mCallback = callback;
489 }
490
491 virtual void onInjectSyncEvent(nsecs_t when) {
492 std::lock_guard<std::mutex> lock(mCallbackMutex);
493 mCallback->onVSyncEvent(when);
494 }
495
496 virtual void setVSyncEnabled(bool) {}
497 virtual void setPhaseOffset(nsecs_t) {}
498
499private:
500 std::mutex mCallbackMutex; // Protects the following
501 sp<VSyncSource::Callback> mCallback;
502};
503
Wei Wangf9b05ee2017-07-19 20:59:39 -0700504// Do not call property_set on main thread which will be blocked by init
505// Use StartPropertySetThread instead.
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000506void SurfaceFlinger::init() {
507 ALOGI( "SurfaceFlinger's main thread ready to run. "
508 "Initializing graphics H/W...");
509
510 Mutex::Autolock _l(mStateLock);
511
512 // initialize EGL for the default display
513 mEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
514 eglInitialize(mEGLDisplay, NULL, NULL);
515
516 // start the EventThread
517 sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,
518 vsyncPhaseOffsetNs, true, "app");
519 mEventThread = new EventThread(vsyncSrc, *this, false);
520 sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,
521 sfVsyncPhaseOffsetNs, true, "sf");
522 mSFEventThread = new EventThread(sfVsyncSrc, *this, true);
523 mEventQueue.setEventThread(mSFEventThread);
524
Tim Murray22752852017-05-04 13:38:49 -0700525 // set EventThread and SFEventThread to SCHED_FIFO to minimize jitter
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000526 struct sched_param param = {0};
527 param.sched_priority = 2;
528 if (sched_setscheduler(mSFEventThread->getTid(), SCHED_FIFO, &param) != 0) {
529 ALOGE("Couldn't set SCHED_FIFO for SFEventThread");
530 }
Tim Murray22752852017-05-04 13:38:49 -0700531 if (sched_setscheduler(mEventThread->getTid(), SCHED_FIFO, &param) != 0) {
532 ALOGE("Couldn't set SCHED_FIFO for EventThread");
533 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000534
535 // Initialize the H/W composer object. There may or may not be an
536 // actual hardware composer underneath.
537 mHwc = new HWComposer(this,
538 *static_cast<HWComposer::EventHandler *>(this));
539
540 // get a RenderEngine for the given display / config (can't fail)
Kalle Raitabbdcf1f2017-05-22 15:47:46 -0700541 mRenderEngine = RenderEngine::create(mEGLDisplay,
542 mHwc->getVisualID(), 0);
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000543
544 // retrieve the EGL context that was selected/created
545 mEGLContext = mRenderEngine->getEGLContext();
546
547 LOG_ALWAYS_FATAL_IF(mEGLContext == EGL_NO_CONTEXT,
548 "couldn't create EGLContext");
549
550 // initialize our non-virtual displays
551 for (size_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {
552 DisplayDevice::DisplayType type((DisplayDevice::DisplayType)i);
553 // set-up the displays that are already connected
554 if (mHwc->isConnected(i) || type==DisplayDevice::DISPLAY_PRIMARY) {
555 // All non-virtual displays are currently considered secure.
556 bool isSecure = true;
557 createBuiltinDisplayLocked(type);
558 wp<IBinder> token = mBuiltinDisplays[i];
559
560 sp<IGraphicBufferProducer> producer;
561 sp<IGraphicBufferConsumer> consumer;
Mathias Agopian0556d792017-03-22 15:49:32 -0700562 BufferQueue::createBufferQueue(&producer, &consumer);
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000563
564 sp<FramebufferSurface> fbs = new FramebufferSurface(*mHwc, i,
565 consumer);
566 int32_t hwcId = allocateHwcDisplayId(type);
567 sp<DisplayDevice> hw = new DisplayDevice(this,
568 type, hwcId, mHwc->getFormat(hwcId), isSecure, token,
569 fbs, producer,
Courtney Goeltzenleuchter4f20f9c2017-04-06 08:18:34 -0600570 mRenderEngine->getEGLConfig(), false);
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000571 if (i > DisplayDevice::DISPLAY_PRIMARY) {
572 // FIXME: currently we don't get blank/unblank requests
573 // for displays other than the main display, so we always
574 // assume a connected display is unblanked.
575 ALOGD("marking display %zu as acquired/unblanked", i);
576 hw->setPowerMode(HWC_POWER_MODE_NORMAL);
577 }
578 mDisplays.add(token, hw);
579 }
580 }
581
582 // make the GLContext current so that we can create textures when creating Layers
583 // (which may happens before we render something)
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700584 getDefaultDisplayDeviceLocked()->makeCurrent(mEGLDisplay, mEGLContext);
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000585
586 mEventControlThread = new EventControlThread(this);
587 mEventControlThread->run("EventControl", PRIORITY_URGENT_DISPLAY);
588
589 // set a fake vsync period if there is no HWComposer
590 if (mHwc->initCheck() != NO_ERROR) {
591 mPrimaryDispSync.setPeriod(16666667);
592 }
593
594 // initialize our drawing state
595 mDrawingState = mCurrentState;
596
597 // set initial conditions (e.g. unblank default device)
598 initializeDisplays();
599
600 mRenderEngine->primeCache();
601
Wei Wangf9b05ee2017-07-19 20:59:39 -0700602 // Inform native graphics APIs that the present timestamp is NOT supported:
603 mStartPropertySetThread = new StartPropertySetThread(false);
604 if (mStartPropertySetThread->Start() != NO_ERROR) {
605 ALOGE("Run StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800606 }
607
608 ALOGV("Done initializing");
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000609}
610
611int32_t SurfaceFlinger::allocateHwcDisplayId(DisplayDevice::DisplayType type) {
612 return (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) ?
613 type : mHwc->allocateDisplayId();
614}
615
616void SurfaceFlinger::startBootAnim() {
Wei Wangb254fa32017-01-31 17:43:23 -0800617 // Start boot animation service by setting a property mailbox
618 // if property setting thread is already running, Start() will be just a NOP
Wei Wangf9b05ee2017-07-19 20:59:39 -0700619 mStartPropertySetThread->Start();
Wei Wangb254fa32017-01-31 17:43:23 -0800620 // Wait until property was set
Wei Wangf9b05ee2017-07-19 20:59:39 -0700621 if (mStartPropertySetThread->join() != NO_ERROR) {
622 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800623 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000624}
625
626size_t SurfaceFlinger::getMaxTextureSize() const {
627 return mRenderEngine->getMaxTextureSize();
628}
629
630size_t SurfaceFlinger::getMaxViewportDims() const {
631 return mRenderEngine->getMaxViewportDims();
632}
633
634// ----------------------------------------------------------------------------
635
636bool SurfaceFlinger::authenticateSurfaceTexture(
637 const sp<IGraphicBufferProducer>& bufferProducer) const {
638 Mutex::Autolock _l(mStateLock);
Robert Carr0d480722017-01-10 16:42:54 -0800639 return authenticateSurfaceTextureLocked(bufferProducer);
640}
641
642bool SurfaceFlinger::authenticateSurfaceTextureLocked(
643 const sp<IGraphicBufferProducer>& bufferProducer) const {
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000644 sp<IBinder> surfaceTextureBinder(IInterface::asBinder(bufferProducer));
645 return mGraphicBufferProducerList.indexOf(surfaceTextureBinder) >= 0;
646}
647
Brian Anderson6b376712017-04-04 10:51:39 -0700648status_t SurfaceFlinger::getSupportedFrameTimestamps(
649 std::vector<FrameEvent>* outSupported) const {
650 *outSupported = {
651 FrameEvent::REQUESTED_PRESENT,
652 FrameEvent::ACQUIRE,
653 FrameEvent::LATCH,
654 FrameEvent::FIRST_REFRESH_START,
655 FrameEvent::LAST_REFRESH_START,
656 FrameEvent::GPU_COMPOSITION_DONE,
657 FrameEvent::DEQUEUE_READY,
658 FrameEvent::RELEASE,
659 };
660 return NO_ERROR;
661}
662
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000663status_t SurfaceFlinger::getDisplayConfigs(const sp<IBinder>& display,
664 Vector<DisplayInfo>* configs) {
665 if ((configs == NULL) || (display.get() == NULL)) {
666 return BAD_VALUE;
667 }
668
669 int32_t type = getDisplayType(display);
670 if (type < 0) return type;
671
672 // TODO: Not sure if display density should handled by SF any longer
673 class Density {
674 static int getDensityFromProperty(char const* propName) {
675 char property[PROPERTY_VALUE_MAX];
676 int density = 0;
677 if (property_get(propName, property, NULL) > 0) {
678 density = atoi(property);
679 }
680 return density;
681 }
682 public:
683 static int getEmuDensity() {
684 return getDensityFromProperty("qemu.sf.lcd_density"); }
685 static int getBuildDensity() {
686 return getDensityFromProperty("ro.sf.lcd_density"); }
687 };
688
689 configs->clear();
690
691 const Vector<HWComposer::DisplayConfig>& hwConfigs =
692 getHwComposer().getConfigs(type);
693 for (size_t c = 0; c < hwConfigs.size(); ++c) {
694 const HWComposer::DisplayConfig& hwConfig = hwConfigs[c];
695 DisplayInfo info = DisplayInfo();
696
697 float xdpi = hwConfig.xdpi;
698 float ydpi = hwConfig.ydpi;
699
700 if (type == DisplayDevice::DISPLAY_PRIMARY) {
701 // The density of the device is provided by a build property
702 float density = Density::getBuildDensity() / 160.0f;
703 if (density == 0) {
704 // the build doesn't provide a density -- this is wrong!
705 // use xdpi instead
706 ALOGE("ro.sf.lcd_density must be defined as a build property");
707 density = xdpi / 160.0f;
708 }
709 if (Density::getEmuDensity()) {
710 // if "qemu.sf.lcd_density" is specified, it overrides everything
711 xdpi = ydpi = density = Density::getEmuDensity();
712 density /= 160.0f;
713 }
714 info.density = density;
715
716 // TODO: this needs to go away (currently needed only by webkit)
717 sp<const DisplayDevice> hw(getDefaultDisplayDevice());
718 info.orientation = hw->getOrientation();
719 } else {
720 // TODO: where should this value come from?
721 static const int TV_DENSITY = 213;
722 info.density = TV_DENSITY / 160.0f;
723 info.orientation = 0;
724 }
725
726 info.w = hwConfig.width;
727 info.h = hwConfig.height;
728 info.xdpi = xdpi;
729 info.ydpi = ydpi;
730 info.fps = float(1e9 / hwConfig.refresh);
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800731 info.appVsyncOffset = vsyncPhaseOffsetNs;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000732
733 // This is how far in advance a buffer must be queued for
734 // presentation at a given time. If you want a buffer to appear
735 // on the screen at time N, you must submit the buffer before
736 // (N - presentationDeadline).
737 //
738 // Normally it's one full refresh period (to give SF a chance to
739 // latch the buffer), but this can be reduced by configuring a
740 // DispSync offset. Any additional delays introduced by the hardware
741 // composer or panel must be accounted for here.
742 //
743 // We add an additional 1ms to allow for processing time and
744 // differences between the ideal and actual refresh rate.
745 info.presentationDeadline =
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800746 hwConfig.refresh - sfVsyncPhaseOffsetNs + 1000000;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000747
748 // All non-virtual displays are currently considered secure.
749 info.secure = true;
750
751 configs->push_back(info);
752 }
753
754 return NO_ERROR;
755}
756
757status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>& /* display */,
758 DisplayStatInfo* stats) {
759 if (stats == NULL) {
760 return BAD_VALUE;
761 }
762
763 // FIXME for now we always return stats for the primary display
764 memset(stats, 0, sizeof(*stats));
765 stats->vsyncTime = mPrimaryDispSync.computeNextRefresh(0);
766 stats->vsyncPeriod = mPrimaryDispSync.getPeriod();
767 return NO_ERROR;
768}
769
770int SurfaceFlinger::getActiveConfig(const sp<IBinder>& display) {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700771 sp<const DisplayDevice> device(getDisplayDevice(display));
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000772 if (device != NULL) {
773 return device->getActiveConfig();
774 }
775 return BAD_VALUE;
776}
777
778void SurfaceFlinger::setActiveConfigInternal(const sp<DisplayDevice>& hw, int mode) {
779 ALOGD("Set active config mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(),
780 this);
781 int32_t type = hw->getDisplayType();
782 int currentMode = hw->getActiveConfig();
783
784 if (mode == currentMode) {
785 ALOGD("Screen type=%d is already mode=%d", hw->getDisplayType(), mode);
786 return;
787 }
788
789 if (type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
790 ALOGW("Trying to set config for virtual display");
791 return;
792 }
793
794 hw->setActiveConfig(mode);
795 getHwComposer().setActiveConfig(type, mode);
796}
797
798status_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& display, int mode) {
799 class MessageSetActiveConfig: public MessageBase {
800 SurfaceFlinger& mFlinger;
801 sp<IBinder> mDisplay;
802 int mMode;
803 public:
804 MessageSetActiveConfig(SurfaceFlinger& flinger, const sp<IBinder>& disp,
805 int mode) :
806 mFlinger(flinger), mDisplay(disp) { mMode = mode; }
807 virtual bool handler() {
808 Vector<DisplayInfo> configs;
809 mFlinger.getDisplayConfigs(mDisplay, &configs);
810 if (mMode < 0 || mMode >= static_cast<int>(configs.size())) {
811 ALOGE("Attempt to set active config = %d for display with %zu configs",
812 mMode, configs.size());
813 }
814 sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
815 if (hw == NULL) {
816 ALOGE("Attempt to set active config = %d for null display %p",
817 mMode, mDisplay.get());
818 } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) {
819 ALOGW("Attempt to set active config = %d for virtual display",
820 mMode);
821 } else {
822 mFlinger.setActiveConfigInternal(hw, mMode);
823 }
824 return true;
825 }
826 };
827 sp<MessageBase> msg = new MessageSetActiveConfig(*this, display, mode);
828 postMessageSync(msg);
829 return NO_ERROR;
830}
831
832status_t SurfaceFlinger::getDisplayColorModes(const sp<IBinder>& display,
833 Vector<android_color_mode_t>* outColorModes) {
834 if (outColorModes == nullptr || display.get() == nullptr) {
835 return BAD_VALUE;
836 }
837
838 int32_t type = getDisplayType(display);
839 if (type < 0) return type;
840
841 std::set<android_color_mode_t> colorModes;
842 for (const HWComposer::DisplayConfig& hwConfig : getHwComposer().getConfigs(type)) {
843 colorModes.insert(hwConfig.colorMode);
844 }
845
846 outColorModes->clear();
847 std::copy(colorModes.cbegin(), colorModes.cend(), std::back_inserter(*outColorModes));
848
849 return NO_ERROR;
850}
851
852android_color_mode_t SurfaceFlinger::getActiveColorMode(const sp<IBinder>& display) {
853 if (display.get() == nullptr) return static_cast<android_color_mode_t>(BAD_VALUE);
854
855 int32_t type = getDisplayType(display);
856 if (type < 0) return static_cast<android_color_mode_t>(type);
857
858 return getHwComposer().getColorMode(type);
859}
860
861status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& display,
862 android_color_mode_t colorMode) {
863 if (display.get() == nullptr || colorMode < 0) {
864 return BAD_VALUE;
865 }
866
867 int32_t type = getDisplayType(display);
868 if (type < 0) return type;
869 const Vector<HWComposer::DisplayConfig>& hwConfigs = getHwComposer().getConfigs(type);
870 HWComposer::DisplayConfig desiredConfig = hwConfigs[getHwComposer().getCurrentConfig(type)];
871 desiredConfig.colorMode = colorMode;
872 for (size_t c = 0; c < hwConfigs.size(); ++c) {
873 const HWComposer::DisplayConfig config = hwConfigs[c];
874 if (config == desiredConfig) {
875 return setActiveConfig(display, c);
876 }
877 }
878 return BAD_VALUE;
879}
880
881status_t SurfaceFlinger::clearAnimationFrameStats() {
882 Mutex::Autolock _l(mStateLock);
883 mAnimFrameTracker.clearStats();
884 return NO_ERROR;
885}
886
887status_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const {
888 Mutex::Autolock _l(mStateLock);
889 mAnimFrameTracker.getStats(outStats);
890 return NO_ERROR;
891}
892
893status_t SurfaceFlinger::getHdrCapabilities(const sp<IBinder>& /*display*/,
894 HdrCapabilities* outCapabilities) const {
895 // HWC1 does not provide HDR capabilities
896 *outCapabilities = HdrCapabilities();
897 return NO_ERROR;
898}
899
900status_t SurfaceFlinger::enableVSyncInjections(bool enable) {
901 if (enable == mInjectVSyncs) {
902 return NO_ERROR;
903 }
904
905 if (enable) {
906 mInjectVSyncs = enable;
907 ALOGV("VSync Injections enabled");
908 if (mVSyncInjector.get() == nullptr) {
909 mVSyncInjector = new InjectVSyncSource();
910 mInjectorEventThread = new EventThread(mVSyncInjector, *this, false);
911 }
912 mEventQueue.setEventThread(mInjectorEventThread);
913 } else {
914 mInjectVSyncs = enable;
915 ALOGV("VSync Injections disabled");
916 mEventQueue.setEventThread(mSFEventThread);
917 mVSyncInjector.clear();
918 }
919 return NO_ERROR;
920}
921
922status_t SurfaceFlinger::injectVSync(nsecs_t when) {
923 if (!mInjectVSyncs) {
924 ALOGE("VSync Injections not enabled");
925 return BAD_VALUE;
926 }
927 if (mInjectVSyncs && mInjectorEventThread.get() != nullptr) {
928 ALOGV("Injecting VSync inside SurfaceFlinger");
929 mVSyncInjector->onInjectSyncEvent(when);
930 }
931 return NO_ERROR;
932}
933
934// ----------------------------------------------------------------------------
935
Jorim Jaggiaaef0982017-06-08 23:55:29 -0700936sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection(
937 ISurfaceComposer::VsyncSource vsyncSource) {
938 if (vsyncSource == eVsyncSourceSurfaceFlinger) {
939 return mSFEventThread->createEventConnection();
940 } else {
941 return mEventThread->createEventConnection();
942 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000943}
944
945// ----------------------------------------------------------------------------
946
947void SurfaceFlinger::waitForEvent() {
948 mEventQueue.waitMessage();
949}
950
951void SurfaceFlinger::signalTransaction() {
952 mEventQueue.invalidate();
953}
954
955void SurfaceFlinger::signalLayerUpdate() {
956 mEventQueue.invalidate();
957}
958
959void SurfaceFlinger::signalRefresh() {
960 mEventQueue.refresh();
961}
962
963status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,
964 nsecs_t reltime, uint32_t /* flags */) {
965 return mEventQueue.postMessage(msg, reltime);
966}
967
968status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
969 nsecs_t reltime, uint32_t /* flags */) {
970 status_t res = mEventQueue.postMessage(msg, reltime);
971 if (res == NO_ERROR) {
972 msg->wait();
973 }
974 return res;
975}
976
977void SurfaceFlinger::run() {
978 do {
979 waitForEvent();
980 } while (true);
981}
982
983void SurfaceFlinger::enableHardwareVsync() {
984 Mutex::Autolock _l(mHWVsyncLock);
985 if (!mPrimaryHWVsyncEnabled && mHWVsyncAvailable) {
986 mPrimaryDispSync.beginResync();
987 //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true);
988 mEventControlThread->setVsyncEnabled(true);
989 mPrimaryHWVsyncEnabled = true;
990 }
991}
992
993void SurfaceFlinger::resyncToHardwareVsync(bool makeAvailable) {
994 Mutex::Autolock _l(mHWVsyncLock);
995
996 if (makeAvailable) {
997 mHWVsyncAvailable = true;
998 } else if (!mHWVsyncAvailable) {
999 // Hardware vsync is not currently available, so abort the resync
1000 // attempt for now
1001 return;
1002 }
1003
1004 const nsecs_t period =
1005 getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
1006
1007 mPrimaryDispSync.reset();
1008 mPrimaryDispSync.setPeriod(period);
1009
1010 if (!mPrimaryHWVsyncEnabled) {
1011 mPrimaryDispSync.beginResync();
1012 //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true);
1013 mEventControlThread->setVsyncEnabled(true);
1014 mPrimaryHWVsyncEnabled = true;
1015 }
1016}
1017
1018void SurfaceFlinger::disableHardwareVsync(bool makeUnavailable) {
1019 Mutex::Autolock _l(mHWVsyncLock);
1020 if (mPrimaryHWVsyncEnabled) {
1021 //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, false);
1022 mEventControlThread->setVsyncEnabled(false);
1023 mPrimaryDispSync.endResync();
1024 mPrimaryHWVsyncEnabled = false;
1025 }
1026 if (makeUnavailable) {
1027 mHWVsyncAvailable = false;
1028 }
1029}
1030
1031void SurfaceFlinger::resyncWithRateLimit() {
1032 static constexpr nsecs_t kIgnoreDelay = ms2ns(500);
1033 if (systemTime() - mLastSwapTime > kIgnoreDelay) {
1034 resyncToHardwareVsync(false);
1035 }
1036}
1037
Steven Thomas3cfac282017-02-06 12:29:30 -08001038void SurfaceFlinger::onVSyncReceived(HWComposer* /*composer*/, int type,
1039 nsecs_t timestamp) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001040 bool needsHwVsync = false;
1041
1042 { // Scope for the lock
1043 Mutex::Autolock _l(mHWVsyncLock);
1044 if (type == 0 && mPrimaryHWVsyncEnabled) {
1045 needsHwVsync = mPrimaryDispSync.addResyncSample(timestamp);
1046 }
1047 }
1048
1049 if (needsHwVsync) {
1050 enableHardwareVsync();
1051 } else {
1052 disableHardwareVsync(false);
1053 }
1054}
1055
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001056void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
Brian Andersond0010582017-03-07 13:20:31 -08001057 std::lock_guard<std::mutex> lock(mCompositorTimingLock);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001058 *compositorTiming = mCompositorTiming;
1059}
1060
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001061void SurfaceFlinger::onHotplugReceived(HWComposer* /*composer*/, int type, bool connected) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001062 if (mEventThread == NULL) {
1063 // This is a temporary workaround for b/7145521. A non-null pointer
1064 // does not mean EventThread has finished initializing, so this
1065 // is not a correct fix.
1066 ALOGW("WARNING: EventThread not started, ignoring hotplug");
1067 return;
1068 }
1069
1070 if (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
1071 Mutex::Autolock _l(mStateLock);
1072 if (connected) {
1073 createBuiltinDisplayLocked((DisplayDevice::DisplayType)type);
1074 } else {
1075 mCurrentState.displays.removeItem(mBuiltinDisplays[type]);
1076 mBuiltinDisplays[type].clear();
1077 }
1078 setTransactionFlags(eDisplayTransactionNeeded);
1079
1080 // Defer EventThread notification until SF has updated mDisplays.
1081 }
1082}
1083
Steven Thomas3cfac282017-02-06 12:29:30 -08001084void SurfaceFlinger::onInvalidateReceived(HWComposer* /*composer*/) {
1085 repaintEverything();
1086}
1087
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001088void SurfaceFlinger::eventControl(int disp, int event, int enabled) {
1089 ATRACE_CALL();
1090 getHwComposer().eventControl(disp, event, enabled);
1091}
1092
1093void SurfaceFlinger::onMessageReceived(int32_t what) {
1094 ATRACE_CALL();
1095 switch (what) {
1096 case MessageQueue::INVALIDATE: {
1097 bool refreshNeeded = handleMessageTransaction();
1098 refreshNeeded |= handleMessageInvalidate();
1099 refreshNeeded |= mRepaintEverything;
1100 if (refreshNeeded) {
1101 // Signal a refresh if a transaction modified the window state,
1102 // a new buffer was latched, or if HWC has requested a full
1103 // repaint
1104 signalRefresh();
1105 }
1106 break;
1107 }
1108 case MessageQueue::REFRESH: {
1109 handleMessageRefresh();
1110 break;
1111 }
1112 }
1113}
1114
1115bool SurfaceFlinger::handleMessageTransaction() {
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08001116 uint32_t transactionFlags = peekTransactionFlags();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001117 if (transactionFlags) {
1118 handleTransaction(transactionFlags);
1119 return true;
1120 }
1121 return false;
1122}
1123
1124bool SurfaceFlinger::handleMessageInvalidate() {
1125 ATRACE_CALL();
1126 return handlePageFlip();
1127}
1128
1129void SurfaceFlinger::handleMessageRefresh() {
1130 ATRACE_CALL();
1131
1132 nsecs_t refreshStartTime = systemTime(SYSTEM_TIME_MONOTONIC);
1133
Brian Andersond6927fb2016-07-23 23:37:30 -07001134 preComposition(refreshStartTime);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001135 rebuildLayerStacks();
1136 setUpHWComposer();
1137 doDebugFlashRegions();
1138 doComposition();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001139 postComposition(refreshStartTime);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001140}
1141
1142void SurfaceFlinger::doDebugFlashRegions()
1143{
1144 // is debugging enabled
1145 if (CC_LIKELY(!mDebugRegion))
1146 return;
1147
1148 const bool repaintEverything = mRepaintEverything;
1149 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1150 const sp<DisplayDevice>& hw(mDisplays[dpy]);
1151 if (hw->isDisplayOn()) {
1152 // transform the dirty region into this screen's coordinate space
1153 const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
1154 if (!dirtyRegion.isEmpty()) {
1155 // redraw the whole screen
1156 doComposeSurfaces(hw, Region(hw->bounds()));
1157
1158 // and draw the dirty region
1159 const int32_t height = hw->getHeight();
1160 RenderEngine& engine(getRenderEngine());
1161 engine.fillRegionWithColor(dirtyRegion, height, 1, 0, 1, 1);
1162
1163 hw->compositionComplete();
1164 hw->swapBuffers(getHwComposer());
1165 }
1166 }
1167 }
1168
1169 postFramebuffer();
1170
1171 if (mDebugRegion > 1) {
1172 usleep(mDebugRegion * 1000);
1173 }
1174
1175 HWComposer& hwc(getHwComposer());
1176 if (hwc.initCheck() == NO_ERROR) {
1177 status_t err = hwc.prepare();
1178 ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
1179 }
1180}
1181
Brian Andersond6927fb2016-07-23 23:37:30 -07001182void SurfaceFlinger::preComposition(nsecs_t refreshStartTime)
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001183{
1184 bool needExtraInvalidate = false;
Robert Carr2047fae2016-11-28 14:09:09 -08001185 mDrawingState.traverseInZOrder([&](Layer* layer) {
1186 if (layer->onPreComposition(refreshStartTime)) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001187 needExtraInvalidate = true;
1188 }
Robert Carr2047fae2016-11-28 14:09:09 -08001189 });
1190
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001191 if (needExtraInvalidate) {
1192 signalLayerUpdate();
1193 }
1194}
1195
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001196void SurfaceFlinger::updateCompositorTiming(
1197 nsecs_t vsyncPhase, nsecs_t vsyncInterval, nsecs_t compositeTime,
1198 std::shared_ptr<FenceTime>& presentFenceTime) {
1199 // Update queue of past composite+present times and determine the
1200 // most recently known composite to present latency.
1201 mCompositePresentTimes.push({compositeTime, presentFenceTime});
1202 nsecs_t compositeToPresentLatency = -1;
1203 while (!mCompositePresentTimes.empty()) {
1204 CompositePresentTime& cpt = mCompositePresentTimes.front();
1205 // Cached values should have been updated before calling this method,
1206 // which helps avoid duplicate syscalls.
1207 nsecs_t displayTime = cpt.display->getCachedSignalTime();
1208 if (displayTime == Fence::SIGNAL_TIME_PENDING) {
1209 break;
1210 }
1211 compositeToPresentLatency = displayTime - cpt.composite;
1212 mCompositePresentTimes.pop();
1213 }
1214
1215 // Don't let mCompositePresentTimes grow unbounded, just in case.
1216 while (mCompositePresentTimes.size() > 16) {
1217 mCompositePresentTimes.pop();
1218 }
1219
Brian Andersond0010582017-03-07 13:20:31 -08001220 setCompositorTimingSnapped(
1221 vsyncPhase, vsyncInterval, compositeToPresentLatency);
1222}
1223
1224void SurfaceFlinger::setCompositorTimingSnapped(nsecs_t vsyncPhase,
1225 nsecs_t vsyncInterval, nsecs_t compositeToPresentLatency) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001226 // Integer division and modulo round toward 0 not -inf, so we need to
1227 // treat negative and positive offsets differently.
Brian Andersond0010582017-03-07 13:20:31 -08001228 nsecs_t idealLatency = (sfVsyncPhaseOffsetNs > 0) ?
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001229 (vsyncInterval - (sfVsyncPhaseOffsetNs % vsyncInterval)) :
1230 ((-sfVsyncPhaseOffsetNs) % vsyncInterval);
1231
Brian Andersond0010582017-03-07 13:20:31 -08001232 // Just in case sfVsyncPhaseOffsetNs == -vsyncInterval.
1233 if (idealLatency <= 0) {
1234 idealLatency = vsyncInterval;
1235 }
1236
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001237 // Snap the latency to a value that removes scheduling jitter from the
1238 // composition and present times, which often have >1ms of jitter.
1239 // Reducing jitter is important if an app attempts to extrapolate
1240 // something (such as user input) to an accurate diasplay time.
1241 // Snapping also allows an app to precisely calculate sfVsyncPhaseOffsetNs
1242 // with (presentLatency % interval).
Brian Andersond0010582017-03-07 13:20:31 -08001243 nsecs_t bias = vsyncInterval / 2;
1244 int64_t extraVsyncs =
1245 (compositeToPresentLatency - idealLatency + bias) / vsyncInterval;
1246 nsecs_t snappedCompositeToPresentLatency = (extraVsyncs > 0) ?
1247 idealLatency + (extraVsyncs * vsyncInterval) : idealLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001248
Brian Andersond0010582017-03-07 13:20:31 -08001249 std::lock_guard<std::mutex> lock(mCompositorTimingLock);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001250 mCompositorTiming.deadline = vsyncPhase - idealLatency;
1251 mCompositorTiming.interval = vsyncInterval;
Brian Andersond0010582017-03-07 13:20:31 -08001252 mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001253}
1254
1255void SurfaceFlinger::postComposition(nsecs_t refreshStartTime)
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001256{
Brian Andersond6927fb2016-07-23 23:37:30 -07001257 const HWComposer& hwc = getHwComposer();
1258 const sp<const DisplayDevice> hw(getDefaultDisplayDevice());
1259
Brian Anderson3d4039d2016-09-23 16:31:30 -07001260 std::shared_ptr<FenceTime> glCompositionDoneFenceTime;
1261 if (getHwComposer().hasGlesComposition(hw->getHwcDisplayId())) {
1262 glCompositionDoneFenceTime =
1263 std::make_shared<FenceTime>(hw->getClientTargetAcquireFence());
1264 mGlCompositionDoneTimeline.push(glCompositionDoneFenceTime);
1265 } else {
1266 glCompositionDoneFenceTime = FenceTime::NO_FENCE;
1267 }
1268 mGlCompositionDoneTimeline.updateSignalTimes();
1269
Brian Anderson4e606e32017-03-16 15:34:57 -07001270 sp<Fence> retireFence = mHwc->getDisplayFence(HWC_DISPLAY_PRIMARY);
1271 auto retireFenceTime = std::make_shared<FenceTime>(retireFence);
Brian Anderson3d4039d2016-09-23 16:31:30 -07001272 mDisplayTimeline.push(retireFenceTime);
1273 mDisplayTimeline.updateSignalTimes();
Brian Andersond6927fb2016-07-23 23:37:30 -07001274
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001275 nsecs_t vsyncPhase = mPrimaryDispSync.computeNextRefresh(0);
1276 nsecs_t vsyncInterval = mPrimaryDispSync.getPeriod();
1277
1278 // We use the refreshStartTime which might be sampled a little later than
1279 // when we started doing work for this frame, but that should be okay
1280 // since updateCompositorTiming has snapping logic.
1281 updateCompositorTiming(
1282 vsyncPhase, vsyncInterval, refreshStartTime, retireFenceTime);
Brian Andersond0010582017-03-07 13:20:31 -08001283 CompositorTiming compositorTiming;
1284 {
1285 std::lock_guard<std::mutex> lock(mCompositorTimingLock);
1286 compositorTiming = mCompositorTiming;
1287 }
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001288
Robert Carr2047fae2016-11-28 14:09:09 -08001289 mDrawingState.traverseInZOrder([&](Layer* layer) {
Brian Anderson4e606e32017-03-16 15:34:57 -07001290 // TODO(brianderson): The retire fence is incorrectly passed in as the
1291 // present fence. Fix this if this file lives on.
Robert Carr2047fae2016-11-28 14:09:09 -08001292 bool frameLatched = layer->onPostComposition(glCompositionDoneFenceTime,
Brian Anderson4e606e32017-03-16 15:34:57 -07001293 retireFenceTime, compositorTiming);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001294 if (frameLatched) {
Robert Carr2047fae2016-11-28 14:09:09 -08001295 recordBufferingStats(layer->getName().string(),
1296 layer->getOccupancyHistory(false));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001297 }
Robert Carr2047fae2016-11-28 14:09:09 -08001298 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001299
Brian Anderson4e606e32017-03-16 15:34:57 -07001300 if (retireFence->isValid()) {
1301 if (mPrimaryDispSync.addPresentFence(retireFence)) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001302 enableHardwareVsync();
1303 } else {
1304 disableHardwareVsync(false);
1305 }
1306 }
1307
Fabien Sanglardcbf153b2017-03-10 17:57:12 -08001308 if (!hasSyncFramework) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001309 if (hw->isDisplayOn()) {
1310 enableHardwareVsync();
1311 }
1312 }
1313
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001314 if (mAnimCompositionPending) {
1315 mAnimCompositionPending = false;
1316
Brian Anderson3d4039d2016-09-23 16:31:30 -07001317 if (retireFenceTime->isValid()) {
1318 mAnimFrameTracker.setActualPresentFence(std::move(retireFenceTime));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001319 } else {
1320 // The HWC doesn't support present fences, so use the refresh
1321 // timestamp instead.
1322 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY);
1323 mAnimFrameTracker.setActualPresentTime(presentTime);
1324 }
1325 mAnimFrameTracker.advanceFrame();
1326 }
1327
1328 if (hw->getPowerMode() == HWC_POWER_MODE_OFF) {
1329 return;
1330 }
1331
1332 nsecs_t currentTime = systemTime();
1333 if (mHasPoweredOff) {
1334 mHasPoweredOff = false;
1335 } else {
1336 nsecs_t period = mPrimaryDispSync.getPeriod();
1337 nsecs_t elapsedTime = currentTime - mLastSwapTime;
1338 size_t numPeriods = static_cast<size_t>(elapsedTime / period);
1339 if (numPeriods < NUM_BUCKETS - 1) {
1340 mFrameBuckets[numPeriods] += elapsedTime;
1341 } else {
1342 mFrameBuckets[NUM_BUCKETS - 1] += elapsedTime;
1343 }
1344 mTotalTime += elapsedTime;
1345 }
1346 mLastSwapTime = currentTime;
1347}
1348
1349void SurfaceFlinger::rebuildLayerStacks() {
1350 // rebuild the visible layer list per screen
1351 if (CC_UNLIKELY(mVisibleRegionsDirty)) {
1352 ATRACE_CALL();
1353 mVisibleRegionsDirty = false;
1354 invalidateHwcGeometry();
1355
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001356 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1357 Region opaqueRegion;
1358 Region dirtyRegion;
1359 Vector< sp<Layer> > layersSortedByZ;
1360 const sp<DisplayDevice>& hw(mDisplays[dpy]);
1361 const Transform& tr(hw->getTransform());
1362 const Rect bounds(hw->getBounds());
1363 if (hw->isDisplayOn()) {
Robert Carr2047fae2016-11-28 14:09:09 -08001364 computeVisibleRegions(hw->getLayerStack(), dirtyRegion,
1365 opaqueRegion);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001366
Robert Carr2047fae2016-11-28 14:09:09 -08001367 mDrawingState.traverseInZOrder([&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07001368 if (layer->getLayerStack() == hw->getLayerStack()) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001369 Region drawRegion(tr.transform(
1370 layer->visibleNonTransparentRegion));
1371 drawRegion.andSelf(bounds);
1372 if (!drawRegion.isEmpty()) {
1373 layersSortedByZ.add(layer);
1374 }
1375 }
Robert Carr2047fae2016-11-28 14:09:09 -08001376 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001377 }
1378 hw->setVisibleLayersSortedByZ(layersSortedByZ);
1379 hw->undefinedRegion.set(bounds);
1380 hw->undefinedRegion.subtractSelf(tr.transform(opaqueRegion));
1381 hw->dirtyRegion.orSelf(dirtyRegion);
1382 }
1383 }
1384}
1385
1386void SurfaceFlinger::setUpHWComposer() {
1387 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1388 bool dirty = !mDisplays[dpy]->getDirtyRegion(false).isEmpty();
1389 bool empty = mDisplays[dpy]->getVisibleLayersSortedByZ().size() == 0;
1390 bool wasEmpty = !mDisplays[dpy]->lastCompositionHadVisibleLayers;
1391
1392 // If nothing has changed (!dirty), don't recompose.
1393 // If something changed, but we don't currently have any visible layers,
1394 // and didn't when we last did a composition, then skip it this time.
1395 // The second rule does two things:
1396 // - When all layers are removed from a display, we'll emit one black
1397 // frame, then nothing more until we get new layers.
1398 // - When a display is created with a private layer stack, we won't
1399 // emit any black frames until a layer is added to the layer stack.
1400 bool mustRecompose = dirty && !(empty && wasEmpty);
1401
1402 ALOGV_IF(mDisplays[dpy]->getDisplayType() == DisplayDevice::DISPLAY_VIRTUAL,
1403 "dpy[%zu]: %s composition (%sdirty %sempty %swasEmpty)", dpy,
1404 mustRecompose ? "doing" : "skipping",
1405 dirty ? "+" : "-",
1406 empty ? "+" : "-",
1407 wasEmpty ? "+" : "-");
1408
1409 mDisplays[dpy]->beginFrame(mustRecompose);
1410
1411 if (mustRecompose) {
1412 mDisplays[dpy]->lastCompositionHadVisibleLayers = !empty;
1413 }
1414 }
1415
1416 HWComposer& hwc(getHwComposer());
1417 if (hwc.initCheck() == NO_ERROR) {
1418 // build the h/w work list
1419 if (CC_UNLIKELY(mHwWorkListDirty)) {
1420 mHwWorkListDirty = false;
1421 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1422 sp<const DisplayDevice> hw(mDisplays[dpy]);
1423 const int32_t id = hw->getHwcDisplayId();
1424 if (id >= 0) {
1425 const Vector< sp<Layer> >& currentLayers(
1426 hw->getVisibleLayersSortedByZ());
1427 const size_t count = currentLayers.size();
1428 if (hwc.createWorkList(id, count) == NO_ERROR) {
1429 HWComposer::LayerListIterator cur = hwc.begin(id);
1430 const HWComposer::LayerListIterator end = hwc.end(id);
1431 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1432 const sp<Layer>& layer(currentLayers[i]);
1433 layer->setGeometry(hw, *cur);
1434 if (mDebugDisableHWC || mDebugRegion || mDaltonize || mHasColorMatrix) {
1435 cur->setSkip(true);
1436 }
1437 }
1438 }
1439 }
1440 }
1441 }
1442
1443 // set the per-frame data
1444 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1445 sp<const DisplayDevice> hw(mDisplays[dpy]);
1446 const int32_t id = hw->getHwcDisplayId();
1447 if (id >= 0) {
1448 const Vector< sp<Layer> >& currentLayers(
1449 hw->getVisibleLayersSortedByZ());
1450 const size_t count = currentLayers.size();
1451 HWComposer::LayerListIterator cur = hwc.begin(id);
1452 const HWComposer::LayerListIterator end = hwc.end(id);
1453 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1454 /*
1455 * update the per-frame h/w composer data for each layer
1456 * and build the transparent region of the FB
1457 */
1458 const sp<Layer>& layer(currentLayers[i]);
1459 layer->setPerFrameData(hw, *cur);
1460 }
1461 }
1462 }
1463
1464 // If possible, attempt to use the cursor overlay on each display.
1465 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1466 sp<const DisplayDevice> hw(mDisplays[dpy]);
1467 const int32_t id = hw->getHwcDisplayId();
1468 if (id >= 0) {
1469 const Vector< sp<Layer> >& currentLayers(
1470 hw->getVisibleLayersSortedByZ());
1471 const size_t count = currentLayers.size();
1472 HWComposer::LayerListIterator cur = hwc.begin(id);
1473 const HWComposer::LayerListIterator end = hwc.end(id);
1474 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1475 const sp<Layer>& layer(currentLayers[i]);
1476 if (layer->isPotentialCursor()) {
1477 cur->setIsCursorLayerHint();
1478 break;
1479 }
1480 }
1481 }
1482 }
1483
1484 status_t err = hwc.prepare();
1485 ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
1486
1487 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1488 sp<const DisplayDevice> hw(mDisplays[dpy]);
1489 hw->prepareFrame(hwc);
1490 }
1491 }
1492}
1493
1494void SurfaceFlinger::doComposition() {
1495 ATRACE_CALL();
1496 const bool repaintEverything = android_atomic_and(0, &mRepaintEverything);
1497 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1498 const sp<DisplayDevice>& hw(mDisplays[dpy]);
1499 if (hw->isDisplayOn()) {
1500 // transform the dirty region into this screen's coordinate space
1501 const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
1502
1503 // repaint the framebuffer (if needed)
1504 doDisplayComposition(hw, dirtyRegion);
1505
1506 hw->dirtyRegion.clear();
1507 hw->flip(hw->swapRegion);
1508 hw->swapRegion.clear();
1509 }
1510 // inform the h/w that we're done compositing
1511 hw->compositionComplete();
1512 }
1513 postFramebuffer();
1514}
1515
1516void SurfaceFlinger::postFramebuffer()
1517{
1518 ATRACE_CALL();
1519
1520 const nsecs_t now = systemTime();
1521 mDebugInSwapBuffers = now;
1522
1523 HWComposer& hwc(getHwComposer());
1524 if (hwc.initCheck() == NO_ERROR) {
1525 if (!hwc.supportsFramebufferTarget()) {
1526 // EGL spec says:
1527 // "surface must be bound to the calling thread's current context,
1528 // for the current rendering API."
1529 getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
1530 }
1531 hwc.commit();
1532 }
1533
1534 // make the default display current because the VirtualDisplayDevice code cannot
1535 // deal with dequeueBuffer() being called outside of the composition loop; however
1536 // the code below can call glFlush() which is allowed (and does in some case) call
1537 // dequeueBuffer().
1538 getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
1539
1540 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1541 sp<const DisplayDevice> hw(mDisplays[dpy]);
1542 const Vector< sp<Layer> >& currentLayers(hw->getVisibleLayersSortedByZ());
1543 hw->onSwapBuffersCompleted(hwc);
1544 const size_t count = currentLayers.size();
1545 int32_t id = hw->getHwcDisplayId();
1546 if (id >=0 && hwc.initCheck() == NO_ERROR) {
1547 HWComposer::LayerListIterator cur = hwc.begin(id);
1548 const HWComposer::LayerListIterator end = hwc.end(id);
1549 for (size_t i = 0; cur != end && i < count; ++i, ++cur) {
1550 currentLayers[i]->onLayerDisplayed(hw, &*cur);
1551 }
1552 } else {
1553 for (size_t i = 0; i < count; i++) {
1554 currentLayers[i]->onLayerDisplayed(hw, NULL);
1555 }
1556 }
1557 }
1558
1559 mLastSwapBufferTime = systemTime() - now;
1560 mDebugInSwapBuffers = 0;
1561
1562 uint32_t flipCount = getDefaultDisplayDevice()->getPageFlipCount();
1563 if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
1564 logFrameStats();
1565 }
1566}
1567
1568void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
1569{
1570 ATRACE_CALL();
1571
1572 // here we keep a copy of the drawing state (that is the state that's
1573 // going to be overwritten by handleTransactionLocked()) outside of
1574 // mStateLock so that the side-effects of the State assignment
1575 // don't happen with mStateLock held (which can cause deadlocks).
1576 State drawingState(mDrawingState);
1577
1578 Mutex::Autolock _l(mStateLock);
1579 const nsecs_t now = systemTime();
1580 mDebugInTransaction = now;
1581
1582 // Here we're guaranteed that some transaction flags are set
1583 // so we can call handleTransactionLocked() unconditionally.
1584 // We call getTransactionFlags(), which will also clear the flags,
1585 // with mStateLock held to guarantee that mCurrentState won't change
1586 // until the transaction is committed.
1587
1588 transactionFlags = getTransactionFlags(eTransactionMask);
1589 handleTransactionLocked(transactionFlags);
1590
1591 mLastTransactionTime = systemTime() - now;
1592 mDebugInTransaction = 0;
1593 invalidateHwcGeometry();
1594 // here the transaction has been committed
1595}
1596
1597void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
1598{
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001599 // Notify all layers of available frames
Robert Carr2047fae2016-11-28 14:09:09 -08001600 mCurrentState.traverseInZOrder([](Layer* layer) {
1601 layer->notifyAvailableFrames();
1602 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001603
1604 /*
1605 * Traversal of the children
1606 * (perform the transaction for each of them if needed)
1607 */
1608
1609 if (transactionFlags & eTraversalNeeded) {
Robert Carr2047fae2016-11-28 14:09:09 -08001610 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001611 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
Robert Carr2047fae2016-11-28 14:09:09 -08001612 if (!trFlags) return;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001613
1614 const uint32_t flags = layer->doTransaction(0);
1615 if (flags & Layer::eVisibleRegion)
1616 mVisibleRegionsDirty = true;
Robert Carr2047fae2016-11-28 14:09:09 -08001617 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001618 }
1619
1620 /*
1621 * Perform display own transactions if needed
1622 */
1623
1624 if (transactionFlags & eDisplayTransactionNeeded) {
1625 // here we take advantage of Vector's copy-on-write semantics to
1626 // improve performance by skipping the transaction entirely when
1627 // know that the lists are identical
1628 const KeyedVector< wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
1629 const KeyedVector< wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
1630 if (!curr.isIdenticalTo(draw)) {
1631 mVisibleRegionsDirty = true;
1632 const size_t cc = curr.size();
1633 size_t dc = draw.size();
1634
1635 // find the displays that were removed
1636 // (ie: in drawing state but not in current state)
1637 // also handle displays that changed
1638 // (ie: displays that are in both lists)
1639 for (size_t i=0 ; i<dc ; i++) {
1640 const ssize_t j = curr.indexOfKey(draw.keyAt(i));
1641 if (j < 0) {
1642 // in drawing state but not in current state
1643 if (!draw[i].isMainDisplay()) {
1644 // Call makeCurrent() on the primary display so we can
1645 // be sure that nothing associated with this display
1646 // is current.
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001647 const sp<const DisplayDevice> defaultDisplay(getDefaultDisplayDeviceLocked());
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001648 defaultDisplay->makeCurrent(mEGLDisplay, mEGLContext);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001649 sp<DisplayDevice> hw(getDisplayDeviceLocked(draw.keyAt(i)));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001650 if (hw != NULL)
1651 hw->disconnect(getHwComposer());
1652 if (draw[i].type < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES)
1653 mEventThread->onHotplugReceived(draw[i].type, false);
1654 mDisplays.removeItem(draw.keyAt(i));
1655 } else {
1656 ALOGW("trying to remove the main display");
1657 }
1658 } else {
1659 // this display is in both lists. see if something changed.
1660 const DisplayDeviceState& state(curr[j]);
1661 const wp<IBinder>& display(curr.keyAt(j));
1662 const sp<IBinder> state_binder = IInterface::asBinder(state.surface);
1663 const sp<IBinder> draw_binder = IInterface::asBinder(draw[i].surface);
1664 if (state_binder != draw_binder) {
1665 // changing the surface is like destroying and
1666 // recreating the DisplayDevice, so we just remove it
1667 // from the drawing state, so that it get re-added
1668 // below.
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001669 sp<DisplayDevice> hw(getDisplayDeviceLocked(display));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001670 if (hw != NULL)
1671 hw->disconnect(getHwComposer());
1672 mDisplays.removeItem(display);
1673 mDrawingState.displays.removeItemsAt(i);
1674 dc--; i--;
1675 // at this point we must loop to the next item
1676 continue;
1677 }
1678
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001679 const sp<DisplayDevice> disp(getDisplayDeviceLocked(display));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001680 if (disp != NULL) {
1681 if (state.layerStack != draw[i].layerStack) {
1682 disp->setLayerStack(state.layerStack);
1683 }
1684 if ((state.orientation != draw[i].orientation)
1685 || (state.viewport != draw[i].viewport)
1686 || (state.frame != draw[i].frame))
1687 {
1688 disp->setProjection(state.orientation,
1689 state.viewport, state.frame);
1690 }
1691 if (state.width != draw[i].width || state.height != draw[i].height) {
1692 disp->setDisplaySize(state.width, state.height);
1693 }
1694 }
1695 }
1696 }
1697
1698 // find displays that were added
1699 // (ie: in current state but not in drawing state)
1700 for (size_t i=0 ; i<cc ; i++) {
1701 if (draw.indexOfKey(curr.keyAt(i)) < 0) {
1702 const DisplayDeviceState& state(curr[i]);
1703
1704 sp<DisplaySurface> dispSurface;
1705 sp<IGraphicBufferProducer> producer;
1706 sp<IGraphicBufferProducer> bqProducer;
1707 sp<IGraphicBufferConsumer> bqConsumer;
Mathias Agopian0556d792017-03-22 15:49:32 -07001708 BufferQueue::createBufferQueue(&bqProducer, &bqConsumer);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001709
1710 int32_t hwcDisplayId = -1;
1711 if (state.isVirtualDisplay()) {
1712 // Virtual displays without a surface are dormant:
1713 // they have external state (layer stack, projection,
1714 // etc.) but no internal state (i.e. a DisplayDevice).
1715 if (state.surface != NULL) {
1716
1717 int width = 0;
1718 int status = state.surface->query(
1719 NATIVE_WINDOW_WIDTH, &width);
1720 ALOGE_IF(status != NO_ERROR,
1721 "Unable to query width (%d)", status);
1722 int height = 0;
1723 status = state.surface->query(
1724 NATIVE_WINDOW_HEIGHT, &height);
1725 ALOGE_IF(status != NO_ERROR,
1726 "Unable to query height (%d)", status);
1727 if (mUseHwcVirtualDisplays &&
Fabien Sanglardc8e387e2017-03-10 10:30:28 -08001728 (SurfaceFlinger::maxVirtualDisplaySize == 0 ||
1729 (width <= static_cast<int>(SurfaceFlinger::maxVirtualDisplaySize) &&
1730 height <= static_cast<int>(SurfaceFlinger::maxVirtualDisplaySize)))) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001731 hwcDisplayId = allocateHwcDisplayId(state.type);
1732 }
1733
1734 sp<VirtualDisplaySurface> vds = new VirtualDisplaySurface(
1735 *mHwc, hwcDisplayId, state.surface,
1736 bqProducer, bqConsumer, state.displayName);
1737
1738 dispSurface = vds;
1739 producer = vds;
1740 }
1741 } else {
1742 ALOGE_IF(state.surface!=NULL,
1743 "adding a supported display, but rendering "
1744 "surface is provided (%p), ignoring it",
1745 state.surface.get());
1746 hwcDisplayId = allocateHwcDisplayId(state.type);
1747 // for supported (by hwc) displays we provide our
1748 // own rendering surface
1749 dispSurface = new FramebufferSurface(*mHwc, state.type,
1750 bqConsumer);
1751 producer = bqProducer;
1752 }
1753
1754 const wp<IBinder>& display(curr.keyAt(i));
1755 if (dispSurface != NULL) {
1756 sp<DisplayDevice> hw = new DisplayDevice(this,
1757 state.type, hwcDisplayId,
1758 mHwc->getFormat(hwcDisplayId), state.isSecure,
1759 display, dispSurface, producer,
Courtney Goeltzenleuchter4f20f9c2017-04-06 08:18:34 -06001760 mRenderEngine->getEGLConfig(), false);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001761 hw->setLayerStack(state.layerStack);
1762 hw->setProjection(state.orientation,
1763 state.viewport, state.frame);
1764 hw->setDisplayName(state.displayName);
1765 mDisplays.add(display, hw);
1766 if (state.isVirtualDisplay()) {
1767 if (hwcDisplayId >= 0) {
1768 mHwc->setVirtualDisplayProperties(hwcDisplayId,
1769 hw->getWidth(), hw->getHeight(),
1770 hw->getFormat());
1771 }
1772 } else {
1773 mEventThread->onHotplugReceived(state.type, true);
1774 }
1775 }
1776 }
1777 }
1778 }
1779 }
1780
1781 if (transactionFlags & (eTraversalNeeded|eDisplayTransactionNeeded)) {
1782 // The transform hint might have changed for some layers
1783 // (either because a display has changed, or because a layer
1784 // as changed).
1785 //
1786 // Walk through all the layers in currentLayers,
1787 // and update their transform hint.
1788 //
1789 // If a layer is visible only on a single display, then that
1790 // display is used to calculate the hint, otherwise we use the
1791 // default display.
1792 //
1793 // NOTE: we do this here, rather than in rebuildLayerStacks() so that
1794 // the hint is set before we acquire a buffer from the surface texture.
1795 //
1796 // NOTE: layer transactions have taken place already, so we use their
1797 // drawing state. However, SurfaceFlinger's own transaction has not
1798 // happened yet, so we must use the current state layer list
1799 // (soon to become the drawing state list).
1800 //
1801 sp<const DisplayDevice> disp;
1802 uint32_t currentlayerStack = 0;
Robert Carr2047fae2016-11-28 14:09:09 -08001803 bool first = true;
1804 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001805 // NOTE: we rely on the fact that layers are sorted by
1806 // layerStack first (so we don't have to traverse the list
1807 // of displays for every layer).
Robert Carr1f0a16a2016-10-24 16:27:39 -07001808 uint32_t layerStack = layer->getLayerStack();
Robert Carr2047fae2016-11-28 14:09:09 -08001809 if (first || currentlayerStack != layerStack) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001810 currentlayerStack = layerStack;
1811 // figure out if this layerstack is mirrored
1812 // (more than one display) if so, pick the default display,
1813 // if not, pick the only display it's on.
1814 disp.clear();
1815 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1816 sp<const DisplayDevice> hw(mDisplays[dpy]);
1817 if (hw->getLayerStack() == currentlayerStack) {
1818 if (disp == NULL) {
1819 disp = hw;
1820 } else {
1821 disp = NULL;
1822 break;
1823 }
1824 }
1825 }
1826 }
1827 if (disp == NULL) {
1828 // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
1829 // redraw after transform hint changes. See bug 8508397.
1830
1831 // could be null when this layer is using a layerStack
1832 // that is not visible on any display. Also can occur at
1833 // screen off/on times.
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001834 disp = getDefaultDisplayDeviceLocked();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001835 }
1836 layer->updateTransformHint(disp);
Robert Carr2047fae2016-11-28 14:09:09 -08001837
1838 first = false;
1839 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001840 }
1841
1842
1843 /*
1844 * Perform our own transaction if needed
1845 */
Robert Carr1f0a16a2016-10-24 16:27:39 -07001846
1847 if (mLayersAdded) {
1848 mLayersAdded = false;
1849 // Layers have been added.
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001850 mVisibleRegionsDirty = true;
1851 }
1852
1853 // some layers might have been removed, so
1854 // we need to update the regions they're exposing.
1855 if (mLayersRemoved) {
1856 mLayersRemoved = false;
1857 mVisibleRegionsDirty = true;
Robert Carr2047fae2016-11-28 14:09:09 -08001858 mDrawingState.traverseInZOrder([&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07001859 if (mLayersPendingRemoval.indexOf(layer) >= 0) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001860 // this layer is not visible anymore
1861 // TODO: we could traverse the tree from front to back and
1862 // compute the actual visible region
1863 // TODO: we could cache the transformed region
Robert Carr1f0a16a2016-10-24 16:27:39 -07001864 Region visibleReg;
1865 visibleReg.set(layer->computeScreenBounds());
1866 invalidateLayerStack(layer->getLayerStack(), visibleReg);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001867 }
Robert Carr2047fae2016-11-28 14:09:09 -08001868 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001869 }
1870
1871 commitTransaction();
1872
1873 updateCursorAsync();
1874}
1875
1876void SurfaceFlinger::updateCursorAsync()
1877{
1878 HWComposer& hwc(getHwComposer());
1879 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1880 sp<const DisplayDevice> hw(mDisplays[dpy]);
1881 const int32_t id = hw->getHwcDisplayId();
1882 if (id < 0) {
1883 continue;
1884 }
1885 const Vector< sp<Layer> >& currentLayers(
1886 hw->getVisibleLayersSortedByZ());
1887 const size_t count = currentLayers.size();
1888 HWComposer::LayerListIterator cur = hwc.begin(id);
1889 const HWComposer::LayerListIterator end = hwc.end(id);
1890 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1891 if (cur->getCompositionType() != HWC_CURSOR_OVERLAY) {
1892 continue;
1893 }
1894 const sp<Layer>& layer(currentLayers[i]);
1895 Rect cursorPos = layer->getPosition(hw);
1896 hwc.setCursorPositionAsync(id, cursorPos);
1897 break;
1898 }
1899 }
1900}
1901
1902void SurfaceFlinger::commitTransaction()
1903{
1904 if (!mLayersPendingRemoval.isEmpty()) {
1905 // Notify removed layers now that they can't be drawn from
Robert Carr1f0a16a2016-10-24 16:27:39 -07001906 for (const auto& l : mLayersPendingRemoval) {
1907 recordBufferingStats(l->getName().string(),
1908 l->getOccupancyHistory(true));
1909 l->onRemoved();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001910 }
1911 mLayersPendingRemoval.clear();
1912 }
1913
1914 // If this transaction is part of a window animation then the next frame
1915 // we composite should be considered an animation as well.
1916 mAnimCompositionPending = mAnimTransactionPending;
1917
1918 mDrawingState = mCurrentState;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001919 mDrawingState.traverseInZOrder([](Layer* layer) {
1920 layer->commitChildList();
1921 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001922 mTransactionPending = false;
1923 mAnimTransactionPending = false;
1924 mTransactionCV.broadcast();
1925}
1926
Robert Carr2047fae2016-11-28 14:09:09 -08001927void SurfaceFlinger::computeVisibleRegions(uint32_t layerStack,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001928 Region& outDirtyRegion, Region& outOpaqueRegion)
1929{
1930 ATRACE_CALL();
1931
1932 Region aboveOpaqueLayers;
1933 Region aboveCoveredLayers;
1934 Region dirty;
1935
1936 outDirtyRegion.clear();
1937
Robert Carr2047fae2016-11-28 14:09:09 -08001938 mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001939 // start with the whole surface at its current location
1940 const Layer::State& s(layer->getDrawingState());
1941
1942 // only consider the layers on the given layer stack
Robert Carr1f0a16a2016-10-24 16:27:39 -07001943 if (layer->getLayerStack() != layerStack)
Robert Carr2047fae2016-11-28 14:09:09 -08001944 return;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001945
1946 /*
1947 * opaqueRegion: area of a surface that is fully opaque.
1948 */
1949 Region opaqueRegion;
1950
1951 /*
1952 * visibleRegion: area of a surface that is visible on screen
1953 * and not fully transparent. This is essentially the layer's
1954 * footprint minus the opaque regions above it.
1955 * Areas covered by a translucent surface are considered visible.
1956 */
1957 Region visibleRegion;
1958
1959 /*
1960 * coveredRegion: area of a surface that is covered by all
1961 * visible regions above it (which includes the translucent areas).
1962 */
1963 Region coveredRegion;
1964
1965 /*
1966 * transparentRegion: area of a surface that is hinted to be completely
1967 * transparent. This is only used to tell when the layer has no visible
1968 * non-transparent regions and can be removed from the layer list. It
1969 * does not affect the visibleRegion of this layer or any layers
1970 * beneath it. The hint may not be correct if apps don't respect the
1971 * SurfaceView restrictions (which, sadly, some don't).
1972 */
1973 Region transparentRegion;
1974
1975
1976 // handle hidden surfaces by setting the visible region to empty
1977 if (CC_LIKELY(layer->isVisible())) {
1978 const bool translucent = !layer->isOpaque(s);
Robert Carr1f0a16a2016-10-24 16:27:39 -07001979 Rect bounds(layer->computeScreenBounds());
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001980 visibleRegion.set(bounds);
Robert Carr1f0a16a2016-10-24 16:27:39 -07001981 Transform tr = layer->getTransform();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001982 if (!visibleRegion.isEmpty()) {
1983 // Remove the transparent area from the visible region
1984 if (translucent) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001985 if (tr.preserveRects()) {
1986 // transform the transparent region
1987 transparentRegion = tr.transform(s.activeTransparentRegion);
1988 } else {
1989 // transformation too complex, can't do the
1990 // transparent region optimization.
1991 transparentRegion.clear();
1992 }
1993 }
1994
1995 // compute the opaque region
Robert Carr1f0a16a2016-10-24 16:27:39 -07001996 const int32_t layerOrientation = tr.getOrientation();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001997 if (s.alpha==255 && !translucent &&
1998 ((layerOrientation & Transform::ROT_INVALID) == false)) {
1999 // the opaque region is the layer's footprint
2000 opaqueRegion = visibleRegion;
2001 }
2002 }
2003 }
2004
2005 // Clip the covered region to the visible region
2006 coveredRegion = aboveCoveredLayers.intersect(visibleRegion);
2007
2008 // Update aboveCoveredLayers for next (lower) layer
2009 aboveCoveredLayers.orSelf(visibleRegion);
2010
2011 // subtract the opaque region covered by the layers above us
2012 visibleRegion.subtractSelf(aboveOpaqueLayers);
2013
2014 // compute this layer's dirty region
2015 if (layer->contentDirty) {
2016 // we need to invalidate the whole region
2017 dirty = visibleRegion;
2018 // as well, as the old visible region
2019 dirty.orSelf(layer->visibleRegion);
2020 layer->contentDirty = false;
2021 } else {
2022 /* compute the exposed region:
2023 * the exposed region consists of two components:
2024 * 1) what's VISIBLE now and was COVERED before
2025 * 2) what's EXPOSED now less what was EXPOSED before
2026 *
2027 * note that (1) is conservative, we start with the whole
2028 * visible region but only keep what used to be covered by
2029 * something -- which mean it may have been exposed.
2030 *
2031 * (2) handles areas that were not covered by anything but got
2032 * exposed because of a resize.
2033 */
2034 const Region newExposed = visibleRegion - coveredRegion;
2035 const Region oldVisibleRegion = layer->visibleRegion;
2036 const Region oldCoveredRegion = layer->coveredRegion;
2037 const Region oldExposed = oldVisibleRegion - oldCoveredRegion;
2038 dirty = (visibleRegion&oldCoveredRegion) | (newExposed-oldExposed);
2039 }
2040 dirty.subtractSelf(aboveOpaqueLayers);
2041
2042 // accumulate to the screen dirty region
2043 outDirtyRegion.orSelf(dirty);
2044
2045 // Update aboveOpaqueLayers for next (lower) layer
2046 aboveOpaqueLayers.orSelf(opaqueRegion);
2047
2048 // Store the visible region in screen space
2049 layer->setVisibleRegion(visibleRegion);
2050 layer->setCoveredRegion(coveredRegion);
2051 layer->setVisibleNonTransparentRegion(
2052 visibleRegion.subtract(transparentRegion));
Robert Carr2047fae2016-11-28 14:09:09 -08002053 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002054
2055 outOpaqueRegion = aboveOpaqueLayers;
2056}
2057
2058void SurfaceFlinger::invalidateLayerStack(uint32_t layerStack,
2059 const Region& dirty) {
2060 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
2061 const sp<DisplayDevice>& hw(mDisplays[dpy]);
2062 if (hw->getLayerStack() == layerStack) {
2063 hw->dirtyRegion.orSelf(dirty);
2064 }
2065 }
2066}
2067
2068bool SurfaceFlinger::handlePageFlip()
2069{
Brian Andersond6927fb2016-07-23 23:37:30 -07002070 nsecs_t latchTime = systemTime();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002071 Region dirtyRegion;
2072
2073 bool visibleRegions = false;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002074 bool frameQueued = false;
2075
2076 // Store the set of layers that need updates. This set must not change as
2077 // buffers are being latched, as this could result in a deadlock.
2078 // Example: Two producers share the same command stream and:
2079 // 1.) Layer 0 is latched
2080 // 2.) Layer 0 gets a new frame
2081 // 2.) Layer 1 gets a new frame
2082 // 3.) Layer 1 is latched.
2083 // Display is now waiting on Layer 1's frame, which is behind layer 0's
2084 // second frame. But layer 0's second frame could be waiting on display.
2085 Vector<Layer*> layersWithQueuedFrames;
Robert Carr2047fae2016-11-28 14:09:09 -08002086 mDrawingState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002087 if (layer->hasQueuedFrame()) {
2088 frameQueued = true;
2089 if (layer->shouldPresentNow(mPrimaryDispSync)) {
Robert Carr2047fae2016-11-28 14:09:09 -08002090 layersWithQueuedFrames.push_back(layer);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002091 } else {
2092 layer->useEmptyDamage();
2093 }
2094 } else {
2095 layer->useEmptyDamage();
2096 }
Robert Carr2047fae2016-11-28 14:09:09 -08002097 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002098 for (size_t i = 0, count = layersWithQueuedFrames.size() ; i<count ; i++) {
2099 Layer* layer = layersWithQueuedFrames[i];
Brian Andersond6927fb2016-07-23 23:37:30 -07002100 const Region dirty(layer->latchBuffer(visibleRegions, latchTime));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002101 layer->useSurfaceDamage();
Robert Carr1f0a16a2016-10-24 16:27:39 -07002102 invalidateLayerStack(layer->getLayerStack(), dirty);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002103 }
2104
2105 mVisibleRegionsDirty |= visibleRegions;
2106
2107 // If we will need to wake up at some time in the future to deal with a
2108 // queued frame that shouldn't be displayed during this vsync period, wake
2109 // up during the next vsync period to check again.
2110 if (frameQueued && layersWithQueuedFrames.empty()) {
2111 signalLayerUpdate();
2112 }
2113
2114 // Only continue with the refresh if there is actually new work to do
2115 return !layersWithQueuedFrames.empty();
2116}
2117
2118void SurfaceFlinger::invalidateHwcGeometry()
2119{
2120 mHwWorkListDirty = true;
2121}
2122
2123
2124void SurfaceFlinger::doDisplayComposition(const sp<const DisplayDevice>& hw,
2125 const Region& inDirtyRegion)
2126{
2127 // We only need to actually compose the display if:
2128 // 1) It is being handled by hardware composer, which may need this to
2129 // keep its virtual display state machine in sync, or
2130 // 2) There is work to be done (the dirty region isn't empty)
2131 bool isHwcDisplay = hw->getHwcDisplayId() >= 0;
2132 if (!isHwcDisplay && inDirtyRegion.isEmpty()) {
2133 return;
2134 }
2135
2136 Region dirtyRegion(inDirtyRegion);
2137
2138 // compute the invalid region
2139 hw->swapRegion.orSelf(dirtyRegion);
2140
2141 uint32_t flags = hw->getFlags();
2142 if (flags & DisplayDevice::SWAP_RECTANGLE) {
2143 // we can redraw only what's dirty, but since SWAP_RECTANGLE only
2144 // takes a rectangle, we must make sure to update that whole
2145 // rectangle in that case
2146 dirtyRegion.set(hw->swapRegion.bounds());
2147 } else {
2148 if (flags & DisplayDevice::PARTIAL_UPDATES) {
2149 // We need to redraw the rectangle that will be updated
2150 // (pushed to the framebuffer).
2151 // This is needed because PARTIAL_UPDATES only takes one
2152 // rectangle instead of a region (see DisplayDevice::flip())
2153 dirtyRegion.set(hw->swapRegion.bounds());
2154 } else {
2155 // we need to redraw everything (the whole screen)
2156 dirtyRegion.set(hw->bounds());
2157 hw->swapRegion = dirtyRegion;
2158 }
2159 }
2160
2161 if (CC_LIKELY(!mDaltonize && !mHasColorMatrix)) {
2162 if (!doComposeSurfaces(hw, dirtyRegion)) return;
2163 } else {
2164 RenderEngine& engine(getRenderEngine());
2165 mat4 colorMatrix = mColorMatrix;
2166 if (mDaltonize) {
2167 colorMatrix = colorMatrix * mDaltonizer();
2168 }
2169 mat4 oldMatrix = engine.setupColorTransform(colorMatrix);
2170 doComposeSurfaces(hw, dirtyRegion);
2171 engine.setupColorTransform(oldMatrix);
2172 }
2173
2174 // update the swap region and clear the dirty region
2175 hw->swapRegion.orSelf(dirtyRegion);
2176
2177 // swap buffers (presentation)
2178 hw->swapBuffers(getHwComposer());
2179}
2180
2181bool SurfaceFlinger::doComposeSurfaces(const sp<const DisplayDevice>& hw, const Region& dirty)
2182{
2183 RenderEngine& engine(getRenderEngine());
2184 const int32_t id = hw->getHwcDisplayId();
2185 HWComposer& hwc(getHwComposer());
2186 HWComposer::LayerListIterator cur = hwc.begin(id);
2187 const HWComposer::LayerListIterator end = hwc.end(id);
2188
2189 bool hasGlesComposition = hwc.hasGlesComposition(id);
2190 if (hasGlesComposition) {
2191 if (!hw->makeCurrent(mEGLDisplay, mEGLContext)) {
2192 ALOGW("DisplayDevice::makeCurrent failed. Aborting surface composition for display %s",
2193 hw->getDisplayName().string());
2194 eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
2195 if(!getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext)) {
2196 ALOGE("DisplayDevice::makeCurrent on default display failed. Aborting.");
2197 }
2198 return false;
2199 }
2200
2201 // Never touch the framebuffer if we don't have any framebuffer layers
2202 const bool hasHwcComposition = hwc.hasHwcComposition(id);
2203 if (hasHwcComposition) {
2204 // when using overlays, we assume a fully transparent framebuffer
2205 // NOTE: we could reduce how much we need to clear, for instance
2206 // remove where there are opaque FB layers. however, on some
2207 // GPUs doing a "clean slate" clear might be more efficient.
2208 // We'll revisit later if needed.
2209 engine.clearWithColor(0, 0, 0, 0);
2210 } else {
2211 // we start with the whole screen area
2212 const Region bounds(hw->getBounds());
2213
2214 // we remove the scissor part
2215 // we're left with the letterbox region
2216 // (common case is that letterbox ends-up being empty)
2217 const Region letterbox(bounds.subtract(hw->getScissor()));
2218
2219 // compute the area to clear
2220 Region region(hw->undefinedRegion.merge(letterbox));
2221
2222 // but limit it to the dirty region
2223 region.andSelf(dirty);
2224
2225 // screen is already cleared here
2226 if (!region.isEmpty()) {
2227 // can happen with SurfaceView
2228 drawWormhole(hw, region);
2229 }
2230 }
2231
2232 if (hw->getDisplayType() != DisplayDevice::DISPLAY_PRIMARY) {
2233 // just to be on the safe side, we don't set the
2234 // scissor on the main display. It should never be needed
2235 // anyways (though in theory it could since the API allows it).
2236 const Rect& bounds(hw->getBounds());
2237 const Rect& scissor(hw->getScissor());
2238 if (scissor != bounds) {
2239 // scissor doesn't match the screen's dimensions, so we
2240 // need to clear everything outside of it and enable
2241 // the GL scissor so we don't draw anything where we shouldn't
2242
2243 // enable scissor for this frame
2244 const uint32_t height = hw->getHeight();
2245 engine.setScissor(scissor.left, height - scissor.bottom,
2246 scissor.getWidth(), scissor.getHeight());
2247 }
2248 }
2249 }
2250
2251 /*
2252 * and then, render the layers targeted at the framebuffer
2253 */
2254
2255 const Vector< sp<Layer> >& layers(hw->getVisibleLayersSortedByZ());
2256 const size_t count = layers.size();
2257 const Transform& tr = hw->getTransform();
2258 if (cur != end) {
2259 // we're using h/w composer
2260 for (size_t i=0 ; i<count && cur!=end ; ++i, ++cur) {
2261 const sp<Layer>& layer(layers[i]);
2262 const Region clip(dirty.intersect(tr.transform(layer->visibleRegion)));
2263 if (!clip.isEmpty()) {
2264 switch (cur->getCompositionType()) {
2265 case HWC_CURSOR_OVERLAY:
2266 case HWC_OVERLAY: {
2267 const Layer::State& state(layer->getDrawingState());
2268 if ((cur->getHints() & HWC_HINT_CLEAR_FB)
2269 && i
2270 && layer->isOpaque(state) && (state.alpha == 0xFF)
2271 && hasGlesComposition) {
2272 // never clear the very first layer since we're
2273 // guaranteed the FB is already cleared
Fabien Sanglard17487192016-12-07 13:03:32 -08002274 layer->clearWithOpenGL(hw);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002275 }
2276 break;
2277 }
2278 case HWC_FRAMEBUFFER: {
2279 layer->draw(hw, clip);
2280 break;
2281 }
2282 case HWC_FRAMEBUFFER_TARGET: {
2283 // this should not happen as the iterator shouldn't
2284 // let us get there.
2285 ALOGW("HWC_FRAMEBUFFER_TARGET found in hwc list (index=%zu)", i);
2286 break;
2287 }
2288 }
2289 }
2290 layer->setAcquireFence(hw, *cur);
2291 }
2292 } else {
2293 // we're not using h/w composer
2294 for (size_t i=0 ; i<count ; ++i) {
2295 const sp<Layer>& layer(layers[i]);
2296 const Region clip(dirty.intersect(
2297 tr.transform(layer->visibleRegion)));
2298 if (!clip.isEmpty()) {
2299 layer->draw(hw, clip);
2300 }
2301 }
2302 }
2303
2304 // disable scissor at the end of the frame
2305 engine.disableScissor();
2306 return true;
2307}
2308
2309void SurfaceFlinger::drawWormhole(const sp<const DisplayDevice>& hw, const Region& region) const {
2310 const int32_t height = hw->getHeight();
2311 RenderEngine& engine(getRenderEngine());
2312 engine.fillRegionWithColor(region, height, 0, 0, 0, 0);
2313}
2314
2315status_t SurfaceFlinger::addClientLayer(const sp<Client>& client,
2316 const sp<IBinder>& handle,
2317 const sp<IGraphicBufferProducer>& gbc,
Robert Carr1f0a16a2016-10-24 16:27:39 -07002318 const sp<Layer>& lbc,
2319 const sp<Layer>& parent)
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002320{
2321 // add this layer to the current state list
2322 {
2323 Mutex::Autolock _l(mStateLock);
Robert Carr1f0a16a2016-10-24 16:27:39 -07002324 if (mNumLayers >= MAX_LAYERS) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002325 return NO_MEMORY;
2326 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07002327 if (parent == nullptr) {
2328 mCurrentState.layersSortedByZ.add(lbc);
2329 } else {
Chia-I Wufae51c42017-06-15 12:53:59 -07002330 if (mCurrentState.layersSortedByZ.indexOf(parent) < 0) {
2331 ALOGE("addClientLayer called with a removed parent");
2332 return NAME_NOT_FOUND;
2333 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07002334 parent->addChild(lbc);
2335 }
Chia-I Wufae51c42017-06-15 12:53:59 -07002336
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002337 mGraphicBufferProducerList.add(IInterface::asBinder(gbc));
Robert Carr1f0a16a2016-10-24 16:27:39 -07002338 mLayersAdded = true;
2339 mNumLayers++;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002340 }
2341
2342 // attach this layer to the client
2343 client->attachLayer(handle, lbc);
2344
2345 return NO_ERROR;
2346}
2347
Chia-I Wu515dc9c2017-06-15 12:53:59 -07002348status_t SurfaceFlinger::removeLayer(const sp<Layer>& layer, bool topLevelOnly) {
Robert Carr7f9b8992017-03-10 11:08:39 -08002349 Mutex::Autolock _l(mStateLock);
2350
Robert Carr1f0a16a2016-10-24 16:27:39 -07002351 const auto& p = layer->getParent();
Chia-I Wu515dc9c2017-06-15 12:53:59 -07002352 ssize_t index;
2353 if (p != nullptr) {
2354 if (topLevelOnly) {
2355 return NO_ERROR;
2356 }
2357
Chia-I Wufae51c42017-06-15 12:53:59 -07002358 sp<Layer> ancestor = p;
2359 while (ancestor->getParent() != nullptr) {
2360 ancestor = ancestor->getParent();
2361 }
2362 if (mCurrentState.layersSortedByZ.indexOf(ancestor) < 0) {
2363 ALOGE("removeLayer called with a layer whose parent has been removed");
2364 return NAME_NOT_FOUND;
2365 }
2366
Chia-I Wu515dc9c2017-06-15 12:53:59 -07002367 index = p->removeChild(layer);
2368 } else {
2369 index = mCurrentState.layersSortedByZ.remove(layer);
2370 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07002371
Robert Carr136e2f62017-02-08 17:54:29 -08002372 // As a matter of normal operation, the LayerCleaner will produce a second
2373 // attempt to remove the surface. The Layer will be kept alive in mDrawingState
2374 // so we will succeed in promoting it, but it's already been removed
2375 // from mCurrentState. As long as we can find it in mDrawingState we have no problem
2376 // otherwise something has gone wrong and we are leaking the layer.
2377 if (index < 0 && mDrawingState.layersSortedByZ.indexOf(layer) < 0) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07002378 ALOGE("Failed to find layer (%s) in layer parent (%s).",
2379 layer->getName().string(),
2380 (p != nullptr) ? p->getName().string() : "no-parent");
2381 return BAD_VALUE;
Robert Carr136e2f62017-02-08 17:54:29 -08002382 } else if (index < 0) {
2383 return NO_ERROR;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002384 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07002385
2386 mLayersPendingRemoval.add(layer);
2387 mLayersRemoved = true;
Chia-I Wufae51c42017-06-15 12:53:59 -07002388 mNumLayers -= 1 + layer->getChildrenCount();
Robert Carr1f0a16a2016-10-24 16:27:39 -07002389 setTransactionFlags(eTransactionNeeded);
2390 return NO_ERROR;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002391}
2392
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08002393uint32_t SurfaceFlinger::peekTransactionFlags() {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002394 return android_atomic_release_load(&mTransactionFlags);
2395}
2396
2397uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) {
2398 return android_atomic_and(~flags, &mTransactionFlags) & flags;
2399}
2400
2401uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) {
2402 uint32_t old = android_atomic_or(flags, &mTransactionFlags);
2403 if ((old & flags)==0) { // wake the server up
2404 signalTransaction();
2405 }
2406 return old;
2407}
2408
2409void SurfaceFlinger::setTransactionState(
2410 const Vector<ComposerState>& state,
2411 const Vector<DisplayState>& displays,
2412 uint32_t flags)
2413{
2414 ATRACE_CALL();
2415 Mutex::Autolock _l(mStateLock);
2416 uint32_t transactionFlags = 0;
2417
2418 if (flags & eAnimation) {
2419 // For window updates that are part of an animation we must wait for
2420 // previous animation "frames" to be handled.
2421 while (mAnimTransactionPending) {
2422 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
2423 if (CC_UNLIKELY(err != NO_ERROR)) {
2424 // just in case something goes wrong in SF, return to the
2425 // caller after a few seconds.
2426 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out "
2427 "waiting for previous animation frame");
2428 mAnimTransactionPending = false;
2429 break;
2430 }
2431 }
2432 }
2433
2434 size_t count = displays.size();
2435 for (size_t i=0 ; i<count ; i++) {
2436 const DisplayState& s(displays[i]);
2437 transactionFlags |= setDisplayStateLocked(s);
2438 }
2439
2440 count = state.size();
2441 for (size_t i=0 ; i<count ; i++) {
2442 const ComposerState& s(state[i]);
2443 // Here we need to check that the interface we're given is indeed
2444 // one of our own. A malicious client could give us a NULL
2445 // IInterface, or one of its own or even one of our own but a
2446 // different type. All these situations would cause us to crash.
2447 //
2448 // NOTE: it would be better to use RTTI as we could directly check
2449 // that we have a Client*. however, RTTI is disabled in Android.
2450 if (s.client != NULL) {
2451 sp<IBinder> binder = IInterface::asBinder(s.client);
2452 if (binder != NULL) {
Fabien Sanglard45b20252017-01-18 16:43:18 -08002453 if (binder->queryLocalInterface(ISurfaceComposerClient::descriptor) != NULL) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002454 sp<Client> client( static_cast<Client *>(s.client.get()) );
2455 transactionFlags |= setClientStateLocked(client, s.state);
2456 }
2457 }
2458 }
2459 }
2460
2461 // If a synchronous transaction is explicitly requested without any changes,
2462 // force a transaction anyway. This can be used as a flush mechanism for
2463 // previous async transactions.
2464 if (transactionFlags == 0 && (flags & eSynchronous)) {
2465 transactionFlags = eTransactionNeeded;
2466 }
2467
2468 if (transactionFlags) {
2469 if (mInterceptor.isEnabled()) {
2470 mInterceptor.saveTransaction(state, mCurrentState.displays, displays, flags);
2471 }
2472
2473 // this triggers the transaction
2474 setTransactionFlags(transactionFlags);
2475
2476 // if this is a synchronous transaction, wait for it to take effect
2477 // before returning.
2478 if (flags & eSynchronous) {
2479 mTransactionPending = true;
2480 }
2481 if (flags & eAnimation) {
2482 mAnimTransactionPending = true;
2483 }
2484 while (mTransactionPending) {
2485 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
2486 if (CC_UNLIKELY(err != NO_ERROR)) {
2487 // just in case something goes wrong in SF, return to the
2488 // called after a few seconds.
2489 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");
2490 mTransactionPending = false;
2491 break;
2492 }
2493 }
2494 }
2495}
2496
2497uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s)
2498{
2499 ssize_t dpyIdx = mCurrentState.displays.indexOfKey(s.token);
2500 if (dpyIdx < 0)
2501 return 0;
2502
2503 uint32_t flags = 0;
2504 DisplayDeviceState& disp(mCurrentState.displays.editValueAt(dpyIdx));
2505 if (disp.isValid()) {
2506 const uint32_t what = s.what;
2507 if (what & DisplayState::eSurfaceChanged) {
2508 if (IInterface::asBinder(disp.surface) != IInterface::asBinder(s.surface)) {
2509 disp.surface = s.surface;
2510 flags |= eDisplayTransactionNeeded;
2511 }
2512 }
2513 if (what & DisplayState::eLayerStackChanged) {
2514 if (disp.layerStack != s.layerStack) {
2515 disp.layerStack = s.layerStack;
2516 flags |= eDisplayTransactionNeeded;
2517 }
2518 }
2519 if (what & DisplayState::eDisplayProjectionChanged) {
2520 if (disp.orientation != s.orientation) {
2521 disp.orientation = s.orientation;
2522 flags |= eDisplayTransactionNeeded;
2523 }
2524 if (disp.frame != s.frame) {
2525 disp.frame = s.frame;
2526 flags |= eDisplayTransactionNeeded;
2527 }
2528 if (disp.viewport != s.viewport) {
2529 disp.viewport = s.viewport;
2530 flags |= eDisplayTransactionNeeded;
2531 }
2532 }
2533 if (what & DisplayState::eDisplaySizeChanged) {
2534 if (disp.width != s.width) {
2535 disp.width = s.width;
2536 flags |= eDisplayTransactionNeeded;
2537 }
2538 if (disp.height != s.height) {
2539 disp.height = s.height;
2540 flags |= eDisplayTransactionNeeded;
2541 }
2542 }
2543 }
2544 return flags;
2545}
2546
2547uint32_t SurfaceFlinger::setClientStateLocked(
2548 const sp<Client>& client,
2549 const layer_state_t& s)
2550{
2551 uint32_t flags = 0;
2552 sp<Layer> layer(client->getLayerUser(s.surface));
2553 if (layer != 0) {
2554 const uint32_t what = s.what;
2555 bool geometryAppliesWithResize =
2556 what & layer_state_t::eGeometryAppliesWithResize;
2557 if (what & layer_state_t::ePositionChanged) {
2558 if (layer->setPosition(s.x, s.y, !geometryAppliesWithResize)) {
2559 flags |= eTraversalNeeded;
2560 }
2561 }
2562 if (what & layer_state_t::eLayerChanged) {
2563 // NOTE: index needs to be calculated before we update the state
Robert Carr1f0a16a2016-10-24 16:27:39 -07002564 const auto& p = layer->getParent();
2565 if (p == nullptr) {
2566 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
2567 if (layer->setLayer(s.z) && idx >= 0) {
2568 mCurrentState.layersSortedByZ.removeAt(idx);
2569 mCurrentState.layersSortedByZ.add(layer);
2570 // we need traversal (state changed)
2571 // AND transaction (list changed)
2572 flags |= eTransactionNeeded|eTraversalNeeded;
2573 }
2574 } else {
2575 if (p->setChildLayer(layer, s.z)) {
2576 flags |= eTransactionNeeded|eTraversalNeeded;
2577 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002578 }
2579 }
2580 if (what & layer_state_t::eSizeChanged) {
2581 if (layer->setSize(s.w, s.h)) {
2582 flags |= eTraversalNeeded;
2583 }
2584 }
2585 if (what & layer_state_t::eAlphaChanged) {
2586 if (layer->setAlpha(uint8_t(255.0f*s.alpha+0.5f)))
2587 flags |= eTraversalNeeded;
2588 }
2589 if (what & layer_state_t::eMatrixChanged) {
2590 if (layer->setMatrix(s.matrix))
2591 flags |= eTraversalNeeded;
2592 }
2593 if (what & layer_state_t::eTransparentRegionChanged) {
2594 if (layer->setTransparentRegionHint(s.transparentRegion))
2595 flags |= eTraversalNeeded;
2596 }
2597 if (what & layer_state_t::eFlagsChanged) {
2598 if (layer->setFlags(s.flags, s.mask))
2599 flags |= eTraversalNeeded;
2600 }
2601 if (what & layer_state_t::eCropChanged) {
2602 if (layer->setCrop(s.crop, !geometryAppliesWithResize))
2603 flags |= eTraversalNeeded;
2604 }
2605 if (what & layer_state_t::eFinalCropChanged) {
Robert Carr6fb9ca72017-03-22 18:23:23 -07002606 if (layer->setFinalCrop(s.finalCrop, !geometryAppliesWithResize))
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002607 flags |= eTraversalNeeded;
2608 }
2609 if (what & layer_state_t::eLayerStackChanged) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002610 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
Robert Carr1f0a16a2016-10-24 16:27:39 -07002611 // We only allow setting layer stacks for top level layers,
2612 // everything else inherits layer stack from its parent.
2613 if (layer->hasParent()) {
2614 ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
2615 layer->getName().string());
2616 } else if (idx < 0) {
2617 ALOGE("Attempt to set layer stack on layer without parent (%s) that "
2618 "that also does not appear in the top level layer list. Something"
2619 " has gone wrong.", layer->getName().string());
2620 } else if (layer->setLayerStack(s.layerStack)) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002621 mCurrentState.layersSortedByZ.removeAt(idx);
2622 mCurrentState.layersSortedByZ.add(layer);
2623 // we need traversal (state changed)
2624 // AND transaction (list changed)
2625 flags |= eTransactionNeeded|eTraversalNeeded;
2626 }
2627 }
2628 if (what & layer_state_t::eDeferTransaction) {
Robert Carr0d480722017-01-10 16:42:54 -08002629 if (s.barrierHandle != nullptr) {
2630 layer->deferTransactionUntil(s.barrierHandle, s.frameNumber);
2631 } else if (s.barrierGbp != nullptr) {
2632 const sp<IGraphicBufferProducer>& gbp = s.barrierGbp;
2633 if (authenticateSurfaceTextureLocked(gbp)) {
2634 const auto& otherLayer =
2635 (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
2636 layer->deferTransactionUntil(otherLayer, s.frameNumber);
2637 } else {
2638 ALOGE("Attempt to defer transaction to to an"
2639 " unrecognized GraphicBufferProducer");
2640 }
2641 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002642 // We don't trigger a traversal here because if no other state is
2643 // changed, we don't want this to cause any more work
2644 }
Robert Carr1db73f62016-12-21 12:58:51 -08002645 if (what & layer_state_t::eReparentChildren) {
2646 if (layer->reparentChildren(s.reparentHandle)) {
2647 flags |= eTransactionNeeded|eTraversalNeeded;
2648 }
2649 }
Robert Carr9524cb32017-02-13 11:32:32 -08002650 if (what & layer_state_t::eDetachChildren) {
2651 layer->detachChildren();
2652 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002653 if (what & layer_state_t::eOverrideScalingModeChanged) {
2654 layer->setOverrideScalingMode(s.overrideScalingMode);
2655 // We don't trigger a traversal here because if no other state is
2656 // changed, we don't want this to cause any more work
2657 }
2658 }
2659 return flags;
2660}
2661
2662status_t SurfaceFlinger::createLayer(
2663 const String8& name,
2664 const sp<Client>& client,
2665 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
Albert Chaulk479c60c2017-01-27 14:21:34 -05002666 uint32_t windowType, uint32_t ownerUid, sp<IBinder>* handle,
2667 sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent)
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002668{
2669 if (int32_t(w|h) < 0) {
2670 ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
2671 int(w), int(h));
2672 return BAD_VALUE;
2673 }
2674
2675 status_t result = NO_ERROR;
2676
2677 sp<Layer> layer;
2678
Cody Northropbc755282017-03-31 12:00:08 -06002679 String8 uniqueName = getUniqueLayerName(name);
2680
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002681 switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
2682 case ISurfaceComposerClient::eFXSurfaceNormal:
2683 result = createNormalLayer(client,
Cody Northropbc755282017-03-31 12:00:08 -06002684 uniqueName, w, h, flags, format,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002685 handle, gbp, &layer);
2686 break;
2687 case ISurfaceComposerClient::eFXSurfaceDim:
2688 result = createDimLayer(client,
Cody Northropbc755282017-03-31 12:00:08 -06002689 uniqueName, w, h, flags,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002690 handle, gbp, &layer);
2691 break;
2692 default:
2693 result = BAD_VALUE;
2694 break;
2695 }
2696
2697 if (result != NO_ERROR) {
2698 return result;
2699 }
2700
Albert Chaulk479c60c2017-01-27 14:21:34 -05002701 layer->setInfo(windowType, ownerUid);
2702
Robert Carr1f0a16a2016-10-24 16:27:39 -07002703 result = addClientLayer(client, *handle, *gbp, layer, *parent);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002704 if (result != NO_ERROR) {
2705 return result;
2706 }
2707 mInterceptor.saveSurfaceCreation(layer);
2708
2709 setTransactionFlags(eTransactionNeeded);
2710 return result;
2711}
2712
Cody Northropbc755282017-03-31 12:00:08 -06002713String8 SurfaceFlinger::getUniqueLayerName(const String8& name)
2714{
2715 bool matchFound = true;
2716 uint32_t dupeCounter = 0;
2717
2718 // Tack on our counter whether there is a hit or not, so everyone gets a tag
2719 String8 uniqueName = name + "#" + String8(std::to_string(dupeCounter).c_str());
2720
2721 // Loop over layers until we're sure there is no matching name
2722 while (matchFound) {
2723 matchFound = false;
2724 mDrawingState.traverseInZOrder([&](Layer* layer) {
2725 if (layer->getName() == uniqueName) {
2726 matchFound = true;
2727 uniqueName = name + "#" + String8(std::to_string(++dupeCounter).c_str());
2728 }
2729 });
2730 }
2731
2732 ALOGD_IF(dupeCounter > 0, "duplicate layer name: changing %s to %s", name.c_str(), uniqueName.c_str());
2733
2734 return uniqueName;
2735}
2736
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002737status_t SurfaceFlinger::createNormalLayer(const sp<Client>& client,
2738 const String8& name, uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
2739 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
2740{
2741 // initialize the surfaces
2742 switch (format) {
2743 case PIXEL_FORMAT_TRANSPARENT:
2744 case PIXEL_FORMAT_TRANSLUCENT:
2745 format = PIXEL_FORMAT_RGBA_8888;
2746 break;
2747 case PIXEL_FORMAT_OPAQUE:
2748 format = PIXEL_FORMAT_RGBX_8888;
2749 break;
2750 }
2751
2752 *outLayer = new Layer(this, client, name, w, h, flags);
2753 status_t err = (*outLayer)->setBuffers(w, h, format, flags);
2754 if (err == NO_ERROR) {
2755 *handle = (*outLayer)->getHandle();
2756 *gbp = (*outLayer)->getProducer();
2757 }
2758
2759 ALOGE_IF(err, "createNormalLayer() failed (%s)", strerror(-err));
2760 return err;
2761}
2762
2763status_t SurfaceFlinger::createDimLayer(const sp<Client>& client,
2764 const String8& name, uint32_t w, uint32_t h, uint32_t flags,
2765 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
2766{
2767 *outLayer = new LayerDim(this, client, name, w, h, flags);
2768 *handle = (*outLayer)->getHandle();
2769 *gbp = (*outLayer)->getProducer();
2770 return NO_ERROR;
2771}
2772
2773status_t SurfaceFlinger::onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle)
2774{
Robert Carr9524cb32017-02-13 11:32:32 -08002775 // called by a client when it wants to remove a Layer
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002776 status_t err = NO_ERROR;
2777 sp<Layer> l(client->getLayerUser(handle));
2778 if (l != NULL) {
2779 mInterceptor.saveSurfaceDeletion(l);
2780 err = removeLayer(l);
2781 ALOGE_IF(err<0 && err != NAME_NOT_FOUND,
2782 "error removing layer=%p (%s)", l.get(), strerror(-err));
2783 }
2784 return err;
2785}
2786
2787status_t SurfaceFlinger::onLayerDestroyed(const wp<Layer>& layer)
2788{
2789 // called by ~LayerCleaner() when all references to the IBinder (handle)
2790 // are gone
Robert Carr9524cb32017-02-13 11:32:32 -08002791 sp<Layer> l = layer.promote();
2792 if (l == nullptr) {
2793 // The layer has already been removed, carry on
2794 return NO_ERROR;
Robert Carr9524cb32017-02-13 11:32:32 -08002795 }
Chia-I Wu515dc9c2017-06-15 12:53:59 -07002796 // If we have a parent, then we can continue to live as long as it does.
2797 return removeLayer(l, true);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002798}
2799
2800// ---------------------------------------------------------------------------
2801
2802void SurfaceFlinger::onInitializeDisplays() {
2803 // reset screen orientation and use primary layer stack
2804 Vector<ComposerState> state;
2805 Vector<DisplayState> displays;
2806 DisplayState d;
2807 d.what = DisplayState::eDisplayProjectionChanged |
2808 DisplayState::eLayerStackChanged;
2809 d.token = mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY];
2810 d.layerStack = 0;
2811 d.orientation = DisplayState::eOrientationDefault;
2812 d.frame.makeInvalid();
2813 d.viewport.makeInvalid();
2814 d.width = 0;
2815 d.height = 0;
2816 displays.add(d);
2817 setTransactionState(state, displays, 0);
2818 setPowerModeInternal(getDisplayDevice(d.token), HWC_POWER_MODE_NORMAL);
2819
2820 const nsecs_t period =
2821 getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
2822 mAnimFrameTracker.setDisplayRefreshPeriod(period);
Brian Andersond0010582017-03-07 13:20:31 -08002823
2824 // Use phase of 0 since phase is not known.
2825 // Use latency of 0, which will snap to the ideal latency.
2826 setCompositorTimingSnapped(0, period, 0);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002827}
2828
2829void SurfaceFlinger::initializeDisplays() {
2830 class MessageScreenInitialized : public MessageBase {
2831 SurfaceFlinger* flinger;
2832 public:
2833 explicit MessageScreenInitialized(SurfaceFlinger* flinger) : flinger(flinger) { }
2834 virtual bool handler() {
2835 flinger->onInitializeDisplays();
2836 return true;
2837 }
2838 };
2839 sp<MessageBase> msg = new MessageScreenInitialized(this);
2840 postMessageAsync(msg); // we may be called from main thread, use async message
2841}
2842
2843void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& hw,
2844 int mode) {
2845 ALOGD("Set power mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(),
2846 this);
2847 int32_t type = hw->getDisplayType();
2848 int currentMode = hw->getPowerMode();
2849
2850 if (mode == currentMode) {
2851 ALOGD("Screen type=%d is already mode=%d", hw->getDisplayType(), mode);
2852 return;
2853 }
2854
2855 hw->setPowerMode(mode);
2856 if (type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
2857 ALOGW("Trying to set power mode for virtual display");
2858 return;
2859 }
2860
2861 if (mInterceptor.isEnabled()) {
2862 Mutex::Autolock _l(mStateLock);
2863 ssize_t idx = mCurrentState.displays.indexOfKey(hw->getDisplayToken());
2864 if (idx < 0) {
2865 ALOGW("Surface Interceptor SavePowerMode: invalid display token");
2866 return;
2867 }
2868 mInterceptor.savePowerModeUpdate(mCurrentState.displays.valueAt(idx).displayId, mode);
2869 }
2870
2871 if (currentMode == HWC_POWER_MODE_OFF) {
2872 // Turn on the display
2873 getHwComposer().setPowerMode(type, mode);
Matthew Bouyack38d49612017-05-12 12:49:32 -07002874 if (type == DisplayDevice::DISPLAY_PRIMARY &&
2875 mode != HWC_POWER_MODE_DOZE_SUSPEND) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002876 // FIXME: eventthread only knows about the main display right now
2877 mEventThread->onScreenAcquired();
2878 resyncToHardwareVsync(true);
2879 }
2880
2881 mVisibleRegionsDirty = true;
2882 mHasPoweredOff = true;
2883 repaintEverything();
2884
2885 struct sched_param param = {0};
2886 param.sched_priority = 1;
2887 if (sched_setscheduler(0, SCHED_FIFO, &param) != 0) {
2888 ALOGW("Couldn't set SCHED_FIFO on display on");
2889 }
2890 } else if (mode == HWC_POWER_MODE_OFF) {
2891 // Turn off the display
2892 struct sched_param param = {0};
2893 if (sched_setscheduler(0, SCHED_OTHER, &param) != 0) {
2894 ALOGW("Couldn't set SCHED_OTHER on display off");
2895 }
2896
2897 if (type == DisplayDevice::DISPLAY_PRIMARY) {
2898 disableHardwareVsync(true); // also cancels any in-progress resync
2899
2900 // FIXME: eventthread only knows about the main display right now
2901 mEventThread->onScreenReleased();
2902 }
2903
2904 getHwComposer().setPowerMode(type, mode);
2905 mVisibleRegionsDirty = true;
2906 // from this point on, SF will stop drawing on this display
Matthew Bouyack38d49612017-05-12 12:49:32 -07002907 } else if (mode == HWC_POWER_MODE_DOZE ||
2908 mode == HWC_POWER_MODE_NORMAL) {
Zheng Zhang8a43fe62017-03-17 11:19:39 +01002909 // Update display while dozing
2910 getHwComposer().setPowerMode(type, mode);
2911 if (type == DisplayDevice::DISPLAY_PRIMARY) {
2912 // FIXME: eventthread only knows about the main display right now
2913 mEventThread->onScreenAcquired();
2914 resyncToHardwareVsync(true);
2915 }
2916 } else if (mode == HWC_POWER_MODE_DOZE_SUSPEND) {
2917 // Leave display going to doze
2918 if (type == DisplayDevice::DISPLAY_PRIMARY) {
2919 disableHardwareVsync(true); // also cancels any in-progress resync
2920 // FIXME: eventthread only knows about the main display right now
2921 mEventThread->onScreenReleased();
2922 }
2923 getHwComposer().setPowerMode(type, mode);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002924 } else {
Matthew Bouyack38d49612017-05-12 12:49:32 -07002925 ALOGE("Attempting to set unknown power mode: %d\n", mode);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002926 getHwComposer().setPowerMode(type, mode);
2927 }
2928}
2929
2930void SurfaceFlinger::setPowerMode(const sp<IBinder>& display, int mode) {
2931 class MessageSetPowerMode: public MessageBase {
2932 SurfaceFlinger& mFlinger;
2933 sp<IBinder> mDisplay;
2934 int mMode;
2935 public:
2936 MessageSetPowerMode(SurfaceFlinger& flinger,
2937 const sp<IBinder>& disp, int mode) : mFlinger(flinger),
2938 mDisplay(disp) { mMode = mode; }
2939 virtual bool handler() {
2940 sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
2941 if (hw == NULL) {
2942 ALOGE("Attempt to set power mode = %d for null display %p",
2943 mMode, mDisplay.get());
2944 } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) {
2945 ALOGW("Attempt to set power mode = %d for virtual display",
2946 mMode);
2947 } else {
2948 mFlinger.setPowerModeInternal(hw, mMode);
2949 }
2950 return true;
2951 }
2952 };
2953 sp<MessageBase> msg = new MessageSetPowerMode(*this, display, mode);
2954 postMessageSync(msg);
2955}
2956
2957// ---------------------------------------------------------------------------
2958
2959status_t SurfaceFlinger::dump(int fd, const Vector<String16>& args)
2960{
2961 String8 result;
2962
2963 IPCThreadState* ipc = IPCThreadState::self();
2964 const int pid = ipc->getCallingPid();
2965 const int uid = ipc->getCallingUid();
2966 if ((uid != AID_SHELL) &&
2967 !PermissionCache::checkPermission(sDump, pid, uid)) {
2968 result.appendFormat("Permission Denial: "
2969 "can't dump SurfaceFlinger from pid=%d, uid=%d\n", pid, uid);
2970 } else {
2971 // Try to get the main lock, but give up after one second
2972 // (this would indicate SF is stuck, but we want to be able to
2973 // print something in dumpsys).
2974 status_t err = mStateLock.timedLock(s2ns(1));
2975 bool locked = (err == NO_ERROR);
2976 if (!locked) {
2977 result.appendFormat(
2978 "SurfaceFlinger appears to be unresponsive (%s [%d]), "
2979 "dumping anyways (no locks held)\n", strerror(-err), err);
2980 }
2981
2982 bool dumpAll = true;
2983 size_t index = 0;
2984 size_t numArgs = args.size();
2985 if (numArgs) {
2986 if ((index < numArgs) &&
2987 (args[index] == String16("--list"))) {
2988 index++;
2989 listLayersLocked(args, index, result);
2990 dumpAll = false;
2991 }
2992
2993 if ((index < numArgs) &&
2994 (args[index] == String16("--latency"))) {
2995 index++;
2996 dumpStatsLocked(args, index, result);
2997 dumpAll = false;
2998 }
2999
3000 if ((index < numArgs) &&
3001 (args[index] == String16("--latency-clear"))) {
3002 index++;
3003 clearStatsLocked(args, index, result);
3004 dumpAll = false;
3005 }
3006
3007 if ((index < numArgs) &&
3008 (args[index] == String16("--dispsync"))) {
3009 index++;
3010 mPrimaryDispSync.dump(result);
3011 dumpAll = false;
3012 }
3013
3014 if ((index < numArgs) &&
3015 (args[index] == String16("--static-screen"))) {
3016 index++;
3017 dumpStaticScreenStats(result);
3018 dumpAll = false;
3019 }
3020
3021 if ((index < numArgs) &&
Brian Andersond6927fb2016-07-23 23:37:30 -07003022 (args[index] == String16("--frame-events"))) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003023 index++;
Brian Andersond6927fb2016-07-23 23:37:30 -07003024 dumpFrameEventsLocked(result);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003025 dumpAll = false;
3026 }
3027 }
3028
3029 if (dumpAll) {
3030 dumpAllLocked(args, index, result);
3031 }
3032
3033 if (locked) {
3034 mStateLock.unlock();
3035 }
3036 }
3037 write(fd, result.string(), result.size());
3038 return NO_ERROR;
3039}
3040
3041void SurfaceFlinger::listLayersLocked(const Vector<String16>& /* args */,
3042 size_t& /* index */, String8& result) const
3043{
Robert Carr2047fae2016-11-28 14:09:09 -08003044 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003045 result.appendFormat("%s\n", layer->getName().string());
Robert Carr2047fae2016-11-28 14:09:09 -08003046 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003047}
3048
3049void SurfaceFlinger::dumpStatsLocked(const Vector<String16>& args, size_t& index,
3050 String8& result) const
3051{
3052 String8 name;
3053 if (index < args.size()) {
3054 name = String8(args[index]);
3055 index++;
3056 }
3057
3058 const nsecs_t period =
3059 getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
3060 result.appendFormat("%" PRId64 "\n", period);
3061
3062 if (name.isEmpty()) {
3063 mAnimFrameTracker.dumpStats(result);
3064 } else {
Robert Carr2047fae2016-11-28 14:09:09 -08003065 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003066 if (name == layer->getName()) {
3067 layer->dumpFrameStats(result);
3068 }
Robert Carr2047fae2016-11-28 14:09:09 -08003069 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003070 }
3071}
3072
3073void SurfaceFlinger::clearStatsLocked(const Vector<String16>& args, size_t& index,
3074 String8& /* result */)
3075{
3076 String8 name;
3077 if (index < args.size()) {
3078 name = String8(args[index]);
3079 index++;
3080 }
3081
Robert Carr2047fae2016-11-28 14:09:09 -08003082 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003083 if (name.isEmpty() || (name == layer->getName())) {
3084 layer->clearFrameStats();
3085 }
Robert Carr2047fae2016-11-28 14:09:09 -08003086 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003087
3088 mAnimFrameTracker.clearStats();
3089}
3090
3091// This should only be called from the main thread. Otherwise it would need
3092// the lock and should use mCurrentState rather than mDrawingState.
3093void SurfaceFlinger::logFrameStats() {
Robert Carr2047fae2016-11-28 14:09:09 -08003094 mDrawingState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003095 layer->logFrameStats();
Robert Carr2047fae2016-11-28 14:09:09 -08003096 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003097
3098 mAnimFrameTracker.logAndResetStats(String8("<win-anim>"));
3099}
3100
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08003101void SurfaceFlinger::appendSfConfigString(String8& result) const
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003102{
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08003103 result.append(" [sf");
Fabien Sanglardc93afd52017-03-13 13:02:42 -07003104 result.appendFormat(" HAS_CONTEXT_PRIORITY=%d", useContextPriority);
3105
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08003106 if (isLayerTripleBufferingDisabled())
3107 result.append(" DISABLE_TRIPLE_BUFFERING");
Fabien Sanglarda34ed632017-03-14 11:43:52 -07003108
Fabien Sanglardc45a7d92017-03-14 13:24:22 -07003109 result.appendFormat(" PRESENT_TIME_OFFSET=%" PRId64, dispSyncPresentTimeOffset);
Fabien Sanglarda34ed632017-03-14 11:43:52 -07003110 result.appendFormat(" FORCE_HWC_FOR_RBG_TO_YUV=%d", useHwcForRgbToYuv);
Fabien Sanglardc8e387e2017-03-10 10:30:28 -08003111 result.appendFormat(" MAX_VIRT_DISPLAY_DIM=%" PRIu64, maxVirtualDisplaySize);
Fabien Sanglardcbf153b2017-03-10 17:57:12 -08003112 result.appendFormat(" RUNNING_WITHOUT_SYNC_FRAMEWORK=%d", !hasSyncFramework);
Fabien Sanglard1971b632017-03-10 14:50:03 -08003113 result.appendFormat(" NUM_FRAMEBUFFER_SURFACE_BUFFERS=%" PRId64,
3114 maxFrameBufferAcquiredBuffers);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08003115 result.append("]");
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003116}
3117
3118void SurfaceFlinger::dumpStaticScreenStats(String8& result) const
3119{
3120 result.appendFormat("Static screen stats:\n");
3121 for (size_t b = 0; b < NUM_BUCKETS - 1; ++b) {
3122 float bucketTimeSec = mFrameBuckets[b] / 1e9;
3123 float percent = 100.0f *
3124 static_cast<float>(mFrameBuckets[b]) / mTotalTime;
3125 result.appendFormat(" < %zd frames: %.3f s (%.1f%%)\n",
3126 b + 1, bucketTimeSec, percent);
3127 }
3128 float bucketTimeSec = mFrameBuckets[NUM_BUCKETS - 1] / 1e9;
3129 float percent = 100.0f *
3130 static_cast<float>(mFrameBuckets[NUM_BUCKETS - 1]) / mTotalTime;
3131 result.appendFormat(" %zd+ frames: %.3f s (%.1f%%)\n",
3132 NUM_BUCKETS - 1, bucketTimeSec, percent);
3133}
3134
Brian Andersond6927fb2016-07-23 23:37:30 -07003135void SurfaceFlinger::dumpFrameEventsLocked(String8& result) {
3136 result.appendFormat("Layer frame timestamps:\n");
3137
3138 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
3139 const size_t count = currentLayers.size();
3140 for (size_t i=0 ; i<count ; i++) {
3141 currentLayers[i]->dumpFrameEvents(result);
3142 }
3143}
3144
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003145void SurfaceFlinger::recordBufferingStats(const char* layerName,
3146 std::vector<OccupancyTracker::Segment>&& history) {
3147 Mutex::Autolock lock(mBufferingStatsMutex);
3148 auto& stats = mBufferingStats[layerName];
3149 for (const auto& segment : history) {
3150 if (!segment.usedThirdBuffer) {
3151 stats.twoBufferTime += segment.totalTime;
3152 }
3153 if (segment.occupancyAverage < 1.0f) {
3154 stats.doubleBufferedTime += segment.totalTime;
3155 } else if (segment.occupancyAverage < 2.0f) {
3156 stats.tripleBufferedTime += segment.totalTime;
3157 }
3158 ++stats.numSegments;
3159 stats.totalTime += segment.totalTime;
3160 }
3161}
3162
3163void SurfaceFlinger::dumpBufferingStats(String8& result) const {
3164 result.append("Buffering stats:\n");
3165 result.append(" [Layer name] <Active time> <Two buffer> "
3166 "<Double buffered> <Triple buffered>\n");
3167 Mutex::Autolock lock(mBufferingStatsMutex);
3168 typedef std::tuple<std::string, float, float, float> BufferTuple;
3169 std::map<float, BufferTuple, std::greater<float>> sorted;
3170 for (const auto& statsPair : mBufferingStats) {
3171 const char* name = statsPair.first.c_str();
3172 const BufferingStats& stats = statsPair.second;
3173 if (stats.numSegments == 0) {
3174 continue;
3175 }
3176 float activeTime = ns2ms(stats.totalTime) / 1000.0f;
3177 float twoBufferRatio = static_cast<float>(stats.twoBufferTime) /
3178 stats.totalTime;
3179 float doubleBufferRatio = static_cast<float>(
3180 stats.doubleBufferedTime) / stats.totalTime;
3181 float tripleBufferRatio = static_cast<float>(
3182 stats.tripleBufferedTime) / stats.totalTime;
3183 sorted.insert({activeTime, {name, twoBufferRatio,
3184 doubleBufferRatio, tripleBufferRatio}});
3185 }
3186 for (const auto& sortedPair : sorted) {
3187 float activeTime = sortedPair.first;
3188 const BufferTuple& values = sortedPair.second;
3189 result.appendFormat(" [%s] %.2f %.3f %.3f %.3f\n",
3190 std::get<0>(values).c_str(), activeTime,
3191 std::get<1>(values), std::get<2>(values),
3192 std::get<3>(values));
3193 }
3194 result.append("\n");
3195}
3196
3197void SurfaceFlinger::dumpAllLocked(const Vector<String16>& args, size_t& index,
3198 String8& result) const
3199{
3200 bool colorize = false;
3201 if (index < args.size()
3202 && (args[index] == String16("--color"))) {
3203 colorize = true;
3204 index++;
3205 }
3206
3207 Colorizer colorizer(colorize);
3208
3209 // figure out if we're stuck somewhere
3210 const nsecs_t now = systemTime();
3211 const nsecs_t inSwapBuffers(mDebugInSwapBuffers);
3212 const nsecs_t inTransaction(mDebugInTransaction);
3213 nsecs_t inSwapBuffersDuration = (inSwapBuffers) ? now-inSwapBuffers : 0;
3214 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
3215
3216 /*
3217 * Dump library configuration.
3218 */
3219
3220 colorizer.bold(result);
3221 result.append("Build configuration:");
3222 colorizer.reset(result);
3223 appendSfConfigString(result);
3224 appendUiConfigString(result);
3225 appendGuiConfigString(result);
3226 result.append("\n");
3227
3228 colorizer.bold(result);
3229 result.append("Sync configuration: ");
3230 colorizer.reset(result);
3231 result.append(SyncFeatures::getInstance().toString());
3232 result.append("\n");
3233
3234 colorizer.bold(result);
3235 result.append("DispSync configuration: ");
3236 colorizer.reset(result);
3237 result.appendFormat("app phase %" PRId64 " ns, sf phase %" PRId64 " ns, "
Fabien Sanglardc45a7d92017-03-14 13:24:22 -07003238 "present offset %" PRId64 " ns (refresh %" PRId64 " ns)",
3239 vsyncPhaseOffsetNs, sfVsyncPhaseOffsetNs, dispSyncPresentTimeOffset,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003240 mHwc->getRefreshPeriod(HWC_DISPLAY_PRIMARY));
3241 result.append("\n");
3242
3243 // Dump static screen stats
3244 result.append("\n");
3245 dumpStaticScreenStats(result);
3246 result.append("\n");
3247
3248 dumpBufferingStats(result);
3249
3250 /*
3251 * Dump the visible layer list
3252 */
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003253 colorizer.bold(result);
Robert Carr1f0a16a2016-10-24 16:27:39 -07003254 result.appendFormat("Visible layers (count = %zu)\n", mNumLayers);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003255 colorizer.reset(result);
Robert Carr2047fae2016-11-28 14:09:09 -08003256 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003257 layer->dump(result, colorizer);
Robert Carr2047fae2016-11-28 14:09:09 -08003258 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003259
3260 /*
3261 * Dump Display state
3262 */
3263
3264 colorizer.bold(result);
3265 result.appendFormat("Displays (%zu entries)\n", mDisplays.size());
3266 colorizer.reset(result);
3267 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
3268 const sp<const DisplayDevice>& hw(mDisplays[dpy]);
3269 hw->dump(result);
3270 }
3271
3272 /*
3273 * Dump SurfaceFlinger global state
3274 */
3275
3276 colorizer.bold(result);
3277 result.append("SurfaceFlinger global state:\n");
3278 colorizer.reset(result);
3279
3280 HWComposer& hwc(getHwComposer());
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07003281 sp<const DisplayDevice> hw(getDefaultDisplayDeviceLocked());
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003282
3283 colorizer.bold(result);
3284 result.appendFormat("EGL implementation : %s\n",
3285 eglQueryStringImplementationANDROID(mEGLDisplay, EGL_VERSION));
3286 colorizer.reset(result);
3287 result.appendFormat("%s\n",
3288 eglQueryStringImplementationANDROID(mEGLDisplay, EGL_EXTENSIONS));
3289
3290 mRenderEngine->dump(result);
3291
3292 hw->undefinedRegion.dump(result, "undefinedRegion");
3293 result.appendFormat(" orientation=%d, isDisplayOn=%d\n",
3294 hw->getOrientation(), hw->isDisplayOn());
3295 result.appendFormat(
3296 " last eglSwapBuffers() time: %f us\n"
3297 " last transaction time : %f us\n"
3298 " transaction-flags : %08x\n"
3299 " refresh-rate : %f fps\n"
3300 " x-dpi : %f\n"
3301 " y-dpi : %f\n"
3302 " gpu_to_cpu_unsupported : %d\n"
3303 ,
3304 mLastSwapBufferTime/1000.0,
3305 mLastTransactionTime/1000.0,
3306 mTransactionFlags,
3307 1e9 / hwc.getRefreshPeriod(HWC_DISPLAY_PRIMARY),
3308 hwc.getDpiX(HWC_DISPLAY_PRIMARY),
3309 hwc.getDpiY(HWC_DISPLAY_PRIMARY),
3310 !mGpuToCpuSupported);
3311
3312 result.appendFormat(" eglSwapBuffers time: %f us\n",
3313 inSwapBuffersDuration/1000.0);
3314
3315 result.appendFormat(" transaction time: %f us\n",
3316 inTransactionDuration/1000.0);
3317
3318 /*
3319 * VSYNC state
3320 */
3321 mEventThread->dump(result);
3322
3323 /*
3324 * Dump HWComposer state
3325 */
3326 colorizer.bold(result);
3327 result.append("h/w composer state:\n");
3328 colorizer.reset(result);
3329 result.appendFormat(" h/w composer %s and %s\n",
3330 hwc.initCheck()==NO_ERROR ? "present" : "not present",
3331 (mDebugDisableHWC || mDebugRegion || mDaltonize
3332 || mHasColorMatrix) ? "disabled" : "enabled");
3333 hwc.dump(result);
3334
3335 /*
3336 * Dump gralloc state
3337 */
3338 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
3339 alloc.dump(result);
3340}
3341
3342const Vector< sp<Layer> >&
3343SurfaceFlinger::getLayerSortedByZForHwcDisplay(int id) {
3344 // Note: mStateLock is held here
3345 wp<IBinder> dpy;
3346 for (size_t i=0 ; i<mDisplays.size() ; i++) {
3347 if (mDisplays.valueAt(i)->getHwcDisplayId() == id) {
3348 dpy = mDisplays.keyAt(i);
3349 break;
3350 }
3351 }
3352 if (dpy == NULL) {
3353 ALOGE("getLayerSortedByZForHwcDisplay: invalid hwc display id %d", id);
3354 // Just use the primary display so we have something to return
3355 dpy = getBuiltInDisplay(DisplayDevice::DISPLAY_PRIMARY);
3356 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07003357 return getDisplayDeviceLocked(dpy)->getVisibleLayersSortedByZ();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003358}
3359
3360bool SurfaceFlinger::startDdmConnection()
3361{
3362 void* libddmconnection_dso =
3363 dlopen("libsurfaceflinger_ddmconnection.so", RTLD_NOW);
3364 if (!libddmconnection_dso) {
3365 return false;
3366 }
3367 void (*DdmConnection_start)(const char* name);
3368 DdmConnection_start =
3369 (decltype(DdmConnection_start))dlsym(libddmconnection_dso, "DdmConnection_start");
3370 if (!DdmConnection_start) {
3371 dlclose(libddmconnection_dso);
3372 return false;
3373 }
3374 (*DdmConnection_start)(getServiceName());
3375 return true;
3376}
3377
3378status_t SurfaceFlinger::onTransact(
3379 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
3380{
3381 switch (code) {
3382 case CREATE_CONNECTION:
3383 case CREATE_DISPLAY:
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003384 case BOOT_FINISHED:
3385 case CLEAR_ANIMATION_FRAME_STATS:
3386 case GET_ANIMATION_FRAME_STATS:
3387 case SET_POWER_MODE:
3388 case GET_HDR_CAPABILITIES:
3389 {
3390 // codes that require permission check
3391 IPCThreadState* ipc = IPCThreadState::self();
3392 const int pid = ipc->getCallingPid();
3393 const int uid = ipc->getCallingUid();
3394 if ((uid != AID_GRAPHICS && uid != AID_SYSTEM) &&
3395 !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)) {
3396 ALOGE("Permission Denial: "
3397 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
3398 return PERMISSION_DENIED;
3399 }
3400 break;
3401 }
Robert Carr1db73f62016-12-21 12:58:51 -08003402 /*
3403 * Calling setTransactionState is safe, because you need to have been
3404 * granted a reference to Client* and Handle* to do anything with it.
3405 *
3406 * Creating a scoped connection is safe, as per discussion in ISurfaceComposer.h
3407 */
3408 case SET_TRANSACTION_STATE:
3409 case CREATE_SCOPED_CONNECTION:
3410 {
3411 break;
3412 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003413 case CAPTURE_SCREEN:
3414 {
3415 // codes that require permission check
3416 IPCThreadState* ipc = IPCThreadState::self();
3417 const int pid = ipc->getCallingPid();
3418 const int uid = ipc->getCallingUid();
3419 if ((uid != AID_GRAPHICS) &&
3420 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
3421 ALOGE("Permission Denial: "
3422 "can't read framebuffer pid=%d, uid=%d", pid, uid);
3423 return PERMISSION_DENIED;
3424 }
3425 break;
3426 }
3427 }
3428
3429 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
3430 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
3431 CHECK_INTERFACE(ISurfaceComposer, data, reply);
3432 if (CC_UNLIKELY(!PermissionCache::checkCallingPermission(sHardwareTest))) {
3433 IPCThreadState* ipc = IPCThreadState::self();
3434 const int pid = ipc->getCallingPid();
3435 const int uid = ipc->getCallingUid();
3436 ALOGE("Permission Denial: "
3437 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
3438 return PERMISSION_DENIED;
3439 }
3440 int n;
3441 switch (code) {
3442 case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
3443 case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
3444 return NO_ERROR;
3445 case 1002: // SHOW_UPDATES
3446 n = data.readInt32();
3447 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
3448 invalidateHwcGeometry();
3449 repaintEverything();
3450 return NO_ERROR;
3451 case 1004:{ // repaint everything
3452 repaintEverything();
3453 return NO_ERROR;
3454 }
3455 case 1005:{ // force transaction
3456 setTransactionFlags(
3457 eTransactionNeeded|
3458 eDisplayTransactionNeeded|
3459 eTraversalNeeded);
3460 return NO_ERROR;
3461 }
3462 case 1006:{ // send empty update
3463 signalRefresh();
3464 return NO_ERROR;
3465 }
3466 case 1008: // toggle use of hw composer
3467 n = data.readInt32();
3468 mDebugDisableHWC = n ? 1 : 0;
3469 invalidateHwcGeometry();
3470 repaintEverything();
3471 return NO_ERROR;
3472 case 1009: // toggle use of transform hint
3473 n = data.readInt32();
3474 mDebugDisableTransformHint = n ? 1 : 0;
3475 invalidateHwcGeometry();
3476 repaintEverything();
3477 return NO_ERROR;
3478 case 1010: // interrogate.
3479 reply->writeInt32(0);
3480 reply->writeInt32(0);
3481 reply->writeInt32(mDebugRegion);
3482 reply->writeInt32(0);
3483 reply->writeInt32(mDebugDisableHWC);
3484 return NO_ERROR;
3485 case 1013: {
3486 Mutex::Autolock _l(mStateLock);
3487 sp<const DisplayDevice> hw(getDefaultDisplayDevice());
3488 reply->writeInt32(hw->getPageFlipCount());
3489 return NO_ERROR;
3490 }
3491 case 1014: {
3492 // daltonize
3493 n = data.readInt32();
3494 switch (n % 10) {
3495 case 1:
3496 mDaltonizer.setType(ColorBlindnessType::Protanomaly);
3497 break;
3498 case 2:
3499 mDaltonizer.setType(ColorBlindnessType::Deuteranomaly);
3500 break;
3501 case 3:
3502 mDaltonizer.setType(ColorBlindnessType::Tritanomaly);
3503 break;
3504 }
3505 if (n >= 10) {
3506 mDaltonizer.setMode(ColorBlindnessMode::Correction);
3507 } else {
3508 mDaltonizer.setMode(ColorBlindnessMode::Simulation);
3509 }
3510 mDaltonize = n > 0;
3511 invalidateHwcGeometry();
3512 repaintEverything();
3513 return NO_ERROR;
3514 }
3515 case 1015: {
3516 // apply a color matrix
3517 n = data.readInt32();
3518 mHasColorMatrix = n ? 1 : 0;
3519 if (n) {
3520 // color matrix is sent as mat3 matrix followed by vec3
3521 // offset, then packed into a mat4 where the last row is
3522 // the offset and extra values are 0
3523 for (size_t i = 0 ; i < 4; i++) {
3524 for (size_t j = 0; j < 4; j++) {
3525 mColorMatrix[i][j] = data.readFloat();
3526 }
3527 }
3528 } else {
3529 mColorMatrix = mat4();
3530 }
3531 invalidateHwcGeometry();
3532 repaintEverything();
3533 return NO_ERROR;
3534 }
3535 // This is an experimental interface
3536 // Needs to be shifted to proper binder interface when we productize
3537 case 1016: {
3538 n = data.readInt32();
3539 mPrimaryDispSync.setRefreshSkipCount(n);
3540 return NO_ERROR;
3541 }
3542 case 1017: {
3543 n = data.readInt32();
3544 mForceFullDamage = static_cast<bool>(n);
3545 return NO_ERROR;
3546 }
3547 case 1018: { // Modify Choreographer's phase offset
3548 n = data.readInt32();
3549 mEventThread->setPhaseOffset(static_cast<nsecs_t>(n));
3550 return NO_ERROR;
3551 }
3552 case 1019: { // Modify SurfaceFlinger's phase offset
3553 n = data.readInt32();
3554 mSFEventThread->setPhaseOffset(static_cast<nsecs_t>(n));
3555 return NO_ERROR;
3556 }
3557 case 1020: { // Layer updates interceptor
3558 n = data.readInt32();
3559 if (n) {
3560 ALOGV("Interceptor enabled");
3561 mInterceptor.enable(mDrawingState.layersSortedByZ, mDrawingState.displays);
3562 }
3563 else{
3564 ALOGV("Interceptor disabled");
3565 mInterceptor.disable();
3566 }
3567 return NO_ERROR;
3568 }
3569 case 1021: { // Disable HWC virtual displays
3570 n = data.readInt32();
3571 mUseHwcVirtualDisplays = !n;
3572 return NO_ERROR;
3573 }
3574 }
3575 }
3576 return err;
3577}
3578
3579void SurfaceFlinger::repaintEverything() {
3580 android_atomic_or(1, &mRepaintEverything);
3581 signalTransaction();
3582}
3583
3584// ---------------------------------------------------------------------------
3585// Capture screen into an IGraphiBufferProducer
3586// ---------------------------------------------------------------------------
3587
3588/* The code below is here to handle b/8734824
3589 *
3590 * We create a IGraphicBufferProducer wrapper that forwards all calls
3591 * from the surfaceflinger thread to the calling binder thread, where they
3592 * are executed. This allows the calling thread in the calling process to be
3593 * reused and not depend on having "enough" binder threads to handle the
3594 * requests.
3595 */
3596class GraphicProducerWrapper : public BBinder, public MessageHandler {
3597 /* Parts of GraphicProducerWrapper are run on two different threads,
3598 * communicating by sending messages via Looper but also by shared member
3599 * data. Coherence maintenance is subtle and in places implicit (ugh).
3600 *
3601 * Don't rely on Looper's sendMessage/handleMessage providing
3602 * release/acquire semantics for any data not actually in the Message.
3603 * Data going from surfaceflinger to binder threads needs to be
3604 * synchronized explicitly.
3605 *
3606 * Barrier open/wait do provide release/acquire semantics. This provides
3607 * implicit synchronization for data coming back from binder to
3608 * surfaceflinger threads.
3609 */
3610
3611 sp<IGraphicBufferProducer> impl;
3612 sp<Looper> looper;
3613 status_t result;
3614 bool exitPending;
3615 bool exitRequested;
3616 Barrier barrier;
3617 uint32_t code;
3618 Parcel const* data;
3619 Parcel* reply;
3620
3621 enum {
3622 MSG_API_CALL,
3623 MSG_EXIT
3624 };
3625
3626 /*
3627 * Called on surfaceflinger thread. This is called by our "fake"
3628 * BpGraphicBufferProducer. We package the data and reply Parcel and
3629 * forward them to the binder thread.
3630 */
3631 virtual status_t transact(uint32_t code,
3632 const Parcel& data, Parcel* reply, uint32_t /* flags */) {
3633 this->code = code;
3634 this->data = &data;
3635 this->reply = reply;
3636 if (exitPending) {
3637 // if we've exited, we run the message synchronously right here.
3638 // note (JH): as far as I can tell from looking at the code, this
3639 // never actually happens. if it does, i'm not sure if it happens
3640 // on the surfaceflinger or binder thread.
3641 handleMessage(Message(MSG_API_CALL));
3642 } else {
3643 barrier.close();
3644 // Prevent stores to this->{code, data, reply} from being
3645 // reordered later than the construction of Message.
3646 atomic_thread_fence(memory_order_release);
3647 looper->sendMessage(this, Message(MSG_API_CALL));
3648 barrier.wait();
3649 }
3650 return result;
3651 }
3652
3653 /*
3654 * here we run on the binder thread. All we've got to do is
3655 * call the real BpGraphicBufferProducer.
3656 */
3657 virtual void handleMessage(const Message& message) {
3658 int what = message.what;
3659 // Prevent reads below from happening before the read from Message
3660 atomic_thread_fence(memory_order_acquire);
3661 if (what == MSG_API_CALL) {
3662 result = IInterface::asBinder(impl)->transact(code, data[0], reply);
3663 barrier.open();
3664 } else if (what == MSG_EXIT) {
3665 exitRequested = true;
3666 }
3667 }
3668
3669public:
3670 explicit GraphicProducerWrapper(const sp<IGraphicBufferProducer>& impl)
3671 : impl(impl),
3672 looper(new Looper(true)),
3673 result(NO_ERROR),
3674 exitPending(false),
3675 exitRequested(false),
3676 code(0),
3677 data(NULL),
3678 reply(NULL)
3679 {}
3680
3681 // Binder thread
3682 status_t waitForResponse() {
3683 do {
3684 looper->pollOnce(-1);
3685 } while (!exitRequested);
3686 return result;
3687 }
3688
3689 // Client thread
3690 void exit(status_t result) {
3691 this->result = result;
3692 exitPending = true;
3693 // Ensure this->result is visible to the binder thread before it
3694 // handles the message.
3695 atomic_thread_fence(memory_order_release);
3696 looper->sendMessage(this, Message(MSG_EXIT));
3697 }
3698};
3699
3700
3701status_t SurfaceFlinger::captureScreen(const sp<IBinder>& display,
3702 const sp<IGraphicBufferProducer>& producer,
3703 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Robert Carrae060832016-11-28 10:51:00 -08003704 int32_t minLayerZ, int32_t maxLayerZ,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003705 bool useIdentityTransform, ISurfaceComposer::Rotation rotation) {
3706
3707 if (CC_UNLIKELY(display == 0))
3708 return BAD_VALUE;
3709
3710 if (CC_UNLIKELY(producer == 0))
3711 return BAD_VALUE;
3712
3713 // if we have secure windows on this display, never allow the screen capture
3714 // unless the producer interface is local (i.e.: we can take a screenshot for
3715 // ourselves).
3716 bool isLocalScreenshot = IInterface::asBinder(producer)->localBinder();
3717
3718 // Convert to surfaceflinger's internal rotation type.
3719 Transform::orientation_flags rotationFlags;
3720 switch (rotation) {
3721 case ISurfaceComposer::eRotateNone:
3722 rotationFlags = Transform::ROT_0;
3723 break;
3724 case ISurfaceComposer::eRotate90:
3725 rotationFlags = Transform::ROT_90;
3726 break;
3727 case ISurfaceComposer::eRotate180:
3728 rotationFlags = Transform::ROT_180;
3729 break;
3730 case ISurfaceComposer::eRotate270:
3731 rotationFlags = Transform::ROT_270;
3732 break;
3733 default:
3734 rotationFlags = Transform::ROT_0;
3735 ALOGE("Invalid rotation passed to captureScreen(): %d\n", rotation);
3736 break;
3737 }
3738
3739 class MessageCaptureScreen : public MessageBase {
3740 SurfaceFlinger* flinger;
3741 sp<IBinder> display;
3742 sp<IGraphicBufferProducer> producer;
3743 Rect sourceCrop;
3744 uint32_t reqWidth, reqHeight;
Robert Carrae060832016-11-28 10:51:00 -08003745 int32_t minLayerZ,maxLayerZ;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003746 bool useIdentityTransform;
3747 Transform::orientation_flags rotation;
3748 status_t result;
3749 bool isLocalScreenshot;
3750 public:
3751 MessageCaptureScreen(SurfaceFlinger* flinger,
3752 const sp<IBinder>& display,
3753 const sp<IGraphicBufferProducer>& producer,
3754 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Robert Carrae060832016-11-28 10:51:00 -08003755 int32_t minLayerZ, int32_t maxLayerZ,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003756 bool useIdentityTransform,
3757 Transform::orientation_flags rotation,
3758 bool isLocalScreenshot)
3759 : flinger(flinger), display(display), producer(producer),
3760 sourceCrop(sourceCrop), reqWidth(reqWidth), reqHeight(reqHeight),
3761 minLayerZ(minLayerZ), maxLayerZ(maxLayerZ),
3762 useIdentityTransform(useIdentityTransform),
3763 rotation(rotation), result(PERMISSION_DENIED),
3764 isLocalScreenshot(isLocalScreenshot)
3765 {
3766 }
3767 status_t getResult() const {
3768 return result;
3769 }
3770 virtual bool handler() {
3771 Mutex::Autolock _l(flinger->mStateLock);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07003772 sp<const DisplayDevice> hw(flinger->getDisplayDeviceLocked(display));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003773 result = flinger->captureScreenImplLocked(hw, producer,
3774 sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ,
3775 useIdentityTransform, rotation, isLocalScreenshot);
3776 static_cast<GraphicProducerWrapper*>(IInterface::asBinder(producer).get())->exit(result);
3777 return true;
3778 }
3779 };
3780
3781 // this creates a "fake" BBinder which will serve as a "fake" remote
3782 // binder to receive the marshaled calls and forward them to the
3783 // real remote (a BpGraphicBufferProducer)
3784 sp<GraphicProducerWrapper> wrapper = new GraphicProducerWrapper(producer);
3785
3786 // the asInterface() call below creates our "fake" BpGraphicBufferProducer
3787 // which does the marshaling work forwards to our "fake remote" above.
3788 sp<MessageBase> msg = new MessageCaptureScreen(this,
3789 display, IGraphicBufferProducer::asInterface( wrapper ),
3790 sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ,
3791 useIdentityTransform, rotationFlags, isLocalScreenshot);
3792
3793 status_t res = postMessageAsync(msg);
3794 if (res == NO_ERROR) {
3795 res = wrapper->waitForResponse();
3796 }
3797 return res;
3798}
3799
3800
3801void SurfaceFlinger::renderScreenImplLocked(
3802 const sp<const DisplayDevice>& hw,
3803 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Robert Carrae060832016-11-28 10:51:00 -08003804 int32_t minLayerZ, int32_t maxLayerZ,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003805 bool yswap, bool useIdentityTransform, Transform::orientation_flags rotation)
3806{
3807 ATRACE_CALL();
3808 RenderEngine& engine(getRenderEngine());
3809
3810 // get screen geometry
3811 const int32_t hw_w = hw->getWidth();
3812 const int32_t hw_h = hw->getHeight();
3813 const bool filtering = static_cast<int32_t>(reqWidth) != hw_w ||
3814 static_cast<int32_t>(reqHeight) != hw_h;
3815
3816 // if a default or invalid sourceCrop is passed in, set reasonable values
3817 if (sourceCrop.width() == 0 || sourceCrop.height() == 0 ||
3818 !sourceCrop.isValid()) {
3819 sourceCrop.setLeftTop(Point(0, 0));
3820 sourceCrop.setRightBottom(Point(hw_w, hw_h));
3821 }
3822
3823 // ensure that sourceCrop is inside screen
3824 if (sourceCrop.left < 0) {
3825 ALOGE("Invalid crop rect: l = %d (< 0)", sourceCrop.left);
3826 }
3827 if (sourceCrop.right > hw_w) {
3828 ALOGE("Invalid crop rect: r = %d (> %d)", sourceCrop.right, hw_w);
3829 }
3830 if (sourceCrop.top < 0) {
3831 ALOGE("Invalid crop rect: t = %d (< 0)", sourceCrop.top);
3832 }
3833 if (sourceCrop.bottom > hw_h) {
3834 ALOGE("Invalid crop rect: b = %d (> %d)", sourceCrop.bottom, hw_h);
3835 }
3836
3837 // make sure to clear all GL error flags
3838 engine.checkErrors();
3839
3840 // set-up our viewport
3841 engine.setViewportAndProjection(
3842 reqWidth, reqHeight, sourceCrop, hw_h, yswap, rotation);
3843 engine.disableTexturing();
3844
3845 // redraw the screen entirely...
3846 engine.clearWithColor(0, 0, 0, 1);
3847
Robert Carr1f0a16a2016-10-24 16:27:39 -07003848 // We loop through the first level of layers without traversing,
3849 // as we need to interpret min/max layer Z in the top level Z space.
3850 for (const auto& layer : mDrawingState.layersSortedByZ) {
3851 if (layer->getLayerStack() != hw->getLayerStack()) {
3852 continue;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003853 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07003854 const Layer::State& state(layer->getDrawingState());
3855 if (state.z < minLayerZ || state.z > maxLayerZ) {
3856 continue;
3857 }
Dan Stoza412903f2017-04-27 13:42:17 -07003858 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003859 if (!layer->isVisible()) {
3860 return;
3861 }
3862 if (filtering) layer->setFiltering(true);
3863 layer->draw(hw, useIdentityTransform);
3864 if (filtering) layer->setFiltering(false);
3865 });
3866 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003867
3868 // compositionComplete is needed for older driver
3869 hw->compositionComplete();
3870 hw->setViewportAndProjection();
3871}
3872
3873
3874status_t SurfaceFlinger::captureScreenImplLocked(
3875 const sp<const DisplayDevice>& hw,
3876 const sp<IGraphicBufferProducer>& producer,
3877 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Robert Carrae060832016-11-28 10:51:00 -08003878 int32_t minLayerZ, int32_t maxLayerZ,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003879 bool useIdentityTransform, Transform::orientation_flags rotation,
3880 bool isLocalScreenshot)
3881{
3882 ATRACE_CALL();
3883
3884 // get screen geometry
3885 uint32_t hw_w = hw->getWidth();
3886 uint32_t hw_h = hw->getHeight();
3887
3888 if (rotation & Transform::ROT_90) {
3889 std::swap(hw_w, hw_h);
3890 }
3891
3892 if ((reqWidth > hw_w) || (reqHeight > hw_h)) {
3893 ALOGE("size mismatch (%d, %d) > (%d, %d)",
3894 reqWidth, reqHeight, hw_w, hw_h);
3895 return BAD_VALUE;
3896 }
3897
3898 reqWidth = (!reqWidth) ? hw_w : reqWidth;
3899 reqHeight = (!reqHeight) ? hw_h : reqHeight;
3900
3901 bool secureLayerIsVisible = false;
Robert Carr1f0a16a2016-10-24 16:27:39 -07003902 for (const auto& layer : mDrawingState.layersSortedByZ) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003903 const Layer::State& state(layer->getDrawingState());
Robert Carr1f0a16a2016-10-24 16:27:39 -07003904 if ((layer->getLayerStack() != hw->getLayerStack()) ||
3905 (state.z < minLayerZ || state.z > maxLayerZ)) {
3906 continue;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003907 }
Dan Stoza412903f2017-04-27 13:42:17 -07003908 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer *layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003909 secureLayerIsVisible = secureLayerIsVisible || (layer->isVisible() &&
3910 layer->isSecure());
3911 });
3912 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003913
3914 if (!isLocalScreenshot && secureLayerIsVisible) {
3915 ALOGW("FB is protected: PERMISSION_DENIED");
3916 return PERMISSION_DENIED;
3917 }
3918
3919 // create a surface (because we're a producer, and we need to
3920 // dequeue/queue a buffer)
3921 sp<Surface> sur = new Surface(producer, false);
3922 ANativeWindow* window = sur.get();
3923
3924 status_t result = native_window_api_connect(window, NATIVE_WINDOW_API_EGL);
3925 if (result == NO_ERROR) {
3926 uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
3927 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
3928
3929 int err = 0;
3930 err = native_window_set_buffers_dimensions(window, reqWidth, reqHeight);
3931 err |= native_window_set_scaling_mode(window, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
3932 err |= native_window_set_buffers_format(window, HAL_PIXEL_FORMAT_RGBA_8888);
3933 err |= native_window_set_usage(window, usage);
3934
3935 if (err == NO_ERROR) {
3936 ANativeWindowBuffer* buffer;
3937 /* TODO: Once we have the sync framework everywhere this can use
3938 * server-side waits on the fence that dequeueBuffer returns.
3939 */
3940 result = native_window_dequeue_buffer_and_wait(window, &buffer);
3941 if (result == NO_ERROR) {
3942 int syncFd = -1;
3943 // create an EGLImage from the buffer so we can later
3944 // turn it into a texture
3945 EGLImageKHR image = eglCreateImageKHR(mEGLDisplay, EGL_NO_CONTEXT,
3946 EGL_NATIVE_BUFFER_ANDROID, buffer, NULL);
3947 if (image != EGL_NO_IMAGE_KHR) {
3948 // this binds the given EGLImage as a framebuffer for the
3949 // duration of this scope.
3950 RenderEngine::BindImageAsFramebuffer imageBond(getRenderEngine(), image);
3951 if (imageBond.getStatus() == NO_ERROR) {
3952 // this will in fact render into our dequeued buffer
3953 // via an FBO, which means we didn't have to create
3954 // an EGLSurface and therefore we're not
3955 // dependent on the context's EGLConfig.
3956 renderScreenImplLocked(
3957 hw, sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ, true,
3958 useIdentityTransform, rotation);
3959
3960 // Attempt to create a sync khr object that can produce a sync point. If that
3961 // isn't available, create a non-dupable sync object in the fallback path and
3962 // wait on it directly.
3963 EGLSyncKHR sync;
3964 if (!DEBUG_SCREENSHOTS) {
3965 sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, NULL);
3966 // native fence fd will not be populated until flush() is done.
3967 getRenderEngine().flush();
3968 } else {
3969 sync = EGL_NO_SYNC_KHR;
3970 }
3971 if (sync != EGL_NO_SYNC_KHR) {
3972 // get the sync fd
3973 syncFd = eglDupNativeFenceFDANDROID(mEGLDisplay, sync);
3974 if (syncFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
3975 ALOGW("captureScreen: failed to dup sync khr object");
3976 syncFd = -1;
3977 }
3978 eglDestroySyncKHR(mEGLDisplay, sync);
3979 } else {
3980 // fallback path
3981 sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, NULL);
3982 if (sync != EGL_NO_SYNC_KHR) {
3983 EGLint result = eglClientWaitSyncKHR(mEGLDisplay, sync,
3984 EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, 2000000000 /*2 sec*/);
3985 EGLint eglErr = eglGetError();
3986 if (result == EGL_TIMEOUT_EXPIRED_KHR) {
3987 ALOGW("captureScreen: fence wait timed out");
3988 } else {
3989 ALOGW_IF(eglErr != EGL_SUCCESS,
3990 "captureScreen: error waiting on EGL fence: %#x", eglErr);
3991 }
3992 eglDestroySyncKHR(mEGLDisplay, sync);
3993 } else {
3994 ALOGW("captureScreen: error creating EGL fence: %#x", eglGetError());
3995 }
3996 }
3997 if (DEBUG_SCREENSHOTS) {
3998 uint32_t* pixels = new uint32_t[reqWidth*reqHeight];
3999 getRenderEngine().readPixels(0, 0, reqWidth, reqHeight, pixels);
4000 checkScreenshot(reqWidth, reqHeight, reqWidth, pixels,
4001 hw, minLayerZ, maxLayerZ);
4002 delete [] pixels;
4003 }
4004
4005 } else {
4006 ALOGE("got GL_FRAMEBUFFER_COMPLETE_OES error while taking screenshot");
4007 result = INVALID_OPERATION;
4008 window->cancelBuffer(window, buffer, syncFd);
4009 buffer = NULL;
4010 }
4011 // destroy our image
4012 eglDestroyImageKHR(mEGLDisplay, image);
4013 } else {
4014 result = BAD_VALUE;
4015 }
4016 if (buffer) {
4017 // queueBuffer takes ownership of syncFd
4018 result = window->queueBuffer(window, buffer, syncFd);
4019 }
4020 }
4021 } else {
4022 result = BAD_VALUE;
4023 }
4024 native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
4025 }
4026
4027 return result;
4028}
4029
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004030void SurfaceFlinger::checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
Robert Carrae060832016-11-28 10:51:00 -08004031 const sp<const DisplayDevice>& hw, int32_t minLayerZ, int32_t maxLayerZ) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004032 if (DEBUG_SCREENSHOTS) {
4033 for (size_t y=0 ; y<h ; y++) {
4034 uint32_t const * p = (uint32_t const *)vaddr + y*s;
4035 for (size_t x=0 ; x<w ; x++) {
4036 if (p[x] != 0xFF000000) return;
4037 }
4038 }
4039 ALOGE("*** we just took a black screenshot ***\n"
4040 "requested minz=%d, maxz=%d, layerStack=%d",
4041 minLayerZ, maxLayerZ, hw->getLayerStack());
Robert Carr2047fae2016-11-28 14:09:09 -08004042 size_t i = 0;
Robert Carr1f0a16a2016-10-24 16:27:39 -07004043 for (const auto& layer : mDrawingState.layersSortedByZ) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004044 const Layer::State& state(layer->getDrawingState());
Robert Carr1f0a16a2016-10-24 16:27:39 -07004045 if (layer->getLayerStack() == hw->getLayerStack() && state.z >= minLayerZ &&
4046 state.z <= maxLayerZ) {
Dan Stoza412903f2017-04-27 13:42:17 -07004047 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07004048 ALOGE("%c index=%zu, name=%s, layerStack=%d, z=%d, visible=%d, flags=%x, alpha=%x",
4049 layer->isVisible() ? '+' : '-',
4050 i, layer->getName().string(), layer->getLayerStack(), state.z,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004051 layer->isVisible(), state.flags, state.alpha);
Robert Carr1f0a16a2016-10-24 16:27:39 -07004052 i++;
4053 });
4054 }
4055 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004056 }
4057}
4058
4059// ---------------------------------------------------------------------------
4060
Dan Stoza412903f2017-04-27 13:42:17 -07004061void SurfaceFlinger::State::traverseInZOrder(const LayerVector::Visitor& visitor) const {
4062 layersSortedByZ.traverseInZOrder(stateSet, visitor);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004063}
4064
Dan Stoza412903f2017-04-27 13:42:17 -07004065void SurfaceFlinger::State::traverseInReverseZOrder(const LayerVector::Visitor& visitor) const {
4066 layersSortedByZ.traverseInReverseZOrder(stateSet, visitor);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004067}
4068
4069}; // namespace android
4070
4071
4072#if defined(__gl_h_)
4073#error "don't include gl/gl.h in this file"
4074#endif
4075
4076#if defined(__gl2_h_)
4077#error "don't include gl2/gl2.h in this file"
4078#endif