blob: 3d421d215482dfec78a4ba935ea3dfaad6940e23 [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 Wangb254fa32017-01-31 17:43:23 -0800323 if (mStartBootAnimThread->join() != NO_ERROR) {
324 ALOGE("Join StartBootAnimThread failed!");
325 }
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
504void SurfaceFlinger::init() {
505 ALOGI( "SurfaceFlinger's main thread ready to run. "
506 "Initializing graphics H/W...");
507
508 Mutex::Autolock _l(mStateLock);
509
510 // initialize EGL for the default display
511 mEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
512 eglInitialize(mEGLDisplay, NULL, NULL);
513
514 // start the EventThread
515 sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,
516 vsyncPhaseOffsetNs, true, "app");
517 mEventThread = new EventThread(vsyncSrc, *this, false);
518 sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,
519 sfVsyncPhaseOffsetNs, true, "sf");
520 mSFEventThread = new EventThread(sfVsyncSrc, *this, true);
521 mEventQueue.setEventThread(mSFEventThread);
522
Tim Murray22752852017-05-04 13:38:49 -0700523 // set EventThread and SFEventThread to SCHED_FIFO to minimize jitter
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000524 struct sched_param param = {0};
525 param.sched_priority = 2;
526 if (sched_setscheduler(mSFEventThread->getTid(), SCHED_FIFO, &param) != 0) {
527 ALOGE("Couldn't set SCHED_FIFO for SFEventThread");
528 }
Tim Murray22752852017-05-04 13:38:49 -0700529 if (sched_setscheduler(mEventThread->getTid(), SCHED_FIFO, &param) != 0) {
530 ALOGE("Couldn't set SCHED_FIFO for EventThread");
531 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000532
533 // Initialize the H/W composer object. There may or may not be an
534 // actual hardware composer underneath.
535 mHwc = new HWComposer(this,
536 *static_cast<HWComposer::EventHandler *>(this));
537
538 // get a RenderEngine for the given display / config (can't fail)
539 mRenderEngine = RenderEngine::create(mEGLDisplay, mHwc->getVisualID());
540
541 // retrieve the EGL context that was selected/created
542 mEGLContext = mRenderEngine->getEGLContext();
543
544 LOG_ALWAYS_FATAL_IF(mEGLContext == EGL_NO_CONTEXT,
545 "couldn't create EGLContext");
546
Ian Elliott5c34de22017-04-10 14:42:30 -0600547 // Inform native graphics APIs that the present timestamp is NOT supported:
548 property_set(kTimestampProperty, "0");
549
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000550 // 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 Wangb254fa32017-01-31 17:43:23 -0800602 mStartBootAnimThread = new StartBootAnimThread();
603 if (mStartBootAnimThread->Start() != NO_ERROR) {
604 ALOGE("Run StartBootAnimThread failed!");
605 }
606
607 ALOGV("Done initializing");
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000608}
609
610int32_t SurfaceFlinger::allocateHwcDisplayId(DisplayDevice::DisplayType type) {
611 return (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) ?
612 type : mHwc->allocateDisplayId();
613}
614
615void SurfaceFlinger::startBootAnim() {
Wei Wangb254fa32017-01-31 17:43:23 -0800616 // Start boot animation service by setting a property mailbox
617 // if property setting thread is already running, Start() will be just a NOP
618 mStartBootAnimThread->Start();
619 // Wait until property was set
620 if (mStartBootAnimThread->join() != NO_ERROR) {
621 ALOGE("Join StartBootAnimThread failed!");
622 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000623}
624
625size_t SurfaceFlinger::getMaxTextureSize() const {
626 return mRenderEngine->getMaxTextureSize();
627}
628
629size_t SurfaceFlinger::getMaxViewportDims() const {
630 return mRenderEngine->getMaxViewportDims();
631}
632
633// ----------------------------------------------------------------------------
634
635bool SurfaceFlinger::authenticateSurfaceTexture(
636 const sp<IGraphicBufferProducer>& bufferProducer) const {
637 Mutex::Autolock _l(mStateLock);
Robert Carr0d480722017-01-10 16:42:54 -0800638 return authenticateSurfaceTextureLocked(bufferProducer);
639}
640
641bool SurfaceFlinger::authenticateSurfaceTextureLocked(
642 const sp<IGraphicBufferProducer>& bufferProducer) const {
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000643 sp<IBinder> surfaceTextureBinder(IInterface::asBinder(bufferProducer));
644 return mGraphicBufferProducerList.indexOf(surfaceTextureBinder) >= 0;
645}
646
Brian Anderson6b376712017-04-04 10:51:39 -0700647status_t SurfaceFlinger::getSupportedFrameTimestamps(
648 std::vector<FrameEvent>* outSupported) const {
649 *outSupported = {
650 FrameEvent::REQUESTED_PRESENT,
651 FrameEvent::ACQUIRE,
652 FrameEvent::LATCH,
653 FrameEvent::FIRST_REFRESH_START,
654 FrameEvent::LAST_REFRESH_START,
655 FrameEvent::GPU_COMPOSITION_DONE,
656 FrameEvent::DEQUEUE_READY,
657 FrameEvent::RELEASE,
658 };
659 return NO_ERROR;
660}
661
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000662status_t SurfaceFlinger::getDisplayConfigs(const sp<IBinder>& display,
663 Vector<DisplayInfo>* configs) {
664 if ((configs == NULL) || (display.get() == NULL)) {
665 return BAD_VALUE;
666 }
667
668 int32_t type = getDisplayType(display);
669 if (type < 0) return type;
670
671 // TODO: Not sure if display density should handled by SF any longer
672 class Density {
673 static int getDensityFromProperty(char const* propName) {
674 char property[PROPERTY_VALUE_MAX];
675 int density = 0;
676 if (property_get(propName, property, NULL) > 0) {
677 density = atoi(property);
678 }
679 return density;
680 }
681 public:
682 static int getEmuDensity() {
683 return getDensityFromProperty("qemu.sf.lcd_density"); }
684 static int getBuildDensity() {
685 return getDensityFromProperty("ro.sf.lcd_density"); }
686 };
687
688 configs->clear();
689
690 const Vector<HWComposer::DisplayConfig>& hwConfigs =
691 getHwComposer().getConfigs(type);
692 for (size_t c = 0; c < hwConfigs.size(); ++c) {
693 const HWComposer::DisplayConfig& hwConfig = hwConfigs[c];
694 DisplayInfo info = DisplayInfo();
695
696 float xdpi = hwConfig.xdpi;
697 float ydpi = hwConfig.ydpi;
698
699 if (type == DisplayDevice::DISPLAY_PRIMARY) {
700 // The density of the device is provided by a build property
701 float density = Density::getBuildDensity() / 160.0f;
702 if (density == 0) {
703 // the build doesn't provide a density -- this is wrong!
704 // use xdpi instead
705 ALOGE("ro.sf.lcd_density must be defined as a build property");
706 density = xdpi / 160.0f;
707 }
708 if (Density::getEmuDensity()) {
709 // if "qemu.sf.lcd_density" is specified, it overrides everything
710 xdpi = ydpi = density = Density::getEmuDensity();
711 density /= 160.0f;
712 }
713 info.density = density;
714
715 // TODO: this needs to go away (currently needed only by webkit)
716 sp<const DisplayDevice> hw(getDefaultDisplayDevice());
717 info.orientation = hw->getOrientation();
718 } else {
719 // TODO: where should this value come from?
720 static const int TV_DENSITY = 213;
721 info.density = TV_DENSITY / 160.0f;
722 info.orientation = 0;
723 }
724
725 info.w = hwConfig.width;
726 info.h = hwConfig.height;
727 info.xdpi = xdpi;
728 info.ydpi = ydpi;
729 info.fps = float(1e9 / hwConfig.refresh);
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800730 info.appVsyncOffset = vsyncPhaseOffsetNs;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000731
732 // This is how far in advance a buffer must be queued for
733 // presentation at a given time. If you want a buffer to appear
734 // on the screen at time N, you must submit the buffer before
735 // (N - presentationDeadline).
736 //
737 // Normally it's one full refresh period (to give SF a chance to
738 // latch the buffer), but this can be reduced by configuring a
739 // DispSync offset. Any additional delays introduced by the hardware
740 // composer or panel must be accounted for here.
741 //
742 // We add an additional 1ms to allow for processing time and
743 // differences between the ideal and actual refresh rate.
744 info.presentationDeadline =
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800745 hwConfig.refresh - sfVsyncPhaseOffsetNs + 1000000;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000746
747 // All non-virtual displays are currently considered secure.
748 info.secure = true;
749
750 configs->push_back(info);
751 }
752
753 return NO_ERROR;
754}
755
756status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>& /* display */,
757 DisplayStatInfo* stats) {
758 if (stats == NULL) {
759 return BAD_VALUE;
760 }
761
762 // FIXME for now we always return stats for the primary display
763 memset(stats, 0, sizeof(*stats));
764 stats->vsyncTime = mPrimaryDispSync.computeNextRefresh(0);
765 stats->vsyncPeriod = mPrimaryDispSync.getPeriod();
766 return NO_ERROR;
767}
768
769int SurfaceFlinger::getActiveConfig(const sp<IBinder>& display) {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700770 sp<const DisplayDevice> device(getDisplayDevice(display));
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000771 if (device != NULL) {
772 return device->getActiveConfig();
773 }
774 return BAD_VALUE;
775}
776
777void SurfaceFlinger::setActiveConfigInternal(const sp<DisplayDevice>& hw, int mode) {
778 ALOGD("Set active config mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(),
779 this);
780 int32_t type = hw->getDisplayType();
781 int currentMode = hw->getActiveConfig();
782
783 if (mode == currentMode) {
784 ALOGD("Screen type=%d is already mode=%d", hw->getDisplayType(), mode);
785 return;
786 }
787
788 if (type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
789 ALOGW("Trying to set config for virtual display");
790 return;
791 }
792
793 hw->setActiveConfig(mode);
794 getHwComposer().setActiveConfig(type, mode);
795}
796
797status_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& display, int mode) {
798 class MessageSetActiveConfig: public MessageBase {
799 SurfaceFlinger& mFlinger;
800 sp<IBinder> mDisplay;
801 int mMode;
802 public:
803 MessageSetActiveConfig(SurfaceFlinger& flinger, const sp<IBinder>& disp,
804 int mode) :
805 mFlinger(flinger), mDisplay(disp) { mMode = mode; }
806 virtual bool handler() {
807 Vector<DisplayInfo> configs;
808 mFlinger.getDisplayConfigs(mDisplay, &configs);
809 if (mMode < 0 || mMode >= static_cast<int>(configs.size())) {
810 ALOGE("Attempt to set active config = %d for display with %zu configs",
811 mMode, configs.size());
812 }
813 sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
814 if (hw == NULL) {
815 ALOGE("Attempt to set active config = %d for null display %p",
816 mMode, mDisplay.get());
817 } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) {
818 ALOGW("Attempt to set active config = %d for virtual display",
819 mMode);
820 } else {
821 mFlinger.setActiveConfigInternal(hw, mMode);
822 }
823 return true;
824 }
825 };
826 sp<MessageBase> msg = new MessageSetActiveConfig(*this, display, mode);
827 postMessageSync(msg);
828 return NO_ERROR;
829}
830
831status_t SurfaceFlinger::getDisplayColorModes(const sp<IBinder>& display,
832 Vector<android_color_mode_t>* outColorModes) {
833 if (outColorModes == nullptr || display.get() == nullptr) {
834 return BAD_VALUE;
835 }
836
837 int32_t type = getDisplayType(display);
838 if (type < 0) return type;
839
840 std::set<android_color_mode_t> colorModes;
841 for (const HWComposer::DisplayConfig& hwConfig : getHwComposer().getConfigs(type)) {
842 colorModes.insert(hwConfig.colorMode);
843 }
844
845 outColorModes->clear();
846 std::copy(colorModes.cbegin(), colorModes.cend(), std::back_inserter(*outColorModes));
847
848 return NO_ERROR;
849}
850
851android_color_mode_t SurfaceFlinger::getActiveColorMode(const sp<IBinder>& display) {
852 if (display.get() == nullptr) return static_cast<android_color_mode_t>(BAD_VALUE);
853
854 int32_t type = getDisplayType(display);
855 if (type < 0) return static_cast<android_color_mode_t>(type);
856
857 return getHwComposer().getColorMode(type);
858}
859
860status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& display,
861 android_color_mode_t colorMode) {
862 if (display.get() == nullptr || colorMode < 0) {
863 return BAD_VALUE;
864 }
865
866 int32_t type = getDisplayType(display);
867 if (type < 0) return type;
868 const Vector<HWComposer::DisplayConfig>& hwConfigs = getHwComposer().getConfigs(type);
869 HWComposer::DisplayConfig desiredConfig = hwConfigs[getHwComposer().getCurrentConfig(type)];
870 desiredConfig.colorMode = colorMode;
871 for (size_t c = 0; c < hwConfigs.size(); ++c) {
872 const HWComposer::DisplayConfig config = hwConfigs[c];
873 if (config == desiredConfig) {
874 return setActiveConfig(display, c);
875 }
876 }
877 return BAD_VALUE;
878}
879
880status_t SurfaceFlinger::clearAnimationFrameStats() {
881 Mutex::Autolock _l(mStateLock);
882 mAnimFrameTracker.clearStats();
883 return NO_ERROR;
884}
885
886status_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const {
887 Mutex::Autolock _l(mStateLock);
888 mAnimFrameTracker.getStats(outStats);
889 return NO_ERROR;
890}
891
892status_t SurfaceFlinger::getHdrCapabilities(const sp<IBinder>& /*display*/,
893 HdrCapabilities* outCapabilities) const {
894 // HWC1 does not provide HDR capabilities
895 *outCapabilities = HdrCapabilities();
896 return NO_ERROR;
897}
898
899status_t SurfaceFlinger::enableVSyncInjections(bool enable) {
900 if (enable == mInjectVSyncs) {
901 return NO_ERROR;
902 }
903
904 if (enable) {
905 mInjectVSyncs = enable;
906 ALOGV("VSync Injections enabled");
907 if (mVSyncInjector.get() == nullptr) {
908 mVSyncInjector = new InjectVSyncSource();
909 mInjectorEventThread = new EventThread(mVSyncInjector, *this, false);
910 }
911 mEventQueue.setEventThread(mInjectorEventThread);
912 } else {
913 mInjectVSyncs = enable;
914 ALOGV("VSync Injections disabled");
915 mEventQueue.setEventThread(mSFEventThread);
916 mVSyncInjector.clear();
917 }
918 return NO_ERROR;
919}
920
921status_t SurfaceFlinger::injectVSync(nsecs_t when) {
922 if (!mInjectVSyncs) {
923 ALOGE("VSync Injections not enabled");
924 return BAD_VALUE;
925 }
926 if (mInjectVSyncs && mInjectorEventThread.get() != nullptr) {
927 ALOGV("Injecting VSync inside SurfaceFlinger");
928 mVSyncInjector->onInjectSyncEvent(when);
929 }
930 return NO_ERROR;
931}
932
933// ----------------------------------------------------------------------------
934
Jorim Jaggiaaef0982017-06-08 23:55:29 -0700935sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection(
936 ISurfaceComposer::VsyncSource vsyncSource) {
937 if (vsyncSource == eVsyncSourceSurfaceFlinger) {
938 return mSFEventThread->createEventConnection();
939 } else {
940 return mEventThread->createEventConnection();
941 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000942}
943
944// ----------------------------------------------------------------------------
945
946void SurfaceFlinger::waitForEvent() {
947 mEventQueue.waitMessage();
948}
949
950void SurfaceFlinger::signalTransaction() {
951 mEventQueue.invalidate();
952}
953
954void SurfaceFlinger::signalLayerUpdate() {
955 mEventQueue.invalidate();
956}
957
958void SurfaceFlinger::signalRefresh() {
959 mEventQueue.refresh();
960}
961
962status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,
963 nsecs_t reltime, uint32_t /* flags */) {
964 return mEventQueue.postMessage(msg, reltime);
965}
966
967status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
968 nsecs_t reltime, uint32_t /* flags */) {
969 status_t res = mEventQueue.postMessage(msg, reltime);
970 if (res == NO_ERROR) {
971 msg->wait();
972 }
973 return res;
974}
975
976void SurfaceFlinger::run() {
977 do {
978 waitForEvent();
979 } while (true);
980}
981
982void SurfaceFlinger::enableHardwareVsync() {
983 Mutex::Autolock _l(mHWVsyncLock);
984 if (!mPrimaryHWVsyncEnabled && mHWVsyncAvailable) {
985 mPrimaryDispSync.beginResync();
986 //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true);
987 mEventControlThread->setVsyncEnabled(true);
988 mPrimaryHWVsyncEnabled = true;
989 }
990}
991
992void SurfaceFlinger::resyncToHardwareVsync(bool makeAvailable) {
993 Mutex::Autolock _l(mHWVsyncLock);
994
995 if (makeAvailable) {
996 mHWVsyncAvailable = true;
997 } else if (!mHWVsyncAvailable) {
998 // Hardware vsync is not currently available, so abort the resync
999 // attempt for now
1000 return;
1001 }
1002
1003 const nsecs_t period =
1004 getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
1005
1006 mPrimaryDispSync.reset();
1007 mPrimaryDispSync.setPeriod(period);
1008
1009 if (!mPrimaryHWVsyncEnabled) {
1010 mPrimaryDispSync.beginResync();
1011 //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true);
1012 mEventControlThread->setVsyncEnabled(true);
1013 mPrimaryHWVsyncEnabled = true;
1014 }
1015}
1016
1017void SurfaceFlinger::disableHardwareVsync(bool makeUnavailable) {
1018 Mutex::Autolock _l(mHWVsyncLock);
1019 if (mPrimaryHWVsyncEnabled) {
1020 //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, false);
1021 mEventControlThread->setVsyncEnabled(false);
1022 mPrimaryDispSync.endResync();
1023 mPrimaryHWVsyncEnabled = false;
1024 }
1025 if (makeUnavailable) {
1026 mHWVsyncAvailable = false;
1027 }
1028}
1029
1030void SurfaceFlinger::resyncWithRateLimit() {
1031 static constexpr nsecs_t kIgnoreDelay = ms2ns(500);
1032 if (systemTime() - mLastSwapTime > kIgnoreDelay) {
1033 resyncToHardwareVsync(false);
1034 }
1035}
1036
Steven Thomas3cfac282017-02-06 12:29:30 -08001037void SurfaceFlinger::onVSyncReceived(HWComposer* /*composer*/, int type,
1038 nsecs_t timestamp) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001039 bool needsHwVsync = false;
1040
1041 { // Scope for the lock
1042 Mutex::Autolock _l(mHWVsyncLock);
1043 if (type == 0 && mPrimaryHWVsyncEnabled) {
1044 needsHwVsync = mPrimaryDispSync.addResyncSample(timestamp);
1045 }
1046 }
1047
1048 if (needsHwVsync) {
1049 enableHardwareVsync();
1050 } else {
1051 disableHardwareVsync(false);
1052 }
1053}
1054
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001055void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
Brian Andersond0010582017-03-07 13:20:31 -08001056 std::lock_guard<std::mutex> lock(mCompositorTimingLock);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001057 *compositorTiming = mCompositorTiming;
1058}
1059
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001060void SurfaceFlinger::onHotplugReceived(HWComposer* /*composer*/, int type, bool connected) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001061 if (mEventThread == NULL) {
1062 // This is a temporary workaround for b/7145521. A non-null pointer
1063 // does not mean EventThread has finished initializing, so this
1064 // is not a correct fix.
1065 ALOGW("WARNING: EventThread not started, ignoring hotplug");
1066 return;
1067 }
1068
1069 if (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
1070 Mutex::Autolock _l(mStateLock);
1071 if (connected) {
1072 createBuiltinDisplayLocked((DisplayDevice::DisplayType)type);
1073 } else {
1074 mCurrentState.displays.removeItem(mBuiltinDisplays[type]);
1075 mBuiltinDisplays[type].clear();
1076 }
1077 setTransactionFlags(eDisplayTransactionNeeded);
1078
1079 // Defer EventThread notification until SF has updated mDisplays.
1080 }
1081}
1082
Steven Thomas3cfac282017-02-06 12:29:30 -08001083void SurfaceFlinger::onInvalidateReceived(HWComposer* /*composer*/) {
1084 repaintEverything();
1085}
1086
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001087void SurfaceFlinger::eventControl(int disp, int event, int enabled) {
1088 ATRACE_CALL();
1089 getHwComposer().eventControl(disp, event, enabled);
1090}
1091
1092void SurfaceFlinger::onMessageReceived(int32_t what) {
1093 ATRACE_CALL();
1094 switch (what) {
1095 case MessageQueue::INVALIDATE: {
1096 bool refreshNeeded = handleMessageTransaction();
1097 refreshNeeded |= handleMessageInvalidate();
1098 refreshNeeded |= mRepaintEverything;
1099 if (refreshNeeded) {
1100 // Signal a refresh if a transaction modified the window state,
1101 // a new buffer was latched, or if HWC has requested a full
1102 // repaint
1103 signalRefresh();
1104 }
1105 break;
1106 }
1107 case MessageQueue::REFRESH: {
1108 handleMessageRefresh();
1109 break;
1110 }
1111 }
1112}
1113
1114bool SurfaceFlinger::handleMessageTransaction() {
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08001115 uint32_t transactionFlags = peekTransactionFlags();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001116 if (transactionFlags) {
1117 handleTransaction(transactionFlags);
1118 return true;
1119 }
1120 return false;
1121}
1122
1123bool SurfaceFlinger::handleMessageInvalidate() {
1124 ATRACE_CALL();
1125 return handlePageFlip();
1126}
1127
1128void SurfaceFlinger::handleMessageRefresh() {
1129 ATRACE_CALL();
1130
1131 nsecs_t refreshStartTime = systemTime(SYSTEM_TIME_MONOTONIC);
1132
Brian Andersond6927fb2016-07-23 23:37:30 -07001133 preComposition(refreshStartTime);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001134 rebuildLayerStacks();
1135 setUpHWComposer();
1136 doDebugFlashRegions();
1137 doComposition();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001138 postComposition(refreshStartTime);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001139}
1140
1141void SurfaceFlinger::doDebugFlashRegions()
1142{
1143 // is debugging enabled
1144 if (CC_LIKELY(!mDebugRegion))
1145 return;
1146
1147 const bool repaintEverything = mRepaintEverything;
1148 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1149 const sp<DisplayDevice>& hw(mDisplays[dpy]);
1150 if (hw->isDisplayOn()) {
1151 // transform the dirty region into this screen's coordinate space
1152 const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
1153 if (!dirtyRegion.isEmpty()) {
1154 // redraw the whole screen
1155 doComposeSurfaces(hw, Region(hw->bounds()));
1156
1157 // and draw the dirty region
1158 const int32_t height = hw->getHeight();
1159 RenderEngine& engine(getRenderEngine());
1160 engine.fillRegionWithColor(dirtyRegion, height, 1, 0, 1, 1);
1161
1162 hw->compositionComplete();
1163 hw->swapBuffers(getHwComposer());
1164 }
1165 }
1166 }
1167
1168 postFramebuffer();
1169
1170 if (mDebugRegion > 1) {
1171 usleep(mDebugRegion * 1000);
1172 }
1173
1174 HWComposer& hwc(getHwComposer());
1175 if (hwc.initCheck() == NO_ERROR) {
1176 status_t err = hwc.prepare();
1177 ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
1178 }
1179}
1180
Brian Andersond6927fb2016-07-23 23:37:30 -07001181void SurfaceFlinger::preComposition(nsecs_t refreshStartTime)
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001182{
1183 bool needExtraInvalidate = false;
Robert Carr2047fae2016-11-28 14:09:09 -08001184 mDrawingState.traverseInZOrder([&](Layer* layer) {
1185 if (layer->onPreComposition(refreshStartTime)) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001186 needExtraInvalidate = true;
1187 }
Robert Carr2047fae2016-11-28 14:09:09 -08001188 });
1189
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001190 if (needExtraInvalidate) {
1191 signalLayerUpdate();
1192 }
1193}
1194
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001195void SurfaceFlinger::updateCompositorTiming(
1196 nsecs_t vsyncPhase, nsecs_t vsyncInterval, nsecs_t compositeTime,
1197 std::shared_ptr<FenceTime>& presentFenceTime) {
1198 // Update queue of past composite+present times and determine the
1199 // most recently known composite to present latency.
1200 mCompositePresentTimes.push({compositeTime, presentFenceTime});
1201 nsecs_t compositeToPresentLatency = -1;
1202 while (!mCompositePresentTimes.empty()) {
1203 CompositePresentTime& cpt = mCompositePresentTimes.front();
1204 // Cached values should have been updated before calling this method,
1205 // which helps avoid duplicate syscalls.
1206 nsecs_t displayTime = cpt.display->getCachedSignalTime();
1207 if (displayTime == Fence::SIGNAL_TIME_PENDING) {
1208 break;
1209 }
1210 compositeToPresentLatency = displayTime - cpt.composite;
1211 mCompositePresentTimes.pop();
1212 }
1213
1214 // Don't let mCompositePresentTimes grow unbounded, just in case.
1215 while (mCompositePresentTimes.size() > 16) {
1216 mCompositePresentTimes.pop();
1217 }
1218
Brian Andersond0010582017-03-07 13:20:31 -08001219 setCompositorTimingSnapped(
1220 vsyncPhase, vsyncInterval, compositeToPresentLatency);
1221}
1222
1223void SurfaceFlinger::setCompositorTimingSnapped(nsecs_t vsyncPhase,
1224 nsecs_t vsyncInterval, nsecs_t compositeToPresentLatency) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001225 // Integer division and modulo round toward 0 not -inf, so we need to
1226 // treat negative and positive offsets differently.
Brian Andersond0010582017-03-07 13:20:31 -08001227 nsecs_t idealLatency = (sfVsyncPhaseOffsetNs > 0) ?
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001228 (vsyncInterval - (sfVsyncPhaseOffsetNs % vsyncInterval)) :
1229 ((-sfVsyncPhaseOffsetNs) % vsyncInterval);
1230
Brian Andersond0010582017-03-07 13:20:31 -08001231 // Just in case sfVsyncPhaseOffsetNs == -vsyncInterval.
1232 if (idealLatency <= 0) {
1233 idealLatency = vsyncInterval;
1234 }
1235
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001236 // Snap the latency to a value that removes scheduling jitter from the
1237 // composition and present times, which often have >1ms of jitter.
1238 // Reducing jitter is important if an app attempts to extrapolate
1239 // something (such as user input) to an accurate diasplay time.
1240 // Snapping also allows an app to precisely calculate sfVsyncPhaseOffsetNs
1241 // with (presentLatency % interval).
Brian Andersond0010582017-03-07 13:20:31 -08001242 nsecs_t bias = vsyncInterval / 2;
1243 int64_t extraVsyncs =
1244 (compositeToPresentLatency - idealLatency + bias) / vsyncInterval;
1245 nsecs_t snappedCompositeToPresentLatency = (extraVsyncs > 0) ?
1246 idealLatency + (extraVsyncs * vsyncInterval) : idealLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001247
Brian Andersond0010582017-03-07 13:20:31 -08001248 std::lock_guard<std::mutex> lock(mCompositorTimingLock);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001249 mCompositorTiming.deadline = vsyncPhase - idealLatency;
1250 mCompositorTiming.interval = vsyncInterval;
Brian Andersond0010582017-03-07 13:20:31 -08001251 mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001252}
1253
1254void SurfaceFlinger::postComposition(nsecs_t refreshStartTime)
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001255{
Brian Andersond6927fb2016-07-23 23:37:30 -07001256 const HWComposer& hwc = getHwComposer();
1257 const sp<const DisplayDevice> hw(getDefaultDisplayDevice());
1258
Brian Anderson3d4039d2016-09-23 16:31:30 -07001259 std::shared_ptr<FenceTime> glCompositionDoneFenceTime;
1260 if (getHwComposer().hasGlesComposition(hw->getHwcDisplayId())) {
1261 glCompositionDoneFenceTime =
1262 std::make_shared<FenceTime>(hw->getClientTargetAcquireFence());
1263 mGlCompositionDoneTimeline.push(glCompositionDoneFenceTime);
1264 } else {
1265 glCompositionDoneFenceTime = FenceTime::NO_FENCE;
1266 }
1267 mGlCompositionDoneTimeline.updateSignalTimes();
1268
Brian Anderson4e606e32017-03-16 15:34:57 -07001269 sp<Fence> retireFence = mHwc->getDisplayFence(HWC_DISPLAY_PRIMARY);
1270 auto retireFenceTime = std::make_shared<FenceTime>(retireFence);
Brian Anderson3d4039d2016-09-23 16:31:30 -07001271 mDisplayTimeline.push(retireFenceTime);
1272 mDisplayTimeline.updateSignalTimes();
Brian Andersond6927fb2016-07-23 23:37:30 -07001273
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001274 nsecs_t vsyncPhase = mPrimaryDispSync.computeNextRefresh(0);
1275 nsecs_t vsyncInterval = mPrimaryDispSync.getPeriod();
1276
1277 // We use the refreshStartTime which might be sampled a little later than
1278 // when we started doing work for this frame, but that should be okay
1279 // since updateCompositorTiming has snapping logic.
1280 updateCompositorTiming(
1281 vsyncPhase, vsyncInterval, refreshStartTime, retireFenceTime);
Brian Andersond0010582017-03-07 13:20:31 -08001282 CompositorTiming compositorTiming;
1283 {
1284 std::lock_guard<std::mutex> lock(mCompositorTimingLock);
1285 compositorTiming = mCompositorTiming;
1286 }
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001287
Robert Carr2047fae2016-11-28 14:09:09 -08001288 mDrawingState.traverseInZOrder([&](Layer* layer) {
Brian Anderson4e606e32017-03-16 15:34:57 -07001289 // TODO(brianderson): The retire fence is incorrectly passed in as the
1290 // present fence. Fix this if this file lives on.
Robert Carr2047fae2016-11-28 14:09:09 -08001291 bool frameLatched = layer->onPostComposition(glCompositionDoneFenceTime,
Brian Anderson4e606e32017-03-16 15:34:57 -07001292 retireFenceTime, compositorTiming);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001293 if (frameLatched) {
Robert Carr2047fae2016-11-28 14:09:09 -08001294 recordBufferingStats(layer->getName().string(),
1295 layer->getOccupancyHistory(false));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001296 }
Robert Carr2047fae2016-11-28 14:09:09 -08001297 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001298
Brian Anderson4e606e32017-03-16 15:34:57 -07001299 if (retireFence->isValid()) {
1300 if (mPrimaryDispSync.addPresentFence(retireFence)) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001301 enableHardwareVsync();
1302 } else {
1303 disableHardwareVsync(false);
1304 }
1305 }
1306
Fabien Sanglardcbf153b2017-03-10 17:57:12 -08001307 if (!hasSyncFramework) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001308 if (hw->isDisplayOn()) {
1309 enableHardwareVsync();
1310 }
1311 }
1312
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001313 if (mAnimCompositionPending) {
1314 mAnimCompositionPending = false;
1315
Brian Anderson3d4039d2016-09-23 16:31:30 -07001316 if (retireFenceTime->isValid()) {
1317 mAnimFrameTracker.setActualPresentFence(std::move(retireFenceTime));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001318 } else {
1319 // The HWC doesn't support present fences, so use the refresh
1320 // timestamp instead.
1321 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY);
1322 mAnimFrameTracker.setActualPresentTime(presentTime);
1323 }
1324 mAnimFrameTracker.advanceFrame();
1325 }
1326
1327 if (hw->getPowerMode() == HWC_POWER_MODE_OFF) {
1328 return;
1329 }
1330
1331 nsecs_t currentTime = systemTime();
1332 if (mHasPoweredOff) {
1333 mHasPoweredOff = false;
1334 } else {
1335 nsecs_t period = mPrimaryDispSync.getPeriod();
1336 nsecs_t elapsedTime = currentTime - mLastSwapTime;
1337 size_t numPeriods = static_cast<size_t>(elapsedTime / period);
1338 if (numPeriods < NUM_BUCKETS - 1) {
1339 mFrameBuckets[numPeriods] += elapsedTime;
1340 } else {
1341 mFrameBuckets[NUM_BUCKETS - 1] += elapsedTime;
1342 }
1343 mTotalTime += elapsedTime;
1344 }
1345 mLastSwapTime = currentTime;
1346}
1347
1348void SurfaceFlinger::rebuildLayerStacks() {
1349 // rebuild the visible layer list per screen
1350 if (CC_UNLIKELY(mVisibleRegionsDirty)) {
1351 ATRACE_CALL();
1352 mVisibleRegionsDirty = false;
1353 invalidateHwcGeometry();
1354
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001355 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1356 Region opaqueRegion;
1357 Region dirtyRegion;
1358 Vector< sp<Layer> > layersSortedByZ;
1359 const sp<DisplayDevice>& hw(mDisplays[dpy]);
1360 const Transform& tr(hw->getTransform());
1361 const Rect bounds(hw->getBounds());
1362 if (hw->isDisplayOn()) {
Robert Carr2047fae2016-11-28 14:09:09 -08001363 computeVisibleRegions(hw->getLayerStack(), dirtyRegion,
1364 opaqueRegion);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001365
Robert Carr2047fae2016-11-28 14:09:09 -08001366 mDrawingState.traverseInZOrder([&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07001367 if (layer->getLayerStack() == hw->getLayerStack()) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001368 Region drawRegion(tr.transform(
1369 layer->visibleNonTransparentRegion));
1370 drawRegion.andSelf(bounds);
1371 if (!drawRegion.isEmpty()) {
1372 layersSortedByZ.add(layer);
1373 }
1374 }
Robert Carr2047fae2016-11-28 14:09:09 -08001375 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001376 }
1377 hw->setVisibleLayersSortedByZ(layersSortedByZ);
1378 hw->undefinedRegion.set(bounds);
1379 hw->undefinedRegion.subtractSelf(tr.transform(opaqueRegion));
1380 hw->dirtyRegion.orSelf(dirtyRegion);
1381 }
1382 }
1383}
1384
1385void SurfaceFlinger::setUpHWComposer() {
1386 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1387 bool dirty = !mDisplays[dpy]->getDirtyRegion(false).isEmpty();
1388 bool empty = mDisplays[dpy]->getVisibleLayersSortedByZ().size() == 0;
1389 bool wasEmpty = !mDisplays[dpy]->lastCompositionHadVisibleLayers;
1390
1391 // If nothing has changed (!dirty), don't recompose.
1392 // If something changed, but we don't currently have any visible layers,
1393 // and didn't when we last did a composition, then skip it this time.
1394 // The second rule does two things:
1395 // - When all layers are removed from a display, we'll emit one black
1396 // frame, then nothing more until we get new layers.
1397 // - When a display is created with a private layer stack, we won't
1398 // emit any black frames until a layer is added to the layer stack.
1399 bool mustRecompose = dirty && !(empty && wasEmpty);
1400
1401 ALOGV_IF(mDisplays[dpy]->getDisplayType() == DisplayDevice::DISPLAY_VIRTUAL,
1402 "dpy[%zu]: %s composition (%sdirty %sempty %swasEmpty)", dpy,
1403 mustRecompose ? "doing" : "skipping",
1404 dirty ? "+" : "-",
1405 empty ? "+" : "-",
1406 wasEmpty ? "+" : "-");
1407
1408 mDisplays[dpy]->beginFrame(mustRecompose);
1409
1410 if (mustRecompose) {
1411 mDisplays[dpy]->lastCompositionHadVisibleLayers = !empty;
1412 }
1413 }
1414
1415 HWComposer& hwc(getHwComposer());
1416 if (hwc.initCheck() == NO_ERROR) {
1417 // build the h/w work list
1418 if (CC_UNLIKELY(mHwWorkListDirty)) {
1419 mHwWorkListDirty = false;
1420 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1421 sp<const DisplayDevice> hw(mDisplays[dpy]);
1422 const int32_t id = hw->getHwcDisplayId();
1423 if (id >= 0) {
1424 const Vector< sp<Layer> >& currentLayers(
1425 hw->getVisibleLayersSortedByZ());
1426 const size_t count = currentLayers.size();
1427 if (hwc.createWorkList(id, count) == NO_ERROR) {
1428 HWComposer::LayerListIterator cur = hwc.begin(id);
1429 const HWComposer::LayerListIterator end = hwc.end(id);
1430 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1431 const sp<Layer>& layer(currentLayers[i]);
1432 layer->setGeometry(hw, *cur);
1433 if (mDebugDisableHWC || mDebugRegion || mDaltonize || mHasColorMatrix) {
1434 cur->setSkip(true);
1435 }
1436 }
1437 }
1438 }
1439 }
1440 }
1441
1442 // set the per-frame data
1443 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1444 sp<const DisplayDevice> hw(mDisplays[dpy]);
1445 const int32_t id = hw->getHwcDisplayId();
1446 if (id >= 0) {
1447 const Vector< sp<Layer> >& currentLayers(
1448 hw->getVisibleLayersSortedByZ());
1449 const size_t count = currentLayers.size();
1450 HWComposer::LayerListIterator cur = hwc.begin(id);
1451 const HWComposer::LayerListIterator end = hwc.end(id);
1452 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1453 /*
1454 * update the per-frame h/w composer data for each layer
1455 * and build the transparent region of the FB
1456 */
1457 const sp<Layer>& layer(currentLayers[i]);
1458 layer->setPerFrameData(hw, *cur);
1459 }
1460 }
1461 }
1462
1463 // If possible, attempt to use the cursor overlay on each display.
1464 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1465 sp<const DisplayDevice> hw(mDisplays[dpy]);
1466 const int32_t id = hw->getHwcDisplayId();
1467 if (id >= 0) {
1468 const Vector< sp<Layer> >& currentLayers(
1469 hw->getVisibleLayersSortedByZ());
1470 const size_t count = currentLayers.size();
1471 HWComposer::LayerListIterator cur = hwc.begin(id);
1472 const HWComposer::LayerListIterator end = hwc.end(id);
1473 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1474 const sp<Layer>& layer(currentLayers[i]);
1475 if (layer->isPotentialCursor()) {
1476 cur->setIsCursorLayerHint();
1477 break;
1478 }
1479 }
1480 }
1481 }
1482
1483 status_t err = hwc.prepare();
1484 ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
1485
1486 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1487 sp<const DisplayDevice> hw(mDisplays[dpy]);
1488 hw->prepareFrame(hwc);
1489 }
1490 }
1491}
1492
1493void SurfaceFlinger::doComposition() {
1494 ATRACE_CALL();
1495 const bool repaintEverything = android_atomic_and(0, &mRepaintEverything);
1496 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1497 const sp<DisplayDevice>& hw(mDisplays[dpy]);
1498 if (hw->isDisplayOn()) {
1499 // transform the dirty region into this screen's coordinate space
1500 const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
1501
1502 // repaint the framebuffer (if needed)
1503 doDisplayComposition(hw, dirtyRegion);
1504
1505 hw->dirtyRegion.clear();
1506 hw->flip(hw->swapRegion);
1507 hw->swapRegion.clear();
1508 }
1509 // inform the h/w that we're done compositing
1510 hw->compositionComplete();
1511 }
1512 postFramebuffer();
1513}
1514
1515void SurfaceFlinger::postFramebuffer()
1516{
1517 ATRACE_CALL();
1518
1519 const nsecs_t now = systemTime();
1520 mDebugInSwapBuffers = now;
1521
1522 HWComposer& hwc(getHwComposer());
1523 if (hwc.initCheck() == NO_ERROR) {
1524 if (!hwc.supportsFramebufferTarget()) {
1525 // EGL spec says:
1526 // "surface must be bound to the calling thread's current context,
1527 // for the current rendering API."
1528 getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
1529 }
1530 hwc.commit();
1531 }
1532
1533 // make the default display current because the VirtualDisplayDevice code cannot
1534 // deal with dequeueBuffer() being called outside of the composition loop; however
1535 // the code below can call glFlush() which is allowed (and does in some case) call
1536 // dequeueBuffer().
1537 getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
1538
1539 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1540 sp<const DisplayDevice> hw(mDisplays[dpy]);
1541 const Vector< sp<Layer> >& currentLayers(hw->getVisibleLayersSortedByZ());
1542 hw->onSwapBuffersCompleted(hwc);
1543 const size_t count = currentLayers.size();
1544 int32_t id = hw->getHwcDisplayId();
1545 if (id >=0 && hwc.initCheck() == NO_ERROR) {
1546 HWComposer::LayerListIterator cur = hwc.begin(id);
1547 const HWComposer::LayerListIterator end = hwc.end(id);
1548 for (size_t i = 0; cur != end && i < count; ++i, ++cur) {
1549 currentLayers[i]->onLayerDisplayed(hw, &*cur);
1550 }
1551 } else {
1552 for (size_t i = 0; i < count; i++) {
1553 currentLayers[i]->onLayerDisplayed(hw, NULL);
1554 }
1555 }
1556 }
1557
1558 mLastSwapBufferTime = systemTime() - now;
1559 mDebugInSwapBuffers = 0;
1560
1561 uint32_t flipCount = getDefaultDisplayDevice()->getPageFlipCount();
1562 if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
1563 logFrameStats();
1564 }
1565}
1566
1567void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
1568{
1569 ATRACE_CALL();
1570
1571 // here we keep a copy of the drawing state (that is the state that's
1572 // going to be overwritten by handleTransactionLocked()) outside of
1573 // mStateLock so that the side-effects of the State assignment
1574 // don't happen with mStateLock held (which can cause deadlocks).
1575 State drawingState(mDrawingState);
1576
1577 Mutex::Autolock _l(mStateLock);
1578 const nsecs_t now = systemTime();
1579 mDebugInTransaction = now;
1580
1581 // Here we're guaranteed that some transaction flags are set
1582 // so we can call handleTransactionLocked() unconditionally.
1583 // We call getTransactionFlags(), which will also clear the flags,
1584 // with mStateLock held to guarantee that mCurrentState won't change
1585 // until the transaction is committed.
1586
1587 transactionFlags = getTransactionFlags(eTransactionMask);
1588 handleTransactionLocked(transactionFlags);
1589
1590 mLastTransactionTime = systemTime() - now;
1591 mDebugInTransaction = 0;
1592 invalidateHwcGeometry();
1593 // here the transaction has been committed
1594}
1595
1596void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
1597{
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001598 // Notify all layers of available frames
Robert Carr2047fae2016-11-28 14:09:09 -08001599 mCurrentState.traverseInZOrder([](Layer* layer) {
1600 layer->notifyAvailableFrames();
1601 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001602
1603 /*
1604 * Traversal of the children
1605 * (perform the transaction for each of them if needed)
1606 */
1607
1608 if (transactionFlags & eTraversalNeeded) {
Robert Carr2047fae2016-11-28 14:09:09 -08001609 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001610 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
Robert Carr2047fae2016-11-28 14:09:09 -08001611 if (!trFlags) return;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001612
1613 const uint32_t flags = layer->doTransaction(0);
1614 if (flags & Layer::eVisibleRegion)
1615 mVisibleRegionsDirty = true;
Robert Carr2047fae2016-11-28 14:09:09 -08001616 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001617 }
1618
1619 /*
1620 * Perform display own transactions if needed
1621 */
1622
1623 if (transactionFlags & eDisplayTransactionNeeded) {
1624 // here we take advantage of Vector's copy-on-write semantics to
1625 // improve performance by skipping the transaction entirely when
1626 // know that the lists are identical
1627 const KeyedVector< wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
1628 const KeyedVector< wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
1629 if (!curr.isIdenticalTo(draw)) {
1630 mVisibleRegionsDirty = true;
1631 const size_t cc = curr.size();
1632 size_t dc = draw.size();
1633
1634 // find the displays that were removed
1635 // (ie: in drawing state but not in current state)
1636 // also handle displays that changed
1637 // (ie: displays that are in both lists)
1638 for (size_t i=0 ; i<dc ; i++) {
1639 const ssize_t j = curr.indexOfKey(draw.keyAt(i));
1640 if (j < 0) {
1641 // in drawing state but not in current state
1642 if (!draw[i].isMainDisplay()) {
1643 // Call makeCurrent() on the primary display so we can
1644 // be sure that nothing associated with this display
1645 // is current.
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001646 const sp<const DisplayDevice> defaultDisplay(getDefaultDisplayDeviceLocked());
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001647 defaultDisplay->makeCurrent(mEGLDisplay, mEGLContext);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001648 sp<DisplayDevice> hw(getDisplayDeviceLocked(draw.keyAt(i)));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001649 if (hw != NULL)
1650 hw->disconnect(getHwComposer());
1651 if (draw[i].type < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES)
1652 mEventThread->onHotplugReceived(draw[i].type, false);
1653 mDisplays.removeItem(draw.keyAt(i));
1654 } else {
1655 ALOGW("trying to remove the main display");
1656 }
1657 } else {
1658 // this display is in both lists. see if something changed.
1659 const DisplayDeviceState& state(curr[j]);
1660 const wp<IBinder>& display(curr.keyAt(j));
1661 const sp<IBinder> state_binder = IInterface::asBinder(state.surface);
1662 const sp<IBinder> draw_binder = IInterface::asBinder(draw[i].surface);
1663 if (state_binder != draw_binder) {
1664 // changing the surface is like destroying and
1665 // recreating the DisplayDevice, so we just remove it
1666 // from the drawing state, so that it get re-added
1667 // below.
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001668 sp<DisplayDevice> hw(getDisplayDeviceLocked(display));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001669 if (hw != NULL)
1670 hw->disconnect(getHwComposer());
1671 mDisplays.removeItem(display);
1672 mDrawingState.displays.removeItemsAt(i);
1673 dc--; i--;
1674 // at this point we must loop to the next item
1675 continue;
1676 }
1677
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001678 const sp<DisplayDevice> disp(getDisplayDeviceLocked(display));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001679 if (disp != NULL) {
1680 if (state.layerStack != draw[i].layerStack) {
1681 disp->setLayerStack(state.layerStack);
1682 }
1683 if ((state.orientation != draw[i].orientation)
1684 || (state.viewport != draw[i].viewport)
1685 || (state.frame != draw[i].frame))
1686 {
1687 disp->setProjection(state.orientation,
1688 state.viewport, state.frame);
1689 }
1690 if (state.width != draw[i].width || state.height != draw[i].height) {
1691 disp->setDisplaySize(state.width, state.height);
1692 }
1693 }
1694 }
1695 }
1696
1697 // find displays that were added
1698 // (ie: in current state but not in drawing state)
1699 for (size_t i=0 ; i<cc ; i++) {
1700 if (draw.indexOfKey(curr.keyAt(i)) < 0) {
1701 const DisplayDeviceState& state(curr[i]);
1702
1703 sp<DisplaySurface> dispSurface;
1704 sp<IGraphicBufferProducer> producer;
1705 sp<IGraphicBufferProducer> bqProducer;
1706 sp<IGraphicBufferConsumer> bqConsumer;
Mathias Agopian0556d792017-03-22 15:49:32 -07001707 BufferQueue::createBufferQueue(&bqProducer, &bqConsumer);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001708
1709 int32_t hwcDisplayId = -1;
1710 if (state.isVirtualDisplay()) {
1711 // Virtual displays without a surface are dormant:
1712 // they have external state (layer stack, projection,
1713 // etc.) but no internal state (i.e. a DisplayDevice).
1714 if (state.surface != NULL) {
1715
1716 int width = 0;
1717 int status = state.surface->query(
1718 NATIVE_WINDOW_WIDTH, &width);
1719 ALOGE_IF(status != NO_ERROR,
1720 "Unable to query width (%d)", status);
1721 int height = 0;
1722 status = state.surface->query(
1723 NATIVE_WINDOW_HEIGHT, &height);
1724 ALOGE_IF(status != NO_ERROR,
1725 "Unable to query height (%d)", status);
1726 if (mUseHwcVirtualDisplays &&
Fabien Sanglardc8e387e2017-03-10 10:30:28 -08001727 (SurfaceFlinger::maxVirtualDisplaySize == 0 ||
1728 (width <= static_cast<int>(SurfaceFlinger::maxVirtualDisplaySize) &&
1729 height <= static_cast<int>(SurfaceFlinger::maxVirtualDisplaySize)))) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001730 hwcDisplayId = allocateHwcDisplayId(state.type);
1731 }
1732
1733 sp<VirtualDisplaySurface> vds = new VirtualDisplaySurface(
1734 *mHwc, hwcDisplayId, state.surface,
1735 bqProducer, bqConsumer, state.displayName);
1736
1737 dispSurface = vds;
1738 producer = vds;
1739 }
1740 } else {
1741 ALOGE_IF(state.surface!=NULL,
1742 "adding a supported display, but rendering "
1743 "surface is provided (%p), ignoring it",
1744 state.surface.get());
1745 hwcDisplayId = allocateHwcDisplayId(state.type);
1746 // for supported (by hwc) displays we provide our
1747 // own rendering surface
1748 dispSurface = new FramebufferSurface(*mHwc, state.type,
1749 bqConsumer);
1750 producer = bqProducer;
1751 }
1752
1753 const wp<IBinder>& display(curr.keyAt(i));
1754 if (dispSurface != NULL) {
1755 sp<DisplayDevice> hw = new DisplayDevice(this,
1756 state.type, hwcDisplayId,
1757 mHwc->getFormat(hwcDisplayId), state.isSecure,
1758 display, dispSurface, producer,
Courtney Goeltzenleuchter4f20f9c2017-04-06 08:18:34 -06001759 mRenderEngine->getEGLConfig(), false);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001760 hw->setLayerStack(state.layerStack);
1761 hw->setProjection(state.orientation,
1762 state.viewport, state.frame);
1763 hw->setDisplayName(state.displayName);
1764 mDisplays.add(display, hw);
1765 if (state.isVirtualDisplay()) {
1766 if (hwcDisplayId >= 0) {
1767 mHwc->setVirtualDisplayProperties(hwcDisplayId,
1768 hw->getWidth(), hw->getHeight(),
1769 hw->getFormat());
1770 }
1771 } else {
1772 mEventThread->onHotplugReceived(state.type, true);
1773 }
1774 }
1775 }
1776 }
1777 }
1778 }
1779
1780 if (transactionFlags & (eTraversalNeeded|eDisplayTransactionNeeded)) {
1781 // The transform hint might have changed for some layers
1782 // (either because a display has changed, or because a layer
1783 // as changed).
1784 //
1785 // Walk through all the layers in currentLayers,
1786 // and update their transform hint.
1787 //
1788 // If a layer is visible only on a single display, then that
1789 // display is used to calculate the hint, otherwise we use the
1790 // default display.
1791 //
1792 // NOTE: we do this here, rather than in rebuildLayerStacks() so that
1793 // the hint is set before we acquire a buffer from the surface texture.
1794 //
1795 // NOTE: layer transactions have taken place already, so we use their
1796 // drawing state. However, SurfaceFlinger's own transaction has not
1797 // happened yet, so we must use the current state layer list
1798 // (soon to become the drawing state list).
1799 //
1800 sp<const DisplayDevice> disp;
1801 uint32_t currentlayerStack = 0;
Robert Carr2047fae2016-11-28 14:09:09 -08001802 bool first = true;
1803 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001804 // NOTE: we rely on the fact that layers are sorted by
1805 // layerStack first (so we don't have to traverse the list
1806 // of displays for every layer).
Robert Carr1f0a16a2016-10-24 16:27:39 -07001807 uint32_t layerStack = layer->getLayerStack();
Robert Carr2047fae2016-11-28 14:09:09 -08001808 if (first || currentlayerStack != layerStack) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001809 currentlayerStack = layerStack;
1810 // figure out if this layerstack is mirrored
1811 // (more than one display) if so, pick the default display,
1812 // if not, pick the only display it's on.
1813 disp.clear();
1814 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1815 sp<const DisplayDevice> hw(mDisplays[dpy]);
1816 if (hw->getLayerStack() == currentlayerStack) {
1817 if (disp == NULL) {
1818 disp = hw;
1819 } else {
1820 disp = NULL;
1821 break;
1822 }
1823 }
1824 }
1825 }
1826 if (disp == NULL) {
1827 // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
1828 // redraw after transform hint changes. See bug 8508397.
1829
1830 // could be null when this layer is using a layerStack
1831 // that is not visible on any display. Also can occur at
1832 // screen off/on times.
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001833 disp = getDefaultDisplayDeviceLocked();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001834 }
1835 layer->updateTransformHint(disp);
Robert Carr2047fae2016-11-28 14:09:09 -08001836
1837 first = false;
1838 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001839 }
1840
1841
1842 /*
1843 * Perform our own transaction if needed
1844 */
Robert Carr1f0a16a2016-10-24 16:27:39 -07001845
1846 if (mLayersAdded) {
1847 mLayersAdded = false;
1848 // Layers have been added.
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001849 mVisibleRegionsDirty = true;
1850 }
1851
1852 // some layers might have been removed, so
1853 // we need to update the regions they're exposing.
1854 if (mLayersRemoved) {
1855 mLayersRemoved = false;
1856 mVisibleRegionsDirty = true;
Robert Carr2047fae2016-11-28 14:09:09 -08001857 mDrawingState.traverseInZOrder([&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07001858 if (mLayersPendingRemoval.indexOf(layer) >= 0) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001859 // this layer is not visible anymore
1860 // TODO: we could traverse the tree from front to back and
1861 // compute the actual visible region
1862 // TODO: we could cache the transformed region
Robert Carr1f0a16a2016-10-24 16:27:39 -07001863 Region visibleReg;
1864 visibleReg.set(layer->computeScreenBounds());
1865 invalidateLayerStack(layer->getLayerStack(), visibleReg);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001866 }
Robert Carr2047fae2016-11-28 14:09:09 -08001867 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001868 }
1869
1870 commitTransaction();
1871
1872 updateCursorAsync();
1873}
1874
1875void SurfaceFlinger::updateCursorAsync()
1876{
1877 HWComposer& hwc(getHwComposer());
1878 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1879 sp<const DisplayDevice> hw(mDisplays[dpy]);
1880 const int32_t id = hw->getHwcDisplayId();
1881 if (id < 0) {
1882 continue;
1883 }
1884 const Vector< sp<Layer> >& currentLayers(
1885 hw->getVisibleLayersSortedByZ());
1886 const size_t count = currentLayers.size();
1887 HWComposer::LayerListIterator cur = hwc.begin(id);
1888 const HWComposer::LayerListIterator end = hwc.end(id);
1889 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1890 if (cur->getCompositionType() != HWC_CURSOR_OVERLAY) {
1891 continue;
1892 }
1893 const sp<Layer>& layer(currentLayers[i]);
1894 Rect cursorPos = layer->getPosition(hw);
1895 hwc.setCursorPositionAsync(id, cursorPos);
1896 break;
1897 }
1898 }
1899}
1900
1901void SurfaceFlinger::commitTransaction()
1902{
1903 if (!mLayersPendingRemoval.isEmpty()) {
1904 // Notify removed layers now that they can't be drawn from
Robert Carr1f0a16a2016-10-24 16:27:39 -07001905 for (const auto& l : mLayersPendingRemoval) {
1906 recordBufferingStats(l->getName().string(),
1907 l->getOccupancyHistory(true));
1908 l->onRemoved();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001909 }
1910 mLayersPendingRemoval.clear();
1911 }
1912
1913 // If this transaction is part of a window animation then the next frame
1914 // we composite should be considered an animation as well.
1915 mAnimCompositionPending = mAnimTransactionPending;
1916
1917 mDrawingState = mCurrentState;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001918 mDrawingState.traverseInZOrder([](Layer* layer) {
1919 layer->commitChildList();
1920 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001921 mTransactionPending = false;
1922 mAnimTransactionPending = false;
1923 mTransactionCV.broadcast();
1924}
1925
Robert Carr2047fae2016-11-28 14:09:09 -08001926void SurfaceFlinger::computeVisibleRegions(uint32_t layerStack,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001927 Region& outDirtyRegion, Region& outOpaqueRegion)
1928{
1929 ATRACE_CALL();
1930
1931 Region aboveOpaqueLayers;
1932 Region aboveCoveredLayers;
1933 Region dirty;
1934
1935 outDirtyRegion.clear();
1936
Robert Carr2047fae2016-11-28 14:09:09 -08001937 mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001938 // start with the whole surface at its current location
1939 const Layer::State& s(layer->getDrawingState());
1940
1941 // only consider the layers on the given layer stack
Robert Carr1f0a16a2016-10-24 16:27:39 -07001942 if (layer->getLayerStack() != layerStack)
Robert Carr2047fae2016-11-28 14:09:09 -08001943 return;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001944
1945 /*
1946 * opaqueRegion: area of a surface that is fully opaque.
1947 */
1948 Region opaqueRegion;
1949
1950 /*
1951 * visibleRegion: area of a surface that is visible on screen
1952 * and not fully transparent. This is essentially the layer's
1953 * footprint minus the opaque regions above it.
1954 * Areas covered by a translucent surface are considered visible.
1955 */
1956 Region visibleRegion;
1957
1958 /*
1959 * coveredRegion: area of a surface that is covered by all
1960 * visible regions above it (which includes the translucent areas).
1961 */
1962 Region coveredRegion;
1963
1964 /*
1965 * transparentRegion: area of a surface that is hinted to be completely
1966 * transparent. This is only used to tell when the layer has no visible
1967 * non-transparent regions and can be removed from the layer list. It
1968 * does not affect the visibleRegion of this layer or any layers
1969 * beneath it. The hint may not be correct if apps don't respect the
1970 * SurfaceView restrictions (which, sadly, some don't).
1971 */
1972 Region transparentRegion;
1973
1974
1975 // handle hidden surfaces by setting the visible region to empty
1976 if (CC_LIKELY(layer->isVisible())) {
1977 const bool translucent = !layer->isOpaque(s);
Robert Carr1f0a16a2016-10-24 16:27:39 -07001978 Rect bounds(layer->computeScreenBounds());
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001979 visibleRegion.set(bounds);
Robert Carr1f0a16a2016-10-24 16:27:39 -07001980 Transform tr = layer->getTransform();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001981 if (!visibleRegion.isEmpty()) {
1982 // Remove the transparent area from the visible region
1983 if (translucent) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001984 if (tr.preserveRects()) {
1985 // transform the transparent region
1986 transparentRegion = tr.transform(s.activeTransparentRegion);
1987 } else {
1988 // transformation too complex, can't do the
1989 // transparent region optimization.
1990 transparentRegion.clear();
1991 }
1992 }
1993
1994 // compute the opaque region
Robert Carr1f0a16a2016-10-24 16:27:39 -07001995 const int32_t layerOrientation = tr.getOrientation();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001996 if (s.alpha==255 && !translucent &&
1997 ((layerOrientation & Transform::ROT_INVALID) == false)) {
1998 // the opaque region is the layer's footprint
1999 opaqueRegion = visibleRegion;
2000 }
2001 }
2002 }
2003
2004 // Clip the covered region to the visible region
2005 coveredRegion = aboveCoveredLayers.intersect(visibleRegion);
2006
2007 // Update aboveCoveredLayers for next (lower) layer
2008 aboveCoveredLayers.orSelf(visibleRegion);
2009
2010 // subtract the opaque region covered by the layers above us
2011 visibleRegion.subtractSelf(aboveOpaqueLayers);
2012
2013 // compute this layer's dirty region
2014 if (layer->contentDirty) {
2015 // we need to invalidate the whole region
2016 dirty = visibleRegion;
2017 // as well, as the old visible region
2018 dirty.orSelf(layer->visibleRegion);
2019 layer->contentDirty = false;
2020 } else {
2021 /* compute the exposed region:
2022 * the exposed region consists of two components:
2023 * 1) what's VISIBLE now and was COVERED before
2024 * 2) what's EXPOSED now less what was EXPOSED before
2025 *
2026 * note that (1) is conservative, we start with the whole
2027 * visible region but only keep what used to be covered by
2028 * something -- which mean it may have been exposed.
2029 *
2030 * (2) handles areas that were not covered by anything but got
2031 * exposed because of a resize.
2032 */
2033 const Region newExposed = visibleRegion - coveredRegion;
2034 const Region oldVisibleRegion = layer->visibleRegion;
2035 const Region oldCoveredRegion = layer->coveredRegion;
2036 const Region oldExposed = oldVisibleRegion - oldCoveredRegion;
2037 dirty = (visibleRegion&oldCoveredRegion) | (newExposed-oldExposed);
2038 }
2039 dirty.subtractSelf(aboveOpaqueLayers);
2040
2041 // accumulate to the screen dirty region
2042 outDirtyRegion.orSelf(dirty);
2043
2044 // Update aboveOpaqueLayers for next (lower) layer
2045 aboveOpaqueLayers.orSelf(opaqueRegion);
2046
2047 // Store the visible region in screen space
2048 layer->setVisibleRegion(visibleRegion);
2049 layer->setCoveredRegion(coveredRegion);
2050 layer->setVisibleNonTransparentRegion(
2051 visibleRegion.subtract(transparentRegion));
Robert Carr2047fae2016-11-28 14:09:09 -08002052 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002053
2054 outOpaqueRegion = aboveOpaqueLayers;
2055}
2056
2057void SurfaceFlinger::invalidateLayerStack(uint32_t layerStack,
2058 const Region& dirty) {
2059 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
2060 const sp<DisplayDevice>& hw(mDisplays[dpy]);
2061 if (hw->getLayerStack() == layerStack) {
2062 hw->dirtyRegion.orSelf(dirty);
2063 }
2064 }
2065}
2066
2067bool SurfaceFlinger::handlePageFlip()
2068{
Brian Andersond6927fb2016-07-23 23:37:30 -07002069 nsecs_t latchTime = systemTime();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002070 Region dirtyRegion;
2071
2072 bool visibleRegions = false;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002073 bool frameQueued = false;
2074
2075 // Store the set of layers that need updates. This set must not change as
2076 // buffers are being latched, as this could result in a deadlock.
2077 // Example: Two producers share the same command stream and:
2078 // 1.) Layer 0 is latched
2079 // 2.) Layer 0 gets a new frame
2080 // 2.) Layer 1 gets a new frame
2081 // 3.) Layer 1 is latched.
2082 // Display is now waiting on Layer 1's frame, which is behind layer 0's
2083 // second frame. But layer 0's second frame could be waiting on display.
2084 Vector<Layer*> layersWithQueuedFrames;
Robert Carr2047fae2016-11-28 14:09:09 -08002085 mDrawingState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002086 if (layer->hasQueuedFrame()) {
2087 frameQueued = true;
2088 if (layer->shouldPresentNow(mPrimaryDispSync)) {
Robert Carr2047fae2016-11-28 14:09:09 -08002089 layersWithQueuedFrames.push_back(layer);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002090 } else {
2091 layer->useEmptyDamage();
2092 }
2093 } else {
2094 layer->useEmptyDamage();
2095 }
Robert Carr2047fae2016-11-28 14:09:09 -08002096 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002097 for (size_t i = 0, count = layersWithQueuedFrames.size() ; i<count ; i++) {
2098 Layer* layer = layersWithQueuedFrames[i];
Brian Andersond6927fb2016-07-23 23:37:30 -07002099 const Region dirty(layer->latchBuffer(visibleRegions, latchTime));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002100 layer->useSurfaceDamage();
Robert Carr1f0a16a2016-10-24 16:27:39 -07002101 invalidateLayerStack(layer->getLayerStack(), dirty);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002102 }
2103
2104 mVisibleRegionsDirty |= visibleRegions;
2105
2106 // If we will need to wake up at some time in the future to deal with a
2107 // queued frame that shouldn't be displayed during this vsync period, wake
2108 // up during the next vsync period to check again.
2109 if (frameQueued && layersWithQueuedFrames.empty()) {
2110 signalLayerUpdate();
2111 }
2112
2113 // Only continue with the refresh if there is actually new work to do
2114 return !layersWithQueuedFrames.empty();
2115}
2116
2117void SurfaceFlinger::invalidateHwcGeometry()
2118{
2119 mHwWorkListDirty = true;
2120}
2121
2122
2123void SurfaceFlinger::doDisplayComposition(const sp<const DisplayDevice>& hw,
2124 const Region& inDirtyRegion)
2125{
2126 // We only need to actually compose the display if:
2127 // 1) It is being handled by hardware composer, which may need this to
2128 // keep its virtual display state machine in sync, or
2129 // 2) There is work to be done (the dirty region isn't empty)
2130 bool isHwcDisplay = hw->getHwcDisplayId() >= 0;
2131 if (!isHwcDisplay && inDirtyRegion.isEmpty()) {
2132 return;
2133 }
2134
2135 Region dirtyRegion(inDirtyRegion);
2136
2137 // compute the invalid region
2138 hw->swapRegion.orSelf(dirtyRegion);
2139
2140 uint32_t flags = hw->getFlags();
2141 if (flags & DisplayDevice::SWAP_RECTANGLE) {
2142 // we can redraw only what's dirty, but since SWAP_RECTANGLE only
2143 // takes a rectangle, we must make sure to update that whole
2144 // rectangle in that case
2145 dirtyRegion.set(hw->swapRegion.bounds());
2146 } else {
2147 if (flags & DisplayDevice::PARTIAL_UPDATES) {
2148 // We need to redraw the rectangle that will be updated
2149 // (pushed to the framebuffer).
2150 // This is needed because PARTIAL_UPDATES only takes one
2151 // rectangle instead of a region (see DisplayDevice::flip())
2152 dirtyRegion.set(hw->swapRegion.bounds());
2153 } else {
2154 // we need to redraw everything (the whole screen)
2155 dirtyRegion.set(hw->bounds());
2156 hw->swapRegion = dirtyRegion;
2157 }
2158 }
2159
2160 if (CC_LIKELY(!mDaltonize && !mHasColorMatrix)) {
2161 if (!doComposeSurfaces(hw, dirtyRegion)) return;
2162 } else {
2163 RenderEngine& engine(getRenderEngine());
2164 mat4 colorMatrix = mColorMatrix;
2165 if (mDaltonize) {
2166 colorMatrix = colorMatrix * mDaltonizer();
2167 }
2168 mat4 oldMatrix = engine.setupColorTransform(colorMatrix);
2169 doComposeSurfaces(hw, dirtyRegion);
2170 engine.setupColorTransform(oldMatrix);
2171 }
2172
2173 // update the swap region and clear the dirty region
2174 hw->swapRegion.orSelf(dirtyRegion);
2175
2176 // swap buffers (presentation)
2177 hw->swapBuffers(getHwComposer());
2178}
2179
2180bool SurfaceFlinger::doComposeSurfaces(const sp<const DisplayDevice>& hw, const Region& dirty)
2181{
2182 RenderEngine& engine(getRenderEngine());
2183 const int32_t id = hw->getHwcDisplayId();
2184 HWComposer& hwc(getHwComposer());
2185 HWComposer::LayerListIterator cur = hwc.begin(id);
2186 const HWComposer::LayerListIterator end = hwc.end(id);
2187
2188 bool hasGlesComposition = hwc.hasGlesComposition(id);
2189 if (hasGlesComposition) {
2190 if (!hw->makeCurrent(mEGLDisplay, mEGLContext)) {
2191 ALOGW("DisplayDevice::makeCurrent failed. Aborting surface composition for display %s",
2192 hw->getDisplayName().string());
2193 eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
2194 if(!getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext)) {
2195 ALOGE("DisplayDevice::makeCurrent on default display failed. Aborting.");
2196 }
2197 return false;
2198 }
2199
2200 // Never touch the framebuffer if we don't have any framebuffer layers
2201 const bool hasHwcComposition = hwc.hasHwcComposition(id);
2202 if (hasHwcComposition) {
2203 // when using overlays, we assume a fully transparent framebuffer
2204 // NOTE: we could reduce how much we need to clear, for instance
2205 // remove where there are opaque FB layers. however, on some
2206 // GPUs doing a "clean slate" clear might be more efficient.
2207 // We'll revisit later if needed.
2208 engine.clearWithColor(0, 0, 0, 0);
2209 } else {
2210 // we start with the whole screen area
2211 const Region bounds(hw->getBounds());
2212
2213 // we remove the scissor part
2214 // we're left with the letterbox region
2215 // (common case is that letterbox ends-up being empty)
2216 const Region letterbox(bounds.subtract(hw->getScissor()));
2217
2218 // compute the area to clear
2219 Region region(hw->undefinedRegion.merge(letterbox));
2220
2221 // but limit it to the dirty region
2222 region.andSelf(dirty);
2223
2224 // screen is already cleared here
2225 if (!region.isEmpty()) {
2226 // can happen with SurfaceView
2227 drawWormhole(hw, region);
2228 }
2229 }
2230
2231 if (hw->getDisplayType() != DisplayDevice::DISPLAY_PRIMARY) {
2232 // just to be on the safe side, we don't set the
2233 // scissor on the main display. It should never be needed
2234 // anyways (though in theory it could since the API allows it).
2235 const Rect& bounds(hw->getBounds());
2236 const Rect& scissor(hw->getScissor());
2237 if (scissor != bounds) {
2238 // scissor doesn't match the screen's dimensions, so we
2239 // need to clear everything outside of it and enable
2240 // the GL scissor so we don't draw anything where we shouldn't
2241
2242 // enable scissor for this frame
2243 const uint32_t height = hw->getHeight();
2244 engine.setScissor(scissor.left, height - scissor.bottom,
2245 scissor.getWidth(), scissor.getHeight());
2246 }
2247 }
2248 }
2249
2250 /*
2251 * and then, render the layers targeted at the framebuffer
2252 */
2253
2254 const Vector< sp<Layer> >& layers(hw->getVisibleLayersSortedByZ());
2255 const size_t count = layers.size();
2256 const Transform& tr = hw->getTransform();
2257 if (cur != end) {
2258 // we're using h/w composer
2259 for (size_t i=0 ; i<count && cur!=end ; ++i, ++cur) {
2260 const sp<Layer>& layer(layers[i]);
2261 const Region clip(dirty.intersect(tr.transform(layer->visibleRegion)));
2262 if (!clip.isEmpty()) {
2263 switch (cur->getCompositionType()) {
2264 case HWC_CURSOR_OVERLAY:
2265 case HWC_OVERLAY: {
2266 const Layer::State& state(layer->getDrawingState());
2267 if ((cur->getHints() & HWC_HINT_CLEAR_FB)
2268 && i
2269 && layer->isOpaque(state) && (state.alpha == 0xFF)
2270 && hasGlesComposition) {
2271 // never clear the very first layer since we're
2272 // guaranteed the FB is already cleared
Fabien Sanglard17487192016-12-07 13:03:32 -08002273 layer->clearWithOpenGL(hw);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002274 }
2275 break;
2276 }
2277 case HWC_FRAMEBUFFER: {
2278 layer->draw(hw, clip);
2279 break;
2280 }
2281 case HWC_FRAMEBUFFER_TARGET: {
2282 // this should not happen as the iterator shouldn't
2283 // let us get there.
2284 ALOGW("HWC_FRAMEBUFFER_TARGET found in hwc list (index=%zu)", i);
2285 break;
2286 }
2287 }
2288 }
2289 layer->setAcquireFence(hw, *cur);
2290 }
2291 } else {
2292 // we're not using h/w composer
2293 for (size_t i=0 ; i<count ; ++i) {
2294 const sp<Layer>& layer(layers[i]);
2295 const Region clip(dirty.intersect(
2296 tr.transform(layer->visibleRegion)));
2297 if (!clip.isEmpty()) {
2298 layer->draw(hw, clip);
2299 }
2300 }
2301 }
2302
2303 // disable scissor at the end of the frame
2304 engine.disableScissor();
2305 return true;
2306}
2307
2308void SurfaceFlinger::drawWormhole(const sp<const DisplayDevice>& hw, const Region& region) const {
2309 const int32_t height = hw->getHeight();
2310 RenderEngine& engine(getRenderEngine());
2311 engine.fillRegionWithColor(region, height, 0, 0, 0, 0);
2312}
2313
2314status_t SurfaceFlinger::addClientLayer(const sp<Client>& client,
2315 const sp<IBinder>& handle,
2316 const sp<IGraphicBufferProducer>& gbc,
Robert Carr1f0a16a2016-10-24 16:27:39 -07002317 const sp<Layer>& lbc,
2318 const sp<Layer>& parent)
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002319{
2320 // add this layer to the current state list
2321 {
2322 Mutex::Autolock _l(mStateLock);
Robert Carr1f0a16a2016-10-24 16:27:39 -07002323 if (mNumLayers >= MAX_LAYERS) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002324 return NO_MEMORY;
2325 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07002326 if (parent == nullptr) {
2327 mCurrentState.layersSortedByZ.add(lbc);
2328 } else {
2329 parent->addChild(lbc);
2330 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002331 mGraphicBufferProducerList.add(IInterface::asBinder(gbc));
Robert Carr1f0a16a2016-10-24 16:27:39 -07002332 mLayersAdded = true;
2333 mNumLayers++;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002334 }
2335
2336 // attach this layer to the client
2337 client->attachLayer(handle, lbc);
2338
2339 return NO_ERROR;
2340}
2341
Chia-I Wu515dc9c2017-06-15 12:53:59 -07002342status_t SurfaceFlinger::removeLayer(const sp<Layer>& layer, bool topLevelOnly) {
Robert Carr7f9b8992017-03-10 11:08:39 -08002343 Mutex::Autolock _l(mStateLock);
2344
Robert Carr1f0a16a2016-10-24 16:27:39 -07002345 const auto& p = layer->getParent();
Chia-I Wu515dc9c2017-06-15 12:53:59 -07002346 ssize_t index;
2347 if (p != nullptr) {
2348 if (topLevelOnly) {
2349 return NO_ERROR;
2350 }
2351
2352 index = p->removeChild(layer);
2353 } else {
2354 index = mCurrentState.layersSortedByZ.remove(layer);
2355 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07002356
Robert Carr136e2f62017-02-08 17:54:29 -08002357 // As a matter of normal operation, the LayerCleaner will produce a second
2358 // attempt to remove the surface. The Layer will be kept alive in mDrawingState
2359 // so we will succeed in promoting it, but it's already been removed
2360 // from mCurrentState. As long as we can find it in mDrawingState we have no problem
2361 // otherwise something has gone wrong and we are leaking the layer.
2362 if (index < 0 && mDrawingState.layersSortedByZ.indexOf(layer) < 0) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07002363 ALOGE("Failed to find layer (%s) in layer parent (%s).",
2364 layer->getName().string(),
2365 (p != nullptr) ? p->getName().string() : "no-parent");
2366 return BAD_VALUE;
Robert Carr136e2f62017-02-08 17:54:29 -08002367 } else if (index < 0) {
2368 return NO_ERROR;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002369 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07002370
2371 mLayersPendingRemoval.add(layer);
2372 mLayersRemoved = true;
2373 mNumLayers--;
2374 setTransactionFlags(eTransactionNeeded);
2375 return NO_ERROR;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002376}
2377
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08002378uint32_t SurfaceFlinger::peekTransactionFlags() {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002379 return android_atomic_release_load(&mTransactionFlags);
2380}
2381
2382uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) {
2383 return android_atomic_and(~flags, &mTransactionFlags) & flags;
2384}
2385
2386uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) {
2387 uint32_t old = android_atomic_or(flags, &mTransactionFlags);
2388 if ((old & flags)==0) { // wake the server up
2389 signalTransaction();
2390 }
2391 return old;
2392}
2393
2394void SurfaceFlinger::setTransactionState(
2395 const Vector<ComposerState>& state,
2396 const Vector<DisplayState>& displays,
2397 uint32_t flags)
2398{
2399 ATRACE_CALL();
2400 Mutex::Autolock _l(mStateLock);
2401 uint32_t transactionFlags = 0;
2402
2403 if (flags & eAnimation) {
2404 // For window updates that are part of an animation we must wait for
2405 // previous animation "frames" to be handled.
2406 while (mAnimTransactionPending) {
2407 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
2408 if (CC_UNLIKELY(err != NO_ERROR)) {
2409 // just in case something goes wrong in SF, return to the
2410 // caller after a few seconds.
2411 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out "
2412 "waiting for previous animation frame");
2413 mAnimTransactionPending = false;
2414 break;
2415 }
2416 }
2417 }
2418
2419 size_t count = displays.size();
2420 for (size_t i=0 ; i<count ; i++) {
2421 const DisplayState& s(displays[i]);
2422 transactionFlags |= setDisplayStateLocked(s);
2423 }
2424
2425 count = state.size();
2426 for (size_t i=0 ; i<count ; i++) {
2427 const ComposerState& s(state[i]);
2428 // Here we need to check that the interface we're given is indeed
2429 // one of our own. A malicious client could give us a NULL
2430 // IInterface, or one of its own or even one of our own but a
2431 // different type. All these situations would cause us to crash.
2432 //
2433 // NOTE: it would be better to use RTTI as we could directly check
2434 // that we have a Client*. however, RTTI is disabled in Android.
2435 if (s.client != NULL) {
2436 sp<IBinder> binder = IInterface::asBinder(s.client);
2437 if (binder != NULL) {
Fabien Sanglard45b20252017-01-18 16:43:18 -08002438 if (binder->queryLocalInterface(ISurfaceComposerClient::descriptor) != NULL) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002439 sp<Client> client( static_cast<Client *>(s.client.get()) );
2440 transactionFlags |= setClientStateLocked(client, s.state);
2441 }
2442 }
2443 }
2444 }
2445
2446 // If a synchronous transaction is explicitly requested without any changes,
2447 // force a transaction anyway. This can be used as a flush mechanism for
2448 // previous async transactions.
2449 if (transactionFlags == 0 && (flags & eSynchronous)) {
2450 transactionFlags = eTransactionNeeded;
2451 }
2452
2453 if (transactionFlags) {
2454 if (mInterceptor.isEnabled()) {
2455 mInterceptor.saveTransaction(state, mCurrentState.displays, displays, flags);
2456 }
2457
2458 // this triggers the transaction
2459 setTransactionFlags(transactionFlags);
2460
2461 // if this is a synchronous transaction, wait for it to take effect
2462 // before returning.
2463 if (flags & eSynchronous) {
2464 mTransactionPending = true;
2465 }
2466 if (flags & eAnimation) {
2467 mAnimTransactionPending = true;
2468 }
2469 while (mTransactionPending) {
2470 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
2471 if (CC_UNLIKELY(err != NO_ERROR)) {
2472 // just in case something goes wrong in SF, return to the
2473 // called after a few seconds.
2474 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");
2475 mTransactionPending = false;
2476 break;
2477 }
2478 }
2479 }
2480}
2481
2482uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s)
2483{
2484 ssize_t dpyIdx = mCurrentState.displays.indexOfKey(s.token);
2485 if (dpyIdx < 0)
2486 return 0;
2487
2488 uint32_t flags = 0;
2489 DisplayDeviceState& disp(mCurrentState.displays.editValueAt(dpyIdx));
2490 if (disp.isValid()) {
2491 const uint32_t what = s.what;
2492 if (what & DisplayState::eSurfaceChanged) {
2493 if (IInterface::asBinder(disp.surface) != IInterface::asBinder(s.surface)) {
2494 disp.surface = s.surface;
2495 flags |= eDisplayTransactionNeeded;
2496 }
2497 }
2498 if (what & DisplayState::eLayerStackChanged) {
2499 if (disp.layerStack != s.layerStack) {
2500 disp.layerStack = s.layerStack;
2501 flags |= eDisplayTransactionNeeded;
2502 }
2503 }
2504 if (what & DisplayState::eDisplayProjectionChanged) {
2505 if (disp.orientation != s.orientation) {
2506 disp.orientation = s.orientation;
2507 flags |= eDisplayTransactionNeeded;
2508 }
2509 if (disp.frame != s.frame) {
2510 disp.frame = s.frame;
2511 flags |= eDisplayTransactionNeeded;
2512 }
2513 if (disp.viewport != s.viewport) {
2514 disp.viewport = s.viewport;
2515 flags |= eDisplayTransactionNeeded;
2516 }
2517 }
2518 if (what & DisplayState::eDisplaySizeChanged) {
2519 if (disp.width != s.width) {
2520 disp.width = s.width;
2521 flags |= eDisplayTransactionNeeded;
2522 }
2523 if (disp.height != s.height) {
2524 disp.height = s.height;
2525 flags |= eDisplayTransactionNeeded;
2526 }
2527 }
2528 }
2529 return flags;
2530}
2531
2532uint32_t SurfaceFlinger::setClientStateLocked(
2533 const sp<Client>& client,
2534 const layer_state_t& s)
2535{
2536 uint32_t flags = 0;
2537 sp<Layer> layer(client->getLayerUser(s.surface));
2538 if (layer != 0) {
2539 const uint32_t what = s.what;
2540 bool geometryAppliesWithResize =
2541 what & layer_state_t::eGeometryAppliesWithResize;
2542 if (what & layer_state_t::ePositionChanged) {
2543 if (layer->setPosition(s.x, s.y, !geometryAppliesWithResize)) {
2544 flags |= eTraversalNeeded;
2545 }
2546 }
2547 if (what & layer_state_t::eLayerChanged) {
2548 // NOTE: index needs to be calculated before we update the state
Robert Carr1f0a16a2016-10-24 16:27:39 -07002549 const auto& p = layer->getParent();
2550 if (p == nullptr) {
2551 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
2552 if (layer->setLayer(s.z) && idx >= 0) {
2553 mCurrentState.layersSortedByZ.removeAt(idx);
2554 mCurrentState.layersSortedByZ.add(layer);
2555 // we need traversal (state changed)
2556 // AND transaction (list changed)
2557 flags |= eTransactionNeeded|eTraversalNeeded;
2558 }
2559 } else {
2560 if (p->setChildLayer(layer, s.z)) {
2561 flags |= eTransactionNeeded|eTraversalNeeded;
2562 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002563 }
2564 }
2565 if (what & layer_state_t::eSizeChanged) {
2566 if (layer->setSize(s.w, s.h)) {
2567 flags |= eTraversalNeeded;
2568 }
2569 }
2570 if (what & layer_state_t::eAlphaChanged) {
2571 if (layer->setAlpha(uint8_t(255.0f*s.alpha+0.5f)))
2572 flags |= eTraversalNeeded;
2573 }
2574 if (what & layer_state_t::eMatrixChanged) {
2575 if (layer->setMatrix(s.matrix))
2576 flags |= eTraversalNeeded;
2577 }
2578 if (what & layer_state_t::eTransparentRegionChanged) {
2579 if (layer->setTransparentRegionHint(s.transparentRegion))
2580 flags |= eTraversalNeeded;
2581 }
2582 if (what & layer_state_t::eFlagsChanged) {
2583 if (layer->setFlags(s.flags, s.mask))
2584 flags |= eTraversalNeeded;
2585 }
2586 if (what & layer_state_t::eCropChanged) {
2587 if (layer->setCrop(s.crop, !geometryAppliesWithResize))
2588 flags |= eTraversalNeeded;
2589 }
2590 if (what & layer_state_t::eFinalCropChanged) {
Robert Carr6fb9ca72017-03-22 18:23:23 -07002591 if (layer->setFinalCrop(s.finalCrop, !geometryAppliesWithResize))
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002592 flags |= eTraversalNeeded;
2593 }
2594 if (what & layer_state_t::eLayerStackChanged) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002595 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
Robert Carr1f0a16a2016-10-24 16:27:39 -07002596 // We only allow setting layer stacks for top level layers,
2597 // everything else inherits layer stack from its parent.
2598 if (layer->hasParent()) {
2599 ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
2600 layer->getName().string());
2601 } else if (idx < 0) {
2602 ALOGE("Attempt to set layer stack on layer without parent (%s) that "
2603 "that also does not appear in the top level layer list. Something"
2604 " has gone wrong.", layer->getName().string());
2605 } else if (layer->setLayerStack(s.layerStack)) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002606 mCurrentState.layersSortedByZ.removeAt(idx);
2607 mCurrentState.layersSortedByZ.add(layer);
2608 // we need traversal (state changed)
2609 // AND transaction (list changed)
2610 flags |= eTransactionNeeded|eTraversalNeeded;
2611 }
2612 }
2613 if (what & layer_state_t::eDeferTransaction) {
Robert Carr0d480722017-01-10 16:42:54 -08002614 if (s.barrierHandle != nullptr) {
2615 layer->deferTransactionUntil(s.barrierHandle, s.frameNumber);
2616 } else if (s.barrierGbp != nullptr) {
2617 const sp<IGraphicBufferProducer>& gbp = s.barrierGbp;
2618 if (authenticateSurfaceTextureLocked(gbp)) {
2619 const auto& otherLayer =
2620 (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
2621 layer->deferTransactionUntil(otherLayer, s.frameNumber);
2622 } else {
2623 ALOGE("Attempt to defer transaction to to an"
2624 " unrecognized GraphicBufferProducer");
2625 }
2626 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002627 // We don't trigger a traversal here because if no other state is
2628 // changed, we don't want this to cause any more work
2629 }
Robert Carr1db73f62016-12-21 12:58:51 -08002630 if (what & layer_state_t::eReparentChildren) {
2631 if (layer->reparentChildren(s.reparentHandle)) {
2632 flags |= eTransactionNeeded|eTraversalNeeded;
2633 }
2634 }
Robert Carr9524cb32017-02-13 11:32:32 -08002635 if (what & layer_state_t::eDetachChildren) {
2636 layer->detachChildren();
2637 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002638 if (what & layer_state_t::eOverrideScalingModeChanged) {
2639 layer->setOverrideScalingMode(s.overrideScalingMode);
2640 // We don't trigger a traversal here because if no other state is
2641 // changed, we don't want this to cause any more work
2642 }
2643 }
2644 return flags;
2645}
2646
2647status_t SurfaceFlinger::createLayer(
2648 const String8& name,
2649 const sp<Client>& client,
2650 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
Albert Chaulk479c60c2017-01-27 14:21:34 -05002651 uint32_t windowType, uint32_t ownerUid, sp<IBinder>* handle,
2652 sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent)
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002653{
2654 if (int32_t(w|h) < 0) {
2655 ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
2656 int(w), int(h));
2657 return BAD_VALUE;
2658 }
2659
2660 status_t result = NO_ERROR;
2661
2662 sp<Layer> layer;
2663
Cody Northropbc755282017-03-31 12:00:08 -06002664 String8 uniqueName = getUniqueLayerName(name);
2665
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002666 switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
2667 case ISurfaceComposerClient::eFXSurfaceNormal:
2668 result = createNormalLayer(client,
Cody Northropbc755282017-03-31 12:00:08 -06002669 uniqueName, w, h, flags, format,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002670 handle, gbp, &layer);
2671 break;
2672 case ISurfaceComposerClient::eFXSurfaceDim:
2673 result = createDimLayer(client,
Cody Northropbc755282017-03-31 12:00:08 -06002674 uniqueName, w, h, flags,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002675 handle, gbp, &layer);
2676 break;
2677 default:
2678 result = BAD_VALUE;
2679 break;
2680 }
2681
2682 if (result != NO_ERROR) {
2683 return result;
2684 }
2685
Albert Chaulk479c60c2017-01-27 14:21:34 -05002686 layer->setInfo(windowType, ownerUid);
2687
Robert Carr1f0a16a2016-10-24 16:27:39 -07002688 result = addClientLayer(client, *handle, *gbp, layer, *parent);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002689 if (result != NO_ERROR) {
2690 return result;
2691 }
2692 mInterceptor.saveSurfaceCreation(layer);
2693
2694 setTransactionFlags(eTransactionNeeded);
2695 return result;
2696}
2697
Cody Northropbc755282017-03-31 12:00:08 -06002698String8 SurfaceFlinger::getUniqueLayerName(const String8& name)
2699{
2700 bool matchFound = true;
2701 uint32_t dupeCounter = 0;
2702
2703 // Tack on our counter whether there is a hit or not, so everyone gets a tag
2704 String8 uniqueName = name + "#" + String8(std::to_string(dupeCounter).c_str());
2705
2706 // Loop over layers until we're sure there is no matching name
2707 while (matchFound) {
2708 matchFound = false;
2709 mDrawingState.traverseInZOrder([&](Layer* layer) {
2710 if (layer->getName() == uniqueName) {
2711 matchFound = true;
2712 uniqueName = name + "#" + String8(std::to_string(++dupeCounter).c_str());
2713 }
2714 });
2715 }
2716
2717 ALOGD_IF(dupeCounter > 0, "duplicate layer name: changing %s to %s", name.c_str(), uniqueName.c_str());
2718
2719 return uniqueName;
2720}
2721
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002722status_t SurfaceFlinger::createNormalLayer(const sp<Client>& client,
2723 const String8& name, uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
2724 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
2725{
2726 // initialize the surfaces
2727 switch (format) {
2728 case PIXEL_FORMAT_TRANSPARENT:
2729 case PIXEL_FORMAT_TRANSLUCENT:
2730 format = PIXEL_FORMAT_RGBA_8888;
2731 break;
2732 case PIXEL_FORMAT_OPAQUE:
2733 format = PIXEL_FORMAT_RGBX_8888;
2734 break;
2735 }
2736
2737 *outLayer = new Layer(this, client, name, w, h, flags);
2738 status_t err = (*outLayer)->setBuffers(w, h, format, flags);
2739 if (err == NO_ERROR) {
2740 *handle = (*outLayer)->getHandle();
2741 *gbp = (*outLayer)->getProducer();
2742 }
2743
2744 ALOGE_IF(err, "createNormalLayer() failed (%s)", strerror(-err));
2745 return err;
2746}
2747
2748status_t SurfaceFlinger::createDimLayer(const sp<Client>& client,
2749 const String8& name, uint32_t w, uint32_t h, uint32_t flags,
2750 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
2751{
2752 *outLayer = new LayerDim(this, client, name, w, h, flags);
2753 *handle = (*outLayer)->getHandle();
2754 *gbp = (*outLayer)->getProducer();
2755 return NO_ERROR;
2756}
2757
2758status_t SurfaceFlinger::onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle)
2759{
Robert Carr9524cb32017-02-13 11:32:32 -08002760 // called by a client when it wants to remove a Layer
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002761 status_t err = NO_ERROR;
2762 sp<Layer> l(client->getLayerUser(handle));
2763 if (l != NULL) {
2764 mInterceptor.saveSurfaceDeletion(l);
2765 err = removeLayer(l);
2766 ALOGE_IF(err<0 && err != NAME_NOT_FOUND,
2767 "error removing layer=%p (%s)", l.get(), strerror(-err));
2768 }
2769 return err;
2770}
2771
2772status_t SurfaceFlinger::onLayerDestroyed(const wp<Layer>& layer)
2773{
2774 // called by ~LayerCleaner() when all references to the IBinder (handle)
2775 // are gone
Robert Carr9524cb32017-02-13 11:32:32 -08002776 sp<Layer> l = layer.promote();
2777 if (l == nullptr) {
2778 // The layer has already been removed, carry on
2779 return NO_ERROR;
Robert Carr9524cb32017-02-13 11:32:32 -08002780 }
Chia-I Wu515dc9c2017-06-15 12:53:59 -07002781 // If we have a parent, then we can continue to live as long as it does.
2782 return removeLayer(l, true);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002783}
2784
2785// ---------------------------------------------------------------------------
2786
2787void SurfaceFlinger::onInitializeDisplays() {
2788 // reset screen orientation and use primary layer stack
2789 Vector<ComposerState> state;
2790 Vector<DisplayState> displays;
2791 DisplayState d;
2792 d.what = DisplayState::eDisplayProjectionChanged |
2793 DisplayState::eLayerStackChanged;
2794 d.token = mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY];
2795 d.layerStack = 0;
2796 d.orientation = DisplayState::eOrientationDefault;
2797 d.frame.makeInvalid();
2798 d.viewport.makeInvalid();
2799 d.width = 0;
2800 d.height = 0;
2801 displays.add(d);
2802 setTransactionState(state, displays, 0);
2803 setPowerModeInternal(getDisplayDevice(d.token), HWC_POWER_MODE_NORMAL);
2804
2805 const nsecs_t period =
2806 getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
2807 mAnimFrameTracker.setDisplayRefreshPeriod(period);
Brian Andersond0010582017-03-07 13:20:31 -08002808
2809 // Use phase of 0 since phase is not known.
2810 // Use latency of 0, which will snap to the ideal latency.
2811 setCompositorTimingSnapped(0, period, 0);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002812}
2813
2814void SurfaceFlinger::initializeDisplays() {
2815 class MessageScreenInitialized : public MessageBase {
2816 SurfaceFlinger* flinger;
2817 public:
2818 explicit MessageScreenInitialized(SurfaceFlinger* flinger) : flinger(flinger) { }
2819 virtual bool handler() {
2820 flinger->onInitializeDisplays();
2821 return true;
2822 }
2823 };
2824 sp<MessageBase> msg = new MessageScreenInitialized(this);
2825 postMessageAsync(msg); // we may be called from main thread, use async message
2826}
2827
2828void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& hw,
2829 int mode) {
2830 ALOGD("Set power mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(),
2831 this);
2832 int32_t type = hw->getDisplayType();
2833 int currentMode = hw->getPowerMode();
2834
2835 if (mode == currentMode) {
2836 ALOGD("Screen type=%d is already mode=%d", hw->getDisplayType(), mode);
2837 return;
2838 }
2839
2840 hw->setPowerMode(mode);
2841 if (type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
2842 ALOGW("Trying to set power mode for virtual display");
2843 return;
2844 }
2845
2846 if (mInterceptor.isEnabled()) {
2847 Mutex::Autolock _l(mStateLock);
2848 ssize_t idx = mCurrentState.displays.indexOfKey(hw->getDisplayToken());
2849 if (idx < 0) {
2850 ALOGW("Surface Interceptor SavePowerMode: invalid display token");
2851 return;
2852 }
2853 mInterceptor.savePowerModeUpdate(mCurrentState.displays.valueAt(idx).displayId, mode);
2854 }
2855
2856 if (currentMode == HWC_POWER_MODE_OFF) {
2857 // Turn on the display
2858 getHwComposer().setPowerMode(type, mode);
2859 if (type == DisplayDevice::DISPLAY_PRIMARY) {
2860 // FIXME: eventthread only knows about the main display right now
2861 mEventThread->onScreenAcquired();
2862 resyncToHardwareVsync(true);
2863 }
2864
2865 mVisibleRegionsDirty = true;
2866 mHasPoweredOff = true;
2867 repaintEverything();
2868
2869 struct sched_param param = {0};
2870 param.sched_priority = 1;
2871 if (sched_setscheduler(0, SCHED_FIFO, &param) != 0) {
2872 ALOGW("Couldn't set SCHED_FIFO on display on");
2873 }
2874 } else if (mode == HWC_POWER_MODE_OFF) {
2875 // Turn off the display
2876 struct sched_param param = {0};
2877 if (sched_setscheduler(0, SCHED_OTHER, &param) != 0) {
2878 ALOGW("Couldn't set SCHED_OTHER on display off");
2879 }
2880
2881 if (type == DisplayDevice::DISPLAY_PRIMARY) {
2882 disableHardwareVsync(true); // also cancels any in-progress resync
2883
2884 // FIXME: eventthread only knows about the main display right now
2885 mEventThread->onScreenReleased();
2886 }
2887
2888 getHwComposer().setPowerMode(type, mode);
2889 mVisibleRegionsDirty = true;
2890 // from this point on, SF will stop drawing on this display
2891 } else {
2892 getHwComposer().setPowerMode(type, mode);
2893 }
2894}
2895
2896void SurfaceFlinger::setPowerMode(const sp<IBinder>& display, int mode) {
2897 class MessageSetPowerMode: public MessageBase {
2898 SurfaceFlinger& mFlinger;
2899 sp<IBinder> mDisplay;
2900 int mMode;
2901 public:
2902 MessageSetPowerMode(SurfaceFlinger& flinger,
2903 const sp<IBinder>& disp, int mode) : mFlinger(flinger),
2904 mDisplay(disp) { mMode = mode; }
2905 virtual bool handler() {
2906 sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
2907 if (hw == NULL) {
2908 ALOGE("Attempt to set power mode = %d for null display %p",
2909 mMode, mDisplay.get());
2910 } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) {
2911 ALOGW("Attempt to set power mode = %d for virtual display",
2912 mMode);
2913 } else {
2914 mFlinger.setPowerModeInternal(hw, mMode);
2915 }
2916 return true;
2917 }
2918 };
2919 sp<MessageBase> msg = new MessageSetPowerMode(*this, display, mode);
2920 postMessageSync(msg);
2921}
2922
2923// ---------------------------------------------------------------------------
2924
2925status_t SurfaceFlinger::dump(int fd, const Vector<String16>& args)
2926{
2927 String8 result;
2928
2929 IPCThreadState* ipc = IPCThreadState::self();
2930 const int pid = ipc->getCallingPid();
2931 const int uid = ipc->getCallingUid();
2932 if ((uid != AID_SHELL) &&
2933 !PermissionCache::checkPermission(sDump, pid, uid)) {
2934 result.appendFormat("Permission Denial: "
2935 "can't dump SurfaceFlinger from pid=%d, uid=%d\n", pid, uid);
2936 } else {
2937 // Try to get the main lock, but give up after one second
2938 // (this would indicate SF is stuck, but we want to be able to
2939 // print something in dumpsys).
2940 status_t err = mStateLock.timedLock(s2ns(1));
2941 bool locked = (err == NO_ERROR);
2942 if (!locked) {
2943 result.appendFormat(
2944 "SurfaceFlinger appears to be unresponsive (%s [%d]), "
2945 "dumping anyways (no locks held)\n", strerror(-err), err);
2946 }
2947
2948 bool dumpAll = true;
2949 size_t index = 0;
2950 size_t numArgs = args.size();
2951 if (numArgs) {
2952 if ((index < numArgs) &&
2953 (args[index] == String16("--list"))) {
2954 index++;
2955 listLayersLocked(args, index, result);
2956 dumpAll = false;
2957 }
2958
2959 if ((index < numArgs) &&
2960 (args[index] == String16("--latency"))) {
2961 index++;
2962 dumpStatsLocked(args, index, result);
2963 dumpAll = false;
2964 }
2965
2966 if ((index < numArgs) &&
2967 (args[index] == String16("--latency-clear"))) {
2968 index++;
2969 clearStatsLocked(args, index, result);
2970 dumpAll = false;
2971 }
2972
2973 if ((index < numArgs) &&
2974 (args[index] == String16("--dispsync"))) {
2975 index++;
2976 mPrimaryDispSync.dump(result);
2977 dumpAll = false;
2978 }
2979
2980 if ((index < numArgs) &&
2981 (args[index] == String16("--static-screen"))) {
2982 index++;
2983 dumpStaticScreenStats(result);
2984 dumpAll = false;
2985 }
2986
2987 if ((index < numArgs) &&
Brian Andersond6927fb2016-07-23 23:37:30 -07002988 (args[index] == String16("--frame-events"))) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002989 index++;
Brian Andersond6927fb2016-07-23 23:37:30 -07002990 dumpFrameEventsLocked(result);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002991 dumpAll = false;
2992 }
2993 }
2994
2995 if (dumpAll) {
2996 dumpAllLocked(args, index, result);
2997 }
2998
2999 if (locked) {
3000 mStateLock.unlock();
3001 }
3002 }
3003 write(fd, result.string(), result.size());
3004 return NO_ERROR;
3005}
3006
3007void SurfaceFlinger::listLayersLocked(const Vector<String16>& /* args */,
3008 size_t& /* index */, String8& result) const
3009{
Robert Carr2047fae2016-11-28 14:09:09 -08003010 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003011 result.appendFormat("%s\n", layer->getName().string());
Robert Carr2047fae2016-11-28 14:09:09 -08003012 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003013}
3014
3015void SurfaceFlinger::dumpStatsLocked(const Vector<String16>& args, size_t& index,
3016 String8& result) const
3017{
3018 String8 name;
3019 if (index < args.size()) {
3020 name = String8(args[index]);
3021 index++;
3022 }
3023
3024 const nsecs_t period =
3025 getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
3026 result.appendFormat("%" PRId64 "\n", period);
3027
3028 if (name.isEmpty()) {
3029 mAnimFrameTracker.dumpStats(result);
3030 } else {
Robert Carr2047fae2016-11-28 14:09:09 -08003031 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003032 if (name == layer->getName()) {
3033 layer->dumpFrameStats(result);
3034 }
Robert Carr2047fae2016-11-28 14:09:09 -08003035 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003036 }
3037}
3038
3039void SurfaceFlinger::clearStatsLocked(const Vector<String16>& args, size_t& index,
3040 String8& /* result */)
3041{
3042 String8 name;
3043 if (index < args.size()) {
3044 name = String8(args[index]);
3045 index++;
3046 }
3047
Robert Carr2047fae2016-11-28 14:09:09 -08003048 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003049 if (name.isEmpty() || (name == layer->getName())) {
3050 layer->clearFrameStats();
3051 }
Robert Carr2047fae2016-11-28 14:09:09 -08003052 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003053
3054 mAnimFrameTracker.clearStats();
3055}
3056
3057// This should only be called from the main thread. Otherwise it would need
3058// the lock and should use mCurrentState rather than mDrawingState.
3059void SurfaceFlinger::logFrameStats() {
Robert Carr2047fae2016-11-28 14:09:09 -08003060 mDrawingState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003061 layer->logFrameStats();
Robert Carr2047fae2016-11-28 14:09:09 -08003062 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003063
3064 mAnimFrameTracker.logAndResetStats(String8("<win-anim>"));
3065}
3066
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08003067void SurfaceFlinger::appendSfConfigString(String8& result) const
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003068{
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08003069 result.append(" [sf");
Fabien Sanglardc93afd52017-03-13 13:02:42 -07003070 result.appendFormat(" HAS_CONTEXT_PRIORITY=%d", useContextPriority);
3071
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08003072 if (isLayerTripleBufferingDisabled())
3073 result.append(" DISABLE_TRIPLE_BUFFERING");
Fabien Sanglarda34ed632017-03-14 11:43:52 -07003074
Fabien Sanglardc45a7d92017-03-14 13:24:22 -07003075 result.appendFormat(" PRESENT_TIME_OFFSET=%" PRId64, dispSyncPresentTimeOffset);
Fabien Sanglarda34ed632017-03-14 11:43:52 -07003076 result.appendFormat(" FORCE_HWC_FOR_RBG_TO_YUV=%d", useHwcForRgbToYuv);
Fabien Sanglardc8e387e2017-03-10 10:30:28 -08003077 result.appendFormat(" MAX_VIRT_DISPLAY_DIM=%" PRIu64, maxVirtualDisplaySize);
Fabien Sanglardcbf153b2017-03-10 17:57:12 -08003078 result.appendFormat(" RUNNING_WITHOUT_SYNC_FRAMEWORK=%d", !hasSyncFramework);
Fabien Sanglard1971b632017-03-10 14:50:03 -08003079 result.appendFormat(" NUM_FRAMEBUFFER_SURFACE_BUFFERS=%" PRId64,
3080 maxFrameBufferAcquiredBuffers);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08003081 result.append("]");
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003082}
3083
3084void SurfaceFlinger::dumpStaticScreenStats(String8& result) const
3085{
3086 result.appendFormat("Static screen stats:\n");
3087 for (size_t b = 0; b < NUM_BUCKETS - 1; ++b) {
3088 float bucketTimeSec = mFrameBuckets[b] / 1e9;
3089 float percent = 100.0f *
3090 static_cast<float>(mFrameBuckets[b]) / mTotalTime;
3091 result.appendFormat(" < %zd frames: %.3f s (%.1f%%)\n",
3092 b + 1, bucketTimeSec, percent);
3093 }
3094 float bucketTimeSec = mFrameBuckets[NUM_BUCKETS - 1] / 1e9;
3095 float percent = 100.0f *
3096 static_cast<float>(mFrameBuckets[NUM_BUCKETS - 1]) / mTotalTime;
3097 result.appendFormat(" %zd+ frames: %.3f s (%.1f%%)\n",
3098 NUM_BUCKETS - 1, bucketTimeSec, percent);
3099}
3100
Brian Andersond6927fb2016-07-23 23:37:30 -07003101void SurfaceFlinger::dumpFrameEventsLocked(String8& result) {
3102 result.appendFormat("Layer frame timestamps:\n");
3103
3104 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
3105 const size_t count = currentLayers.size();
3106 for (size_t i=0 ; i<count ; i++) {
3107 currentLayers[i]->dumpFrameEvents(result);
3108 }
3109}
3110
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003111void SurfaceFlinger::recordBufferingStats(const char* layerName,
3112 std::vector<OccupancyTracker::Segment>&& history) {
3113 Mutex::Autolock lock(mBufferingStatsMutex);
3114 auto& stats = mBufferingStats[layerName];
3115 for (const auto& segment : history) {
3116 if (!segment.usedThirdBuffer) {
3117 stats.twoBufferTime += segment.totalTime;
3118 }
3119 if (segment.occupancyAverage < 1.0f) {
3120 stats.doubleBufferedTime += segment.totalTime;
3121 } else if (segment.occupancyAverage < 2.0f) {
3122 stats.tripleBufferedTime += segment.totalTime;
3123 }
3124 ++stats.numSegments;
3125 stats.totalTime += segment.totalTime;
3126 }
3127}
3128
3129void SurfaceFlinger::dumpBufferingStats(String8& result) const {
3130 result.append("Buffering stats:\n");
3131 result.append(" [Layer name] <Active time> <Two buffer> "
3132 "<Double buffered> <Triple buffered>\n");
3133 Mutex::Autolock lock(mBufferingStatsMutex);
3134 typedef std::tuple<std::string, float, float, float> BufferTuple;
3135 std::map<float, BufferTuple, std::greater<float>> sorted;
3136 for (const auto& statsPair : mBufferingStats) {
3137 const char* name = statsPair.first.c_str();
3138 const BufferingStats& stats = statsPair.second;
3139 if (stats.numSegments == 0) {
3140 continue;
3141 }
3142 float activeTime = ns2ms(stats.totalTime) / 1000.0f;
3143 float twoBufferRatio = static_cast<float>(stats.twoBufferTime) /
3144 stats.totalTime;
3145 float doubleBufferRatio = static_cast<float>(
3146 stats.doubleBufferedTime) / stats.totalTime;
3147 float tripleBufferRatio = static_cast<float>(
3148 stats.tripleBufferedTime) / stats.totalTime;
3149 sorted.insert({activeTime, {name, twoBufferRatio,
3150 doubleBufferRatio, tripleBufferRatio}});
3151 }
3152 for (const auto& sortedPair : sorted) {
3153 float activeTime = sortedPair.first;
3154 const BufferTuple& values = sortedPair.second;
3155 result.appendFormat(" [%s] %.2f %.3f %.3f %.3f\n",
3156 std::get<0>(values).c_str(), activeTime,
3157 std::get<1>(values), std::get<2>(values),
3158 std::get<3>(values));
3159 }
3160 result.append("\n");
3161}
3162
3163void SurfaceFlinger::dumpAllLocked(const Vector<String16>& args, size_t& index,
3164 String8& result) const
3165{
3166 bool colorize = false;
3167 if (index < args.size()
3168 && (args[index] == String16("--color"))) {
3169 colorize = true;
3170 index++;
3171 }
3172
3173 Colorizer colorizer(colorize);
3174
3175 // figure out if we're stuck somewhere
3176 const nsecs_t now = systemTime();
3177 const nsecs_t inSwapBuffers(mDebugInSwapBuffers);
3178 const nsecs_t inTransaction(mDebugInTransaction);
3179 nsecs_t inSwapBuffersDuration = (inSwapBuffers) ? now-inSwapBuffers : 0;
3180 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
3181
3182 /*
3183 * Dump library configuration.
3184 */
3185
3186 colorizer.bold(result);
3187 result.append("Build configuration:");
3188 colorizer.reset(result);
3189 appendSfConfigString(result);
3190 appendUiConfigString(result);
3191 appendGuiConfigString(result);
3192 result.append("\n");
3193
3194 colorizer.bold(result);
3195 result.append("Sync configuration: ");
3196 colorizer.reset(result);
3197 result.append(SyncFeatures::getInstance().toString());
3198 result.append("\n");
3199
3200 colorizer.bold(result);
3201 result.append("DispSync configuration: ");
3202 colorizer.reset(result);
3203 result.appendFormat("app phase %" PRId64 " ns, sf phase %" PRId64 " ns, "
Fabien Sanglardc45a7d92017-03-14 13:24:22 -07003204 "present offset %" PRId64 " ns (refresh %" PRId64 " ns)",
3205 vsyncPhaseOffsetNs, sfVsyncPhaseOffsetNs, dispSyncPresentTimeOffset,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003206 mHwc->getRefreshPeriod(HWC_DISPLAY_PRIMARY));
3207 result.append("\n");
3208
3209 // Dump static screen stats
3210 result.append("\n");
3211 dumpStaticScreenStats(result);
3212 result.append("\n");
3213
3214 dumpBufferingStats(result);
3215
3216 /*
3217 * Dump the visible layer list
3218 */
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003219 colorizer.bold(result);
Robert Carr1f0a16a2016-10-24 16:27:39 -07003220 result.appendFormat("Visible layers (count = %zu)\n", mNumLayers);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003221 colorizer.reset(result);
Robert Carr2047fae2016-11-28 14:09:09 -08003222 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003223 layer->dump(result, colorizer);
Robert Carr2047fae2016-11-28 14:09:09 -08003224 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003225
3226 /*
3227 * Dump Display state
3228 */
3229
3230 colorizer.bold(result);
3231 result.appendFormat("Displays (%zu entries)\n", mDisplays.size());
3232 colorizer.reset(result);
3233 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
3234 const sp<const DisplayDevice>& hw(mDisplays[dpy]);
3235 hw->dump(result);
3236 }
3237
3238 /*
3239 * Dump SurfaceFlinger global state
3240 */
3241
3242 colorizer.bold(result);
3243 result.append("SurfaceFlinger global state:\n");
3244 colorizer.reset(result);
3245
3246 HWComposer& hwc(getHwComposer());
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07003247 sp<const DisplayDevice> hw(getDefaultDisplayDeviceLocked());
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003248
3249 colorizer.bold(result);
3250 result.appendFormat("EGL implementation : %s\n",
3251 eglQueryStringImplementationANDROID(mEGLDisplay, EGL_VERSION));
3252 colorizer.reset(result);
3253 result.appendFormat("%s\n",
3254 eglQueryStringImplementationANDROID(mEGLDisplay, EGL_EXTENSIONS));
3255
3256 mRenderEngine->dump(result);
3257
3258 hw->undefinedRegion.dump(result, "undefinedRegion");
3259 result.appendFormat(" orientation=%d, isDisplayOn=%d\n",
3260 hw->getOrientation(), hw->isDisplayOn());
3261 result.appendFormat(
3262 " last eglSwapBuffers() time: %f us\n"
3263 " last transaction time : %f us\n"
3264 " transaction-flags : %08x\n"
3265 " refresh-rate : %f fps\n"
3266 " x-dpi : %f\n"
3267 " y-dpi : %f\n"
3268 " gpu_to_cpu_unsupported : %d\n"
3269 ,
3270 mLastSwapBufferTime/1000.0,
3271 mLastTransactionTime/1000.0,
3272 mTransactionFlags,
3273 1e9 / hwc.getRefreshPeriod(HWC_DISPLAY_PRIMARY),
3274 hwc.getDpiX(HWC_DISPLAY_PRIMARY),
3275 hwc.getDpiY(HWC_DISPLAY_PRIMARY),
3276 !mGpuToCpuSupported);
3277
3278 result.appendFormat(" eglSwapBuffers time: %f us\n",
3279 inSwapBuffersDuration/1000.0);
3280
3281 result.appendFormat(" transaction time: %f us\n",
3282 inTransactionDuration/1000.0);
3283
3284 /*
3285 * VSYNC state
3286 */
3287 mEventThread->dump(result);
3288
3289 /*
3290 * Dump HWComposer state
3291 */
3292 colorizer.bold(result);
3293 result.append("h/w composer state:\n");
3294 colorizer.reset(result);
3295 result.appendFormat(" h/w composer %s and %s\n",
3296 hwc.initCheck()==NO_ERROR ? "present" : "not present",
3297 (mDebugDisableHWC || mDebugRegion || mDaltonize
3298 || mHasColorMatrix) ? "disabled" : "enabled");
3299 hwc.dump(result);
3300
3301 /*
3302 * Dump gralloc state
3303 */
3304 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
3305 alloc.dump(result);
3306}
3307
3308const Vector< sp<Layer> >&
3309SurfaceFlinger::getLayerSortedByZForHwcDisplay(int id) {
3310 // Note: mStateLock is held here
3311 wp<IBinder> dpy;
3312 for (size_t i=0 ; i<mDisplays.size() ; i++) {
3313 if (mDisplays.valueAt(i)->getHwcDisplayId() == id) {
3314 dpy = mDisplays.keyAt(i);
3315 break;
3316 }
3317 }
3318 if (dpy == NULL) {
3319 ALOGE("getLayerSortedByZForHwcDisplay: invalid hwc display id %d", id);
3320 // Just use the primary display so we have something to return
3321 dpy = getBuiltInDisplay(DisplayDevice::DISPLAY_PRIMARY);
3322 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07003323 return getDisplayDeviceLocked(dpy)->getVisibleLayersSortedByZ();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003324}
3325
3326bool SurfaceFlinger::startDdmConnection()
3327{
3328 void* libddmconnection_dso =
3329 dlopen("libsurfaceflinger_ddmconnection.so", RTLD_NOW);
3330 if (!libddmconnection_dso) {
3331 return false;
3332 }
3333 void (*DdmConnection_start)(const char* name);
3334 DdmConnection_start =
3335 (decltype(DdmConnection_start))dlsym(libddmconnection_dso, "DdmConnection_start");
3336 if (!DdmConnection_start) {
3337 dlclose(libddmconnection_dso);
3338 return false;
3339 }
3340 (*DdmConnection_start)(getServiceName());
3341 return true;
3342}
3343
3344status_t SurfaceFlinger::onTransact(
3345 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
3346{
3347 switch (code) {
3348 case CREATE_CONNECTION:
3349 case CREATE_DISPLAY:
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003350 case BOOT_FINISHED:
3351 case CLEAR_ANIMATION_FRAME_STATS:
3352 case GET_ANIMATION_FRAME_STATS:
3353 case SET_POWER_MODE:
3354 case GET_HDR_CAPABILITIES:
3355 {
3356 // codes that require permission check
3357 IPCThreadState* ipc = IPCThreadState::self();
3358 const int pid = ipc->getCallingPid();
3359 const int uid = ipc->getCallingUid();
3360 if ((uid != AID_GRAPHICS && uid != AID_SYSTEM) &&
3361 !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)) {
3362 ALOGE("Permission Denial: "
3363 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
3364 return PERMISSION_DENIED;
3365 }
3366 break;
3367 }
Robert Carr1db73f62016-12-21 12:58:51 -08003368 /*
3369 * Calling setTransactionState is safe, because you need to have been
3370 * granted a reference to Client* and Handle* to do anything with it.
3371 *
3372 * Creating a scoped connection is safe, as per discussion in ISurfaceComposer.h
3373 */
3374 case SET_TRANSACTION_STATE:
3375 case CREATE_SCOPED_CONNECTION:
3376 {
3377 break;
3378 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003379 case CAPTURE_SCREEN:
3380 {
3381 // codes that require permission check
3382 IPCThreadState* ipc = IPCThreadState::self();
3383 const int pid = ipc->getCallingPid();
3384 const int uid = ipc->getCallingUid();
3385 if ((uid != AID_GRAPHICS) &&
3386 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
3387 ALOGE("Permission Denial: "
3388 "can't read framebuffer pid=%d, uid=%d", pid, uid);
3389 return PERMISSION_DENIED;
3390 }
3391 break;
3392 }
3393 }
3394
3395 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
3396 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
3397 CHECK_INTERFACE(ISurfaceComposer, data, reply);
3398 if (CC_UNLIKELY(!PermissionCache::checkCallingPermission(sHardwareTest))) {
3399 IPCThreadState* ipc = IPCThreadState::self();
3400 const int pid = ipc->getCallingPid();
3401 const int uid = ipc->getCallingUid();
3402 ALOGE("Permission Denial: "
3403 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
3404 return PERMISSION_DENIED;
3405 }
3406 int n;
3407 switch (code) {
3408 case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
3409 case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
3410 return NO_ERROR;
3411 case 1002: // SHOW_UPDATES
3412 n = data.readInt32();
3413 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
3414 invalidateHwcGeometry();
3415 repaintEverything();
3416 return NO_ERROR;
3417 case 1004:{ // repaint everything
3418 repaintEverything();
3419 return NO_ERROR;
3420 }
3421 case 1005:{ // force transaction
3422 setTransactionFlags(
3423 eTransactionNeeded|
3424 eDisplayTransactionNeeded|
3425 eTraversalNeeded);
3426 return NO_ERROR;
3427 }
3428 case 1006:{ // send empty update
3429 signalRefresh();
3430 return NO_ERROR;
3431 }
3432 case 1008: // toggle use of hw composer
3433 n = data.readInt32();
3434 mDebugDisableHWC = n ? 1 : 0;
3435 invalidateHwcGeometry();
3436 repaintEverything();
3437 return NO_ERROR;
3438 case 1009: // toggle use of transform hint
3439 n = data.readInt32();
3440 mDebugDisableTransformHint = n ? 1 : 0;
3441 invalidateHwcGeometry();
3442 repaintEverything();
3443 return NO_ERROR;
3444 case 1010: // interrogate.
3445 reply->writeInt32(0);
3446 reply->writeInt32(0);
3447 reply->writeInt32(mDebugRegion);
3448 reply->writeInt32(0);
3449 reply->writeInt32(mDebugDisableHWC);
3450 return NO_ERROR;
3451 case 1013: {
3452 Mutex::Autolock _l(mStateLock);
3453 sp<const DisplayDevice> hw(getDefaultDisplayDevice());
3454 reply->writeInt32(hw->getPageFlipCount());
3455 return NO_ERROR;
3456 }
3457 case 1014: {
3458 // daltonize
3459 n = data.readInt32();
3460 switch (n % 10) {
3461 case 1:
3462 mDaltonizer.setType(ColorBlindnessType::Protanomaly);
3463 break;
3464 case 2:
3465 mDaltonizer.setType(ColorBlindnessType::Deuteranomaly);
3466 break;
3467 case 3:
3468 mDaltonizer.setType(ColorBlindnessType::Tritanomaly);
3469 break;
3470 }
3471 if (n >= 10) {
3472 mDaltonizer.setMode(ColorBlindnessMode::Correction);
3473 } else {
3474 mDaltonizer.setMode(ColorBlindnessMode::Simulation);
3475 }
3476 mDaltonize = n > 0;
3477 invalidateHwcGeometry();
3478 repaintEverything();
3479 return NO_ERROR;
3480 }
3481 case 1015: {
3482 // apply a color matrix
3483 n = data.readInt32();
3484 mHasColorMatrix = n ? 1 : 0;
3485 if (n) {
3486 // color matrix is sent as mat3 matrix followed by vec3
3487 // offset, then packed into a mat4 where the last row is
3488 // the offset and extra values are 0
3489 for (size_t i = 0 ; i < 4; i++) {
3490 for (size_t j = 0; j < 4; j++) {
3491 mColorMatrix[i][j] = data.readFloat();
3492 }
3493 }
3494 } else {
3495 mColorMatrix = mat4();
3496 }
3497 invalidateHwcGeometry();
3498 repaintEverything();
3499 return NO_ERROR;
3500 }
3501 // This is an experimental interface
3502 // Needs to be shifted to proper binder interface when we productize
3503 case 1016: {
3504 n = data.readInt32();
3505 mPrimaryDispSync.setRefreshSkipCount(n);
3506 return NO_ERROR;
3507 }
3508 case 1017: {
3509 n = data.readInt32();
3510 mForceFullDamage = static_cast<bool>(n);
3511 return NO_ERROR;
3512 }
3513 case 1018: { // Modify Choreographer's phase offset
3514 n = data.readInt32();
3515 mEventThread->setPhaseOffset(static_cast<nsecs_t>(n));
3516 return NO_ERROR;
3517 }
3518 case 1019: { // Modify SurfaceFlinger's phase offset
3519 n = data.readInt32();
3520 mSFEventThread->setPhaseOffset(static_cast<nsecs_t>(n));
3521 return NO_ERROR;
3522 }
3523 case 1020: { // Layer updates interceptor
3524 n = data.readInt32();
3525 if (n) {
3526 ALOGV("Interceptor enabled");
3527 mInterceptor.enable(mDrawingState.layersSortedByZ, mDrawingState.displays);
3528 }
3529 else{
3530 ALOGV("Interceptor disabled");
3531 mInterceptor.disable();
3532 }
3533 return NO_ERROR;
3534 }
3535 case 1021: { // Disable HWC virtual displays
3536 n = data.readInt32();
3537 mUseHwcVirtualDisplays = !n;
3538 return NO_ERROR;
3539 }
3540 }
3541 }
3542 return err;
3543}
3544
3545void SurfaceFlinger::repaintEverything() {
3546 android_atomic_or(1, &mRepaintEverything);
3547 signalTransaction();
3548}
3549
3550// ---------------------------------------------------------------------------
3551// Capture screen into an IGraphiBufferProducer
3552// ---------------------------------------------------------------------------
3553
3554/* The code below is here to handle b/8734824
3555 *
3556 * We create a IGraphicBufferProducer wrapper that forwards all calls
3557 * from the surfaceflinger thread to the calling binder thread, where they
3558 * are executed. This allows the calling thread in the calling process to be
3559 * reused and not depend on having "enough" binder threads to handle the
3560 * requests.
3561 */
3562class GraphicProducerWrapper : public BBinder, public MessageHandler {
3563 /* Parts of GraphicProducerWrapper are run on two different threads,
3564 * communicating by sending messages via Looper but also by shared member
3565 * data. Coherence maintenance is subtle and in places implicit (ugh).
3566 *
3567 * Don't rely on Looper's sendMessage/handleMessage providing
3568 * release/acquire semantics for any data not actually in the Message.
3569 * Data going from surfaceflinger to binder threads needs to be
3570 * synchronized explicitly.
3571 *
3572 * Barrier open/wait do provide release/acquire semantics. This provides
3573 * implicit synchronization for data coming back from binder to
3574 * surfaceflinger threads.
3575 */
3576
3577 sp<IGraphicBufferProducer> impl;
3578 sp<Looper> looper;
3579 status_t result;
3580 bool exitPending;
3581 bool exitRequested;
3582 Barrier barrier;
3583 uint32_t code;
3584 Parcel const* data;
3585 Parcel* reply;
3586
3587 enum {
3588 MSG_API_CALL,
3589 MSG_EXIT
3590 };
3591
3592 /*
3593 * Called on surfaceflinger thread. This is called by our "fake"
3594 * BpGraphicBufferProducer. We package the data and reply Parcel and
3595 * forward them to the binder thread.
3596 */
3597 virtual status_t transact(uint32_t code,
3598 const Parcel& data, Parcel* reply, uint32_t /* flags */) {
3599 this->code = code;
3600 this->data = &data;
3601 this->reply = reply;
3602 if (exitPending) {
3603 // if we've exited, we run the message synchronously right here.
3604 // note (JH): as far as I can tell from looking at the code, this
3605 // never actually happens. if it does, i'm not sure if it happens
3606 // on the surfaceflinger or binder thread.
3607 handleMessage(Message(MSG_API_CALL));
3608 } else {
3609 barrier.close();
3610 // Prevent stores to this->{code, data, reply} from being
3611 // reordered later than the construction of Message.
3612 atomic_thread_fence(memory_order_release);
3613 looper->sendMessage(this, Message(MSG_API_CALL));
3614 barrier.wait();
3615 }
3616 return result;
3617 }
3618
3619 /*
3620 * here we run on the binder thread. All we've got to do is
3621 * call the real BpGraphicBufferProducer.
3622 */
3623 virtual void handleMessage(const Message& message) {
3624 int what = message.what;
3625 // Prevent reads below from happening before the read from Message
3626 atomic_thread_fence(memory_order_acquire);
3627 if (what == MSG_API_CALL) {
3628 result = IInterface::asBinder(impl)->transact(code, data[0], reply);
3629 barrier.open();
3630 } else if (what == MSG_EXIT) {
3631 exitRequested = true;
3632 }
3633 }
3634
3635public:
3636 explicit GraphicProducerWrapper(const sp<IGraphicBufferProducer>& impl)
3637 : impl(impl),
3638 looper(new Looper(true)),
3639 result(NO_ERROR),
3640 exitPending(false),
3641 exitRequested(false),
3642 code(0),
3643 data(NULL),
3644 reply(NULL)
3645 {}
3646
3647 // Binder thread
3648 status_t waitForResponse() {
3649 do {
3650 looper->pollOnce(-1);
3651 } while (!exitRequested);
3652 return result;
3653 }
3654
3655 // Client thread
3656 void exit(status_t result) {
3657 this->result = result;
3658 exitPending = true;
3659 // Ensure this->result is visible to the binder thread before it
3660 // handles the message.
3661 atomic_thread_fence(memory_order_release);
3662 looper->sendMessage(this, Message(MSG_EXIT));
3663 }
3664};
3665
3666
3667status_t SurfaceFlinger::captureScreen(const sp<IBinder>& display,
3668 const sp<IGraphicBufferProducer>& producer,
3669 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Robert Carrae060832016-11-28 10:51:00 -08003670 int32_t minLayerZ, int32_t maxLayerZ,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003671 bool useIdentityTransform, ISurfaceComposer::Rotation rotation) {
3672
3673 if (CC_UNLIKELY(display == 0))
3674 return BAD_VALUE;
3675
3676 if (CC_UNLIKELY(producer == 0))
3677 return BAD_VALUE;
3678
3679 // if we have secure windows on this display, never allow the screen capture
3680 // unless the producer interface is local (i.e.: we can take a screenshot for
3681 // ourselves).
3682 bool isLocalScreenshot = IInterface::asBinder(producer)->localBinder();
3683
3684 // Convert to surfaceflinger's internal rotation type.
3685 Transform::orientation_flags rotationFlags;
3686 switch (rotation) {
3687 case ISurfaceComposer::eRotateNone:
3688 rotationFlags = Transform::ROT_0;
3689 break;
3690 case ISurfaceComposer::eRotate90:
3691 rotationFlags = Transform::ROT_90;
3692 break;
3693 case ISurfaceComposer::eRotate180:
3694 rotationFlags = Transform::ROT_180;
3695 break;
3696 case ISurfaceComposer::eRotate270:
3697 rotationFlags = Transform::ROT_270;
3698 break;
3699 default:
3700 rotationFlags = Transform::ROT_0;
3701 ALOGE("Invalid rotation passed to captureScreen(): %d\n", rotation);
3702 break;
3703 }
3704
3705 class MessageCaptureScreen : public MessageBase {
3706 SurfaceFlinger* flinger;
3707 sp<IBinder> display;
3708 sp<IGraphicBufferProducer> producer;
3709 Rect sourceCrop;
3710 uint32_t reqWidth, reqHeight;
Robert Carrae060832016-11-28 10:51:00 -08003711 int32_t minLayerZ,maxLayerZ;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003712 bool useIdentityTransform;
3713 Transform::orientation_flags rotation;
3714 status_t result;
3715 bool isLocalScreenshot;
3716 public:
3717 MessageCaptureScreen(SurfaceFlinger* flinger,
3718 const sp<IBinder>& display,
3719 const sp<IGraphicBufferProducer>& producer,
3720 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Robert Carrae060832016-11-28 10:51:00 -08003721 int32_t minLayerZ, int32_t maxLayerZ,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003722 bool useIdentityTransform,
3723 Transform::orientation_flags rotation,
3724 bool isLocalScreenshot)
3725 : flinger(flinger), display(display), producer(producer),
3726 sourceCrop(sourceCrop), reqWidth(reqWidth), reqHeight(reqHeight),
3727 minLayerZ(minLayerZ), maxLayerZ(maxLayerZ),
3728 useIdentityTransform(useIdentityTransform),
3729 rotation(rotation), result(PERMISSION_DENIED),
3730 isLocalScreenshot(isLocalScreenshot)
3731 {
3732 }
3733 status_t getResult() const {
3734 return result;
3735 }
3736 virtual bool handler() {
3737 Mutex::Autolock _l(flinger->mStateLock);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07003738 sp<const DisplayDevice> hw(flinger->getDisplayDeviceLocked(display));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003739 result = flinger->captureScreenImplLocked(hw, producer,
3740 sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ,
3741 useIdentityTransform, rotation, isLocalScreenshot);
3742 static_cast<GraphicProducerWrapper*>(IInterface::asBinder(producer).get())->exit(result);
3743 return true;
3744 }
3745 };
3746
3747 // this creates a "fake" BBinder which will serve as a "fake" remote
3748 // binder to receive the marshaled calls and forward them to the
3749 // real remote (a BpGraphicBufferProducer)
3750 sp<GraphicProducerWrapper> wrapper = new GraphicProducerWrapper(producer);
3751
3752 // the asInterface() call below creates our "fake" BpGraphicBufferProducer
3753 // which does the marshaling work forwards to our "fake remote" above.
3754 sp<MessageBase> msg = new MessageCaptureScreen(this,
3755 display, IGraphicBufferProducer::asInterface( wrapper ),
3756 sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ,
3757 useIdentityTransform, rotationFlags, isLocalScreenshot);
3758
3759 status_t res = postMessageAsync(msg);
3760 if (res == NO_ERROR) {
3761 res = wrapper->waitForResponse();
3762 }
3763 return res;
3764}
3765
3766
3767void SurfaceFlinger::renderScreenImplLocked(
3768 const sp<const DisplayDevice>& hw,
3769 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Robert Carrae060832016-11-28 10:51:00 -08003770 int32_t minLayerZ, int32_t maxLayerZ,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003771 bool yswap, bool useIdentityTransform, Transform::orientation_flags rotation)
3772{
3773 ATRACE_CALL();
3774 RenderEngine& engine(getRenderEngine());
3775
3776 // get screen geometry
3777 const int32_t hw_w = hw->getWidth();
3778 const int32_t hw_h = hw->getHeight();
3779 const bool filtering = static_cast<int32_t>(reqWidth) != hw_w ||
3780 static_cast<int32_t>(reqHeight) != hw_h;
3781
3782 // if a default or invalid sourceCrop is passed in, set reasonable values
3783 if (sourceCrop.width() == 0 || sourceCrop.height() == 0 ||
3784 !sourceCrop.isValid()) {
3785 sourceCrop.setLeftTop(Point(0, 0));
3786 sourceCrop.setRightBottom(Point(hw_w, hw_h));
3787 }
3788
3789 // ensure that sourceCrop is inside screen
3790 if (sourceCrop.left < 0) {
3791 ALOGE("Invalid crop rect: l = %d (< 0)", sourceCrop.left);
3792 }
3793 if (sourceCrop.right > hw_w) {
3794 ALOGE("Invalid crop rect: r = %d (> %d)", sourceCrop.right, hw_w);
3795 }
3796 if (sourceCrop.top < 0) {
3797 ALOGE("Invalid crop rect: t = %d (< 0)", sourceCrop.top);
3798 }
3799 if (sourceCrop.bottom > hw_h) {
3800 ALOGE("Invalid crop rect: b = %d (> %d)", sourceCrop.bottom, hw_h);
3801 }
3802
3803 // make sure to clear all GL error flags
3804 engine.checkErrors();
3805
3806 // set-up our viewport
3807 engine.setViewportAndProjection(
3808 reqWidth, reqHeight, sourceCrop, hw_h, yswap, rotation);
3809 engine.disableTexturing();
3810
3811 // redraw the screen entirely...
3812 engine.clearWithColor(0, 0, 0, 1);
3813
Robert Carr1f0a16a2016-10-24 16:27:39 -07003814 // We loop through the first level of layers without traversing,
3815 // as we need to interpret min/max layer Z in the top level Z space.
3816 for (const auto& layer : mDrawingState.layersSortedByZ) {
3817 if (layer->getLayerStack() != hw->getLayerStack()) {
3818 continue;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003819 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07003820 const Layer::State& state(layer->getDrawingState());
3821 if (state.z < minLayerZ || state.z > maxLayerZ) {
3822 continue;
3823 }
Dan Stoza412903f2017-04-27 13:42:17 -07003824 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003825 if (!layer->isVisible()) {
3826 return;
3827 }
3828 if (filtering) layer->setFiltering(true);
3829 layer->draw(hw, useIdentityTransform);
3830 if (filtering) layer->setFiltering(false);
3831 });
3832 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003833
3834 // compositionComplete is needed for older driver
3835 hw->compositionComplete();
3836 hw->setViewportAndProjection();
3837}
3838
3839
3840status_t SurfaceFlinger::captureScreenImplLocked(
3841 const sp<const DisplayDevice>& hw,
3842 const sp<IGraphicBufferProducer>& producer,
3843 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Robert Carrae060832016-11-28 10:51:00 -08003844 int32_t minLayerZ, int32_t maxLayerZ,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003845 bool useIdentityTransform, Transform::orientation_flags rotation,
3846 bool isLocalScreenshot)
3847{
3848 ATRACE_CALL();
3849
3850 // get screen geometry
3851 uint32_t hw_w = hw->getWidth();
3852 uint32_t hw_h = hw->getHeight();
3853
3854 if (rotation & Transform::ROT_90) {
3855 std::swap(hw_w, hw_h);
3856 }
3857
3858 if ((reqWidth > hw_w) || (reqHeight > hw_h)) {
3859 ALOGE("size mismatch (%d, %d) > (%d, %d)",
3860 reqWidth, reqHeight, hw_w, hw_h);
3861 return BAD_VALUE;
3862 }
3863
3864 reqWidth = (!reqWidth) ? hw_w : reqWidth;
3865 reqHeight = (!reqHeight) ? hw_h : reqHeight;
3866
3867 bool secureLayerIsVisible = false;
Robert Carr1f0a16a2016-10-24 16:27:39 -07003868 for (const auto& layer : mDrawingState.layersSortedByZ) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003869 const Layer::State& state(layer->getDrawingState());
Robert Carr1f0a16a2016-10-24 16:27:39 -07003870 if ((layer->getLayerStack() != hw->getLayerStack()) ||
3871 (state.z < minLayerZ || state.z > maxLayerZ)) {
3872 continue;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003873 }
Dan Stoza412903f2017-04-27 13:42:17 -07003874 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer *layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003875 secureLayerIsVisible = secureLayerIsVisible || (layer->isVisible() &&
3876 layer->isSecure());
3877 });
3878 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003879
3880 if (!isLocalScreenshot && secureLayerIsVisible) {
3881 ALOGW("FB is protected: PERMISSION_DENIED");
3882 return PERMISSION_DENIED;
3883 }
3884
3885 // create a surface (because we're a producer, and we need to
3886 // dequeue/queue a buffer)
3887 sp<Surface> sur = new Surface(producer, false);
3888 ANativeWindow* window = sur.get();
3889
3890 status_t result = native_window_api_connect(window, NATIVE_WINDOW_API_EGL);
3891 if (result == NO_ERROR) {
3892 uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
3893 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
3894
3895 int err = 0;
3896 err = native_window_set_buffers_dimensions(window, reqWidth, reqHeight);
3897 err |= native_window_set_scaling_mode(window, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
3898 err |= native_window_set_buffers_format(window, HAL_PIXEL_FORMAT_RGBA_8888);
3899 err |= native_window_set_usage(window, usage);
3900
3901 if (err == NO_ERROR) {
3902 ANativeWindowBuffer* buffer;
3903 /* TODO: Once we have the sync framework everywhere this can use
3904 * server-side waits on the fence that dequeueBuffer returns.
3905 */
3906 result = native_window_dequeue_buffer_and_wait(window, &buffer);
3907 if (result == NO_ERROR) {
3908 int syncFd = -1;
3909 // create an EGLImage from the buffer so we can later
3910 // turn it into a texture
3911 EGLImageKHR image = eglCreateImageKHR(mEGLDisplay, EGL_NO_CONTEXT,
3912 EGL_NATIVE_BUFFER_ANDROID, buffer, NULL);
3913 if (image != EGL_NO_IMAGE_KHR) {
3914 // this binds the given EGLImage as a framebuffer for the
3915 // duration of this scope.
3916 RenderEngine::BindImageAsFramebuffer imageBond(getRenderEngine(), image);
3917 if (imageBond.getStatus() == NO_ERROR) {
3918 // this will in fact render into our dequeued buffer
3919 // via an FBO, which means we didn't have to create
3920 // an EGLSurface and therefore we're not
3921 // dependent on the context's EGLConfig.
3922 renderScreenImplLocked(
3923 hw, sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ, true,
3924 useIdentityTransform, rotation);
3925
3926 // Attempt to create a sync khr object that can produce a sync point. If that
3927 // isn't available, create a non-dupable sync object in the fallback path and
3928 // wait on it directly.
3929 EGLSyncKHR sync;
3930 if (!DEBUG_SCREENSHOTS) {
3931 sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, NULL);
3932 // native fence fd will not be populated until flush() is done.
3933 getRenderEngine().flush();
3934 } else {
3935 sync = EGL_NO_SYNC_KHR;
3936 }
3937 if (sync != EGL_NO_SYNC_KHR) {
3938 // get the sync fd
3939 syncFd = eglDupNativeFenceFDANDROID(mEGLDisplay, sync);
3940 if (syncFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
3941 ALOGW("captureScreen: failed to dup sync khr object");
3942 syncFd = -1;
3943 }
3944 eglDestroySyncKHR(mEGLDisplay, sync);
3945 } else {
3946 // fallback path
3947 sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, NULL);
3948 if (sync != EGL_NO_SYNC_KHR) {
3949 EGLint result = eglClientWaitSyncKHR(mEGLDisplay, sync,
3950 EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, 2000000000 /*2 sec*/);
3951 EGLint eglErr = eglGetError();
3952 if (result == EGL_TIMEOUT_EXPIRED_KHR) {
3953 ALOGW("captureScreen: fence wait timed out");
3954 } else {
3955 ALOGW_IF(eglErr != EGL_SUCCESS,
3956 "captureScreen: error waiting on EGL fence: %#x", eglErr);
3957 }
3958 eglDestroySyncKHR(mEGLDisplay, sync);
3959 } else {
3960 ALOGW("captureScreen: error creating EGL fence: %#x", eglGetError());
3961 }
3962 }
3963 if (DEBUG_SCREENSHOTS) {
3964 uint32_t* pixels = new uint32_t[reqWidth*reqHeight];
3965 getRenderEngine().readPixels(0, 0, reqWidth, reqHeight, pixels);
3966 checkScreenshot(reqWidth, reqHeight, reqWidth, pixels,
3967 hw, minLayerZ, maxLayerZ);
3968 delete [] pixels;
3969 }
3970
3971 } else {
3972 ALOGE("got GL_FRAMEBUFFER_COMPLETE_OES error while taking screenshot");
3973 result = INVALID_OPERATION;
3974 window->cancelBuffer(window, buffer, syncFd);
3975 buffer = NULL;
3976 }
3977 // destroy our image
3978 eglDestroyImageKHR(mEGLDisplay, image);
3979 } else {
3980 result = BAD_VALUE;
3981 }
3982 if (buffer) {
3983 // queueBuffer takes ownership of syncFd
3984 result = window->queueBuffer(window, buffer, syncFd);
3985 }
3986 }
3987 } else {
3988 result = BAD_VALUE;
3989 }
3990 native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
3991 }
3992
3993 return result;
3994}
3995
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003996void SurfaceFlinger::checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
Robert Carrae060832016-11-28 10:51:00 -08003997 const sp<const DisplayDevice>& hw, int32_t minLayerZ, int32_t maxLayerZ) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003998 if (DEBUG_SCREENSHOTS) {
3999 for (size_t y=0 ; y<h ; y++) {
4000 uint32_t const * p = (uint32_t const *)vaddr + y*s;
4001 for (size_t x=0 ; x<w ; x++) {
4002 if (p[x] != 0xFF000000) return;
4003 }
4004 }
4005 ALOGE("*** we just took a black screenshot ***\n"
4006 "requested minz=%d, maxz=%d, layerStack=%d",
4007 minLayerZ, maxLayerZ, hw->getLayerStack());
Robert Carr2047fae2016-11-28 14:09:09 -08004008 size_t i = 0;
Robert Carr1f0a16a2016-10-24 16:27:39 -07004009 for (const auto& layer : mDrawingState.layersSortedByZ) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004010 const Layer::State& state(layer->getDrawingState());
Robert Carr1f0a16a2016-10-24 16:27:39 -07004011 if (layer->getLayerStack() == hw->getLayerStack() && state.z >= minLayerZ &&
4012 state.z <= maxLayerZ) {
Dan Stoza412903f2017-04-27 13:42:17 -07004013 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07004014 ALOGE("%c index=%zu, name=%s, layerStack=%d, z=%d, visible=%d, flags=%x, alpha=%x",
4015 layer->isVisible() ? '+' : '-',
4016 i, layer->getName().string(), layer->getLayerStack(), state.z,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004017 layer->isVisible(), state.flags, state.alpha);
Robert Carr1f0a16a2016-10-24 16:27:39 -07004018 i++;
4019 });
4020 }
4021 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004022 }
4023}
4024
4025// ---------------------------------------------------------------------------
4026
Dan Stoza412903f2017-04-27 13:42:17 -07004027void SurfaceFlinger::State::traverseInZOrder(const LayerVector::Visitor& visitor) const {
4028 layersSortedByZ.traverseInZOrder(stateSet, visitor);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004029}
4030
Dan Stoza412903f2017-04-27 13:42:17 -07004031void SurfaceFlinger::State::traverseInReverseZOrder(const LayerVector::Visitor& visitor) const {
4032 layersSortedByZ.traverseInReverseZOrder(stateSet, visitor);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004033}
4034
4035}; // namespace android
4036
4037
4038#if defined(__gl_h_)
4039#error "don't include gl/gl.h in this file"
4040#endif
4041
4042#if defined(__gl2_h_)
4043#error "don't include gl2/gl2.h in this file"
4044#endif