blob: 81bda02d80eebccabd8793631335cde5f5124211 [file] [log] [blame]
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define ATRACE_TAG ATRACE_TAG_GRAPHICS
18
Mark Salyzyn7823e122016-09-29 08:08:05 -070019#include <dlfcn.h>
20#include <errno.h>
21#include <inttypes.h>
22#include <math.h>
23#include <stdatomic.h>
Fabien Sanglard9d96de42016-10-11 00:15:18 +000024#include <stdint.h>
25#include <sys/types.h>
Dan Stoza9e56aa02015-11-02 13:00:03 -080026
Fabien Sanglard9d96de42016-10-11 00:15:18 +000027#include <mutex>
Fabien Sanglard9d96de42016-10-11 00:15:18 +000028
29#include <EGL/egl.h>
30
Fabien Sanglard9d96de42016-10-11 00:15:18 +000031#include <cutils/properties.h>
Mark Salyzyn7823e122016-09-29 08:08:05 -070032#include <log/log.h>
Fabien Sanglard9d96de42016-10-11 00:15:18 +000033
34#include <binder/IPCThreadState.h>
35#include <binder/IServiceManager.h>
Fabien Sanglard9d96de42016-10-11 00:15:18 +000036#include <binder/PermissionCache.h>
37
38#include <ui/DisplayInfo.h>
39#include <ui/DisplayStatInfo.h>
40
Fabien Sanglard9d96de42016-10-11 00:15:18 +000041#include <gui/BufferQueue.h>
42#include <gui/GuiConfig.h>
43#include <gui/IDisplayEventConnection.h>
Kalle Raitaa099a242017-01-11 11:17:29 -080044#include <gui/LayerDebugInfo.h>
Fabien Sanglard9d96de42016-10-11 00:15:18 +000045#include <gui/Surface.h>
Fabien Sanglard9d96de42016-10-11 00:15:18 +000046
47#include <ui/GraphicBufferAllocator.h>
48#include <ui/HdrCapabilities.h>
49#include <ui/PixelFormat.h>
50#include <ui/UiConfig.h>
51
52#include <utils/misc.h>
53#include <utils/String8.h>
54#include <utils/String16.h>
55#include <utils/StopWatch.h>
56#include <utils/Timers.h>
57#include <utils/Trace.h>
58
59#include <private/android_filesystem_config.h>
60#include <private/gui/SyncFeatures.h>
61
62#include <set>
63
64#include "Client.h"
65#include "clz.h"
66#include "Colorizer.h"
67#include "DdmConnection.h"
68#include "DisplayDevice.h"
69#include "DispSync.h"
70#include "EventControlThread.h"
71#include "EventThread.h"
72#include "Layer.h"
Robert Carr1f0a16a2016-10-24 16:27:39 -070073#include "LayerVector.h"
chaviw13fdc492017-06-27 12:40:18 -070074#include "ColorLayer.h"
Robert Carr1db73f62016-12-21 12:58:51 -080075#include "MonitoredProducer.h"
Fabien Sanglard9d96de42016-10-11 00:15:18 +000076#include "SurfaceFlinger.h"
77
78#include "DisplayHardware/FramebufferSurface.h"
79#include "DisplayHardware/HWComposer.h"
80#include "DisplayHardware/VirtualDisplaySurface.h"
81
82#include "Effects/Daltonizer.h"
83
84#include "RenderEngine/RenderEngine.h"
85#include <cutils/compiler.h>
86
Fabien Sanglard0cc19382017-03-06 11:54:40 -080087#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
88#include <configstore/Utils.h>
89
Fabien Sanglard9d96de42016-10-11 00:15:18 +000090#define DISPLAY_COUNT 1
91
92/*
93 * DEBUG_SCREENSHOTS: set to true to check that screenshots are not all
94 * black pixels.
95 */
96#define DEBUG_SCREENSHOTS false
97
Jiyong Park00b15b82017-08-10 20:30:56 +090098extern "C" EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name);
Fabien Sanglard9d96de42016-10-11 00:15:18 +000099
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000100namespace android {
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000101// ---------------------------------------------------------------------------
102
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800103using namespace android::hardware::configstore;
104using namespace android::hardware::configstore::V1_0;
105
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000106const String16 sHardwareTest("android.permission.HARDWARE_TEST");
107const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER");
108const String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER");
109const String16 sDump("android.permission.DUMP");
110
111// ---------------------------------------------------------------------------
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800112int64_t SurfaceFlinger::vsyncPhaseOffsetNs;
113int64_t SurfaceFlinger::sfVsyncPhaseOffsetNs;
Fabien Sanglardc93afd52017-03-13 13:02:42 -0700114bool SurfaceFlinger::useContextPriority;
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700115int64_t SurfaceFlinger::dispSyncPresentTimeOffset;
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700116bool SurfaceFlinger::useHwcForRgbToYuv;
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800117uint64_t SurfaceFlinger::maxVirtualDisplaySize;
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800118bool SurfaceFlinger::hasSyncFramework;
Fabien Sanglard1971b632017-03-10 14:50:03 -0800119int64_t SurfaceFlinger::maxFrameBufferAcquiredBuffers;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000120
121SurfaceFlinger::SurfaceFlinger()
122 : BnSurfaceComposer(),
123 mTransactionFlags(0),
124 mTransactionPending(false),
125 mAnimTransactionPending(false),
126 mLayersRemoved(false),
Robert Carr1f0a16a2016-10-24 16:27:39 -0700127 mLayersAdded(false),
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000128 mRepaintEverything(0),
129 mRenderEngine(NULL),
130 mBootTime(systemTime()),
131 mVisibleRegionsDirty(false),
132 mHwWorkListDirty(false),
133 mAnimCompositionPending(false),
134 mDebugRegion(0),
135 mDebugDDMS(0),
136 mDebugDisableHWC(0),
137 mDebugDisableTransformHint(0),
138 mDebugInSwapBuffers(0),
139 mLastSwapBufferTime(0),
140 mDebugInTransaction(0),
141 mLastTransactionTime(0),
142 mBootFinished(false),
143 mForceFullDamage(false),
Robert Carr0d480722017-01-10 16:42:54 -0800144 mInterceptor(this),
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000145 mPrimaryDispSync("PrimaryDispSync"),
146 mPrimaryHWVsyncEnabled(false),
147 mHWVsyncAvailable(false),
148 mDaltonize(false),
149 mHasColorMatrix(false),
150 mHasPoweredOff(false),
151 mFrameBuckets(),
152 mTotalTime(0),
Robert Carr1f0a16a2016-10-24 16:27:39 -0700153 mLastSwapTime(0),
154 mNumLayers(0)
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000155{
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800156 ALOGI("SurfaceFlinger is starting");
157
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800158 vsyncPhaseOffsetNs = getInt64< ISurfaceFlingerConfigs,
159 &ISurfaceFlingerConfigs::vsyncEventPhaseOffsetNs>(1000000);
160
161 sfVsyncPhaseOffsetNs = getInt64< ISurfaceFlingerConfigs,
162 &ISurfaceFlingerConfigs::vsyncSfEventPhaseOffsetNs>(1000000);
163
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800164 maxVirtualDisplaySize = getUInt64<ISurfaceFlingerConfigs,
165 &ISurfaceFlingerConfigs::maxVirtualDisplaySize>(0);
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000166
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800167 hasSyncFramework = getBool< ISurfaceFlingerConfigs,
168 &ISurfaceFlingerConfigs::hasSyncFramework>(true);
169
Fabien Sanglardc93afd52017-03-13 13:02:42 -0700170 useContextPriority = getBool< ISurfaceFlingerConfigs,
171 &ISurfaceFlingerConfigs::useContextPriority>(false);
172
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700173 dispSyncPresentTimeOffset = getInt64< ISurfaceFlingerConfigs,
174 &ISurfaceFlingerConfigs::presentTimeOffsetFromVSyncNs>(0);
175
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700176 useHwcForRgbToYuv = getBool< ISurfaceFlingerConfigs,
177 &ISurfaceFlingerConfigs::useHwcForRGBtoYUV>(false);
178
Fabien Sanglard1971b632017-03-10 14:50:03 -0800179 maxFrameBufferAcquiredBuffers = getInt64< ISurfaceFlingerConfigs,
180 &ISurfaceFlingerConfigs::maxFrameBufferAcquiredBuffers>(2);
181
Marissa Wall4dea0382017-09-18 13:26:15 -0700182 mPrimaryDispSync.init(hasSyncFramework, dispSyncPresentTimeOffset);
183
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000184 char value[PROPERTY_VALUE_MAX];
185
186 property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");
187 mGpuToCpuSupported = !atoi(value);
188
189 property_get("debug.sf.showupdates", value, "0");
190 mDebugRegion = atoi(value);
191
192 property_get("debug.sf.ddms", value, "0");
193 mDebugDDMS = atoi(value);
194 if (mDebugDDMS) {
195 if (!startDdmConnection()) {
196 // start failed, and DDMS debugging not enabled
197 mDebugDDMS = 0;
198 }
199 }
200 ALOGI_IF(mDebugRegion, "showupdates enabled");
201 ALOGI_IF(mDebugDDMS, "DDMS debugging enabled");
202
Fabien Sanglard642b23d2017-02-09 12:29:39 -0800203 property_get("debug.sf.enable_hwc_vds", value, "0");
204 mUseHwcVirtualDisplays = atoi(value);
205 ALOGI_IF(!mUseHwcVirtualDisplays, "Enabling HWC virtual displays");
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800206
Fabien Sanglardc65dafa2017-02-07 14:06:39 -0800207 property_get("ro.sf.disable_triple_buffer", value, "1");
208 mLayerTripleBufferingDisabled = atoi(value);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800209 ALOGI_IF(mLayerTripleBufferingDisabled, "Disabling Triple Buffering");
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000210}
211
212void SurfaceFlinger::onFirstRef()
213{
214 mEventQueue.init(this);
215}
216
217SurfaceFlinger::~SurfaceFlinger()
218{
219 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
220 eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
221 eglTerminate(display);
222}
223
224void SurfaceFlinger::binderDied(const wp<IBinder>& /* who */)
225{
226 // the window manager died on us. prepare its eulogy.
227
228 // restore initial conditions (default device unblank, etc)
229 initializeDisplays();
230
231 // restart the boot-animation
232 startBootAnim();
233}
234
Robert Carr1db73f62016-12-21 12:58:51 -0800235static sp<ISurfaceComposerClient> initClient(const sp<Client>& client) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000236 status_t err = client->initCheck();
237 if (err == NO_ERROR) {
Robert Carr1db73f62016-12-21 12:58:51 -0800238 return client;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000239 }
Robert Carr1db73f62016-12-21 12:58:51 -0800240 return nullptr;
241}
242
243sp<ISurfaceComposerClient> SurfaceFlinger::createConnection() {
244 return initClient(new Client(this));
245}
246
247sp<ISurfaceComposerClient> SurfaceFlinger::createScopedConnection(
248 const sp<IGraphicBufferProducer>& gbp) {
249 if (authenticateSurfaceTexture(gbp) == false) {
250 return nullptr;
251 }
252 const auto& layer = (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
253 if (layer == nullptr) {
254 return nullptr;
255 }
256
257 return initClient(new Client(this, layer));
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000258}
259
260sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName,
261 bool secure)
262{
263 class DisplayToken : public BBinder {
264 sp<SurfaceFlinger> flinger;
265 virtual ~DisplayToken() {
266 // no more references, this display must be terminated
267 Mutex::Autolock _l(flinger->mStateLock);
268 flinger->mCurrentState.displays.removeItem(this);
269 flinger->setTransactionFlags(eDisplayTransactionNeeded);
270 }
271 public:
272 explicit DisplayToken(const sp<SurfaceFlinger>& flinger)
273 : flinger(flinger) {
274 }
275 };
276
277 sp<BBinder> token = new DisplayToken(this);
278
279 Mutex::Autolock _l(mStateLock);
280 DisplayDeviceState info(DisplayDevice::DISPLAY_VIRTUAL, secure);
281 info.displayName = displayName;
282 mCurrentState.displays.add(token, info);
283 mInterceptor.saveDisplayCreation(info);
284 return token;
285}
286
287void SurfaceFlinger::destroyDisplay(const sp<IBinder>& display) {
288 Mutex::Autolock _l(mStateLock);
289
290 ssize_t idx = mCurrentState.displays.indexOfKey(display);
291 if (idx < 0) {
292 ALOGW("destroyDisplay: invalid display token");
293 return;
294 }
295
296 const DisplayDeviceState& info(mCurrentState.displays.valueAt(idx));
297 if (!info.isVirtualDisplay()) {
298 ALOGE("destroyDisplay called for non-virtual display");
299 return;
300 }
301 mInterceptor.saveDisplayDeletion(info.displayId);
302 mCurrentState.displays.removeItemsAt(idx);
303 setTransactionFlags(eDisplayTransactionNeeded);
304}
305
306void SurfaceFlinger::createBuiltinDisplayLocked(DisplayDevice::DisplayType type) {
307 ALOGW_IF(mBuiltinDisplays[type],
308 "Overwriting display token for display type %d", type);
309 mBuiltinDisplays[type] = new BBinder();
310 // All non-virtual displays are currently considered secure.
311 DisplayDeviceState info(type, true);
312 mCurrentState.displays.add(mBuiltinDisplays[type], info);
313 mInterceptor.saveDisplayCreation(info);
314}
315
316sp<IBinder> SurfaceFlinger::getBuiltInDisplay(int32_t id) {
317 if (uint32_t(id) >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
318 ALOGE("getDefaultDisplay: id=%d is not a valid default display id", id);
319 return NULL;
320 }
321 return mBuiltinDisplays[id];
322}
323
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000324void SurfaceFlinger::bootFinished()
325{
Wei Wangf9b05ee2017-07-19 20:59:39 -0700326 if (mStartPropertySetThread->join() != NO_ERROR) {
327 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800328 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000329 const nsecs_t now = systemTime();
330 const nsecs_t duration = now - mBootTime;
331 ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
332 mBootFinished = true;
333
334 // wait patiently for the window manager death
335 const String16 name("window");
336 sp<IBinder> window(defaultServiceManager()->getService(name));
337 if (window != 0) {
338 window->linkToDeath(static_cast<IBinder::DeathRecipient*>(this));
339 }
340
341 // stop boot animation
342 // formerly we would just kill the process, but we now ask it to exit so it
343 // can choose where to stop the animation.
344 property_set("service.bootanim.exit", "1");
345
346 const int LOGTAG_SF_STOP_BOOTANIM = 60110;
347 LOG_EVENT_LONG(LOGTAG_SF_STOP_BOOTANIM,
348 ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
349}
350
351void SurfaceFlinger::deleteTextureAsync(uint32_t texture) {
352 class MessageDestroyGLTexture : public MessageBase {
353 RenderEngine& engine;
354 uint32_t texture;
355 public:
356 MessageDestroyGLTexture(RenderEngine& engine, uint32_t texture)
357 : engine(engine), texture(texture) {
358 }
359 virtual bool handler() {
360 engine.deleteTextures(1, &texture);
361 return true;
362 }
363 };
364 postMessageAsync(new MessageDestroyGLTexture(getRenderEngine(), texture));
365}
366
367class DispSyncSource : public VSyncSource, private DispSync::Callback {
368public:
369 DispSyncSource(DispSync* dispSync, nsecs_t phaseOffset, bool traceVsync,
370 const char* name) :
371 mName(name),
372 mValue(0),
373 mTraceVsync(traceVsync),
374 mVsyncOnLabel(String8::format("VsyncOn-%s", name)),
375 mVsyncEventLabel(String8::format("VSYNC-%s", name)),
376 mDispSync(dispSync),
377 mCallbackMutex(),
378 mCallback(),
379 mVsyncMutex(),
380 mPhaseOffset(phaseOffset),
381 mEnabled(false) {}
382
383 virtual ~DispSyncSource() {}
384
385 virtual void setVSyncEnabled(bool enable) {
386 Mutex::Autolock lock(mVsyncMutex);
387 if (enable) {
388 status_t err = mDispSync->addEventListener(mName, mPhaseOffset,
389 static_cast<DispSync::Callback*>(this));
390 if (err != NO_ERROR) {
391 ALOGE("error registering vsync callback: %s (%d)",
392 strerror(-err), err);
393 }
394 //ATRACE_INT(mVsyncOnLabel.string(), 1);
395 } else {
396 status_t err = mDispSync->removeEventListener(
397 static_cast<DispSync::Callback*>(this));
398 if (err != NO_ERROR) {
399 ALOGE("error unregistering vsync callback: %s (%d)",
400 strerror(-err), err);
401 }
402 //ATRACE_INT(mVsyncOnLabel.string(), 0);
403 }
404 mEnabled = enable;
405 }
406
407 virtual void setCallback(const sp<VSyncSource::Callback>& callback) {
408 Mutex::Autolock lock(mCallbackMutex);
409 mCallback = callback;
410 }
411
412 virtual void setPhaseOffset(nsecs_t phaseOffset) {
413 Mutex::Autolock lock(mVsyncMutex);
414
415 // Normalize phaseOffset to [0, period)
416 auto period = mDispSync->getPeriod();
417 phaseOffset %= period;
418 if (phaseOffset < 0) {
419 // If we're here, then phaseOffset is in (-period, 0). After this
420 // operation, it will be in (0, period)
421 phaseOffset += period;
422 }
423 mPhaseOffset = phaseOffset;
424
425 // If we're not enabled, we don't need to mess with the listeners
426 if (!mEnabled) {
427 return;
428 }
429
430 // Remove the listener with the old offset
431 status_t err = mDispSync->removeEventListener(
432 static_cast<DispSync::Callback*>(this));
433 if (err != NO_ERROR) {
434 ALOGE("error unregistering vsync callback: %s (%d)",
435 strerror(-err), err);
436 }
437
438 // Add a listener with the new offset
439 err = mDispSync->addEventListener(mName, mPhaseOffset,
440 static_cast<DispSync::Callback*>(this));
441 if (err != NO_ERROR) {
442 ALOGE("error registering vsync callback: %s (%d)",
443 strerror(-err), err);
444 }
445 }
446
447private:
448 virtual void onDispSyncEvent(nsecs_t when) {
449 sp<VSyncSource::Callback> callback;
450 {
451 Mutex::Autolock lock(mCallbackMutex);
452 callback = mCallback;
453
454 if (mTraceVsync) {
455 mValue = (mValue + 1) % 2;
456 ATRACE_INT(mVsyncEventLabel.string(), mValue);
457 }
458 }
459
460 if (callback != NULL) {
461 callback->onVSyncEvent(when);
462 }
463 }
464
465 const char* const mName;
466
467 int mValue;
468
469 const bool mTraceVsync;
470 const String8 mVsyncOnLabel;
471 const String8 mVsyncEventLabel;
472
473 DispSync* mDispSync;
474
475 Mutex mCallbackMutex; // Protects the following
476 sp<VSyncSource::Callback> mCallback;
477
478 Mutex mVsyncMutex; // Protects the following
479 nsecs_t mPhaseOffset;
480 bool mEnabled;
481};
482
483class InjectVSyncSource : public VSyncSource {
484public:
485 InjectVSyncSource() {}
486
487 virtual ~InjectVSyncSource() {}
488
489 virtual void setCallback(const sp<VSyncSource::Callback>& callback) {
490 std::lock_guard<std::mutex> lock(mCallbackMutex);
491 mCallback = callback;
492 }
493
494 virtual void onInjectSyncEvent(nsecs_t when) {
495 std::lock_guard<std::mutex> lock(mCallbackMutex);
496 mCallback->onVSyncEvent(when);
497 }
498
499 virtual void setVSyncEnabled(bool) {}
500 virtual void setPhaseOffset(nsecs_t) {}
501
502private:
503 std::mutex mCallbackMutex; // Protects the following
504 sp<VSyncSource::Callback> mCallback;
505};
506
Wei Wangf9b05ee2017-07-19 20:59:39 -0700507// Do not call property_set on main thread which will be blocked by init
508// Use StartPropertySetThread instead.
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000509void SurfaceFlinger::init() {
510 ALOGI( "SurfaceFlinger's main thread ready to run. "
511 "Initializing graphics H/W...");
512
513 Mutex::Autolock _l(mStateLock);
514
515 // initialize EGL for the default display
516 mEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
517 eglInitialize(mEGLDisplay, NULL, NULL);
518
519 // start the EventThread
520 sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,
521 vsyncPhaseOffsetNs, true, "app");
522 mEventThread = new EventThread(vsyncSrc, *this, false);
523 sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,
524 sfVsyncPhaseOffsetNs, true, "sf");
525 mSFEventThread = new EventThread(sfVsyncSrc, *this, true);
526 mEventQueue.setEventThread(mSFEventThread);
527
Tim Murray22752852017-05-04 13:38:49 -0700528 // set EventThread and SFEventThread to SCHED_FIFO to minimize jitter
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000529 struct sched_param param = {0};
530 param.sched_priority = 2;
531 if (sched_setscheduler(mSFEventThread->getTid(), SCHED_FIFO, &param) != 0) {
532 ALOGE("Couldn't set SCHED_FIFO for SFEventThread");
533 }
Tim Murray22752852017-05-04 13:38:49 -0700534 if (sched_setscheduler(mEventThread->getTid(), SCHED_FIFO, &param) != 0) {
535 ALOGE("Couldn't set SCHED_FIFO for EventThread");
536 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000537
538 // Initialize the H/W composer object. There may or may not be an
539 // actual hardware composer underneath.
Steven Thomasb02664d2017-07-26 18:48:28 -0700540 mHwc.reset(new HWComposer(this,
541 *static_cast<HWComposer::EventHandler *>(this)));
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000542
543 // get a RenderEngine for the given display / config (can't fail)
Kalle Raitabbdcf1f2017-05-22 15:47:46 -0700544 mRenderEngine = RenderEngine::create(mEGLDisplay,
545 mHwc->getVisualID(), 0);
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000546
547 // retrieve the EGL context that was selected/created
548 mEGLContext = mRenderEngine->getEGLContext();
549
550 LOG_ALWAYS_FATAL_IF(mEGLContext == EGL_NO_CONTEXT,
551 "couldn't create EGLContext");
552
553 // initialize our non-virtual displays
554 for (size_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {
555 DisplayDevice::DisplayType type((DisplayDevice::DisplayType)i);
556 // set-up the displays that are already connected
557 if (mHwc->isConnected(i) || type==DisplayDevice::DISPLAY_PRIMARY) {
558 // All non-virtual displays are currently considered secure.
559 bool isSecure = true;
560 createBuiltinDisplayLocked(type);
561 wp<IBinder> token = mBuiltinDisplays[i];
562
563 sp<IGraphicBufferProducer> producer;
564 sp<IGraphicBufferConsumer> consumer;
Mathias Agopian0556d792017-03-22 15:49:32 -0700565 BufferQueue::createBufferQueue(&producer, &consumer);
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000566
567 sp<FramebufferSurface> fbs = new FramebufferSurface(*mHwc, i,
568 consumer);
569 int32_t hwcId = allocateHwcDisplayId(type);
570 sp<DisplayDevice> hw = new DisplayDevice(this,
571 type, hwcId, mHwc->getFormat(hwcId), isSecure, token,
572 fbs, producer,
Courtney Goeltzenleuchter4f20f9c2017-04-06 08:18:34 -0600573 mRenderEngine->getEGLConfig(), false);
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000574 if (i > DisplayDevice::DISPLAY_PRIMARY) {
575 // FIXME: currently we don't get blank/unblank requests
576 // for displays other than the main display, so we always
577 // assume a connected display is unblanked.
578 ALOGD("marking display %zu as acquired/unblanked", i);
579 hw->setPowerMode(HWC_POWER_MODE_NORMAL);
580 }
581 mDisplays.add(token, hw);
582 }
583 }
584
585 // make the GLContext current so that we can create textures when creating Layers
586 // (which may happens before we render something)
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700587 getDefaultDisplayDeviceLocked()->makeCurrent(mEGLDisplay, mEGLContext);
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000588
589 mEventControlThread = new EventControlThread(this);
590 mEventControlThread->run("EventControl", PRIORITY_URGENT_DISPLAY);
591
592 // set a fake vsync period if there is no HWComposer
593 if (mHwc->initCheck() != NO_ERROR) {
594 mPrimaryDispSync.setPeriod(16666667);
595 }
596
597 // initialize our drawing state
598 mDrawingState = mCurrentState;
599
600 // set initial conditions (e.g. unblank default device)
601 initializeDisplays();
602
603 mRenderEngine->primeCache();
604
Wei Wangf9b05ee2017-07-19 20:59:39 -0700605 // Inform native graphics APIs that the present timestamp is NOT supported:
606 mStartPropertySetThread = new StartPropertySetThread(false);
607 if (mStartPropertySetThread->Start() != NO_ERROR) {
608 ALOGE("Run StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800609 }
610
611 ALOGV("Done initializing");
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000612}
613
614int32_t SurfaceFlinger::allocateHwcDisplayId(DisplayDevice::DisplayType type) {
615 return (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) ?
616 type : mHwc->allocateDisplayId();
617}
618
619void SurfaceFlinger::startBootAnim() {
Wei Wangb254fa32017-01-31 17:43:23 -0800620 // Start boot animation service by setting a property mailbox
621 // if property setting thread is already running, Start() will be just a NOP
Wei Wangf9b05ee2017-07-19 20:59:39 -0700622 mStartPropertySetThread->Start();
Wei Wangb254fa32017-01-31 17:43:23 -0800623 // Wait until property was set
Wei Wangf9b05ee2017-07-19 20:59:39 -0700624 if (mStartPropertySetThread->join() != NO_ERROR) {
625 ALOGE("Join StartPropertySetThread failed!");
Wei Wangb254fa32017-01-31 17:43:23 -0800626 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000627}
628
629size_t SurfaceFlinger::getMaxTextureSize() const {
630 return mRenderEngine->getMaxTextureSize();
631}
632
633size_t SurfaceFlinger::getMaxViewportDims() const {
634 return mRenderEngine->getMaxViewportDims();
635}
636
637// ----------------------------------------------------------------------------
638
639bool SurfaceFlinger::authenticateSurfaceTexture(
640 const sp<IGraphicBufferProducer>& bufferProducer) const {
641 Mutex::Autolock _l(mStateLock);
Robert Carr0d480722017-01-10 16:42:54 -0800642 return authenticateSurfaceTextureLocked(bufferProducer);
643}
644
645bool SurfaceFlinger::authenticateSurfaceTextureLocked(
646 const sp<IGraphicBufferProducer>& bufferProducer) const {
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000647 sp<IBinder> surfaceTextureBinder(IInterface::asBinder(bufferProducer));
648 return mGraphicBufferProducerList.indexOf(surfaceTextureBinder) >= 0;
649}
650
Brian Anderson6b376712017-04-04 10:51:39 -0700651status_t SurfaceFlinger::getSupportedFrameTimestamps(
652 std::vector<FrameEvent>* outSupported) const {
653 *outSupported = {
654 FrameEvent::REQUESTED_PRESENT,
655 FrameEvent::ACQUIRE,
656 FrameEvent::LATCH,
657 FrameEvent::FIRST_REFRESH_START,
658 FrameEvent::LAST_REFRESH_START,
659 FrameEvent::GPU_COMPOSITION_DONE,
660 FrameEvent::DEQUEUE_READY,
661 FrameEvent::RELEASE,
662 };
663 return NO_ERROR;
664}
665
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000666status_t SurfaceFlinger::getDisplayConfigs(const sp<IBinder>& display,
667 Vector<DisplayInfo>* configs) {
668 if ((configs == NULL) || (display.get() == NULL)) {
669 return BAD_VALUE;
670 }
671
672 int32_t type = getDisplayType(display);
673 if (type < 0) return type;
674
675 // TODO: Not sure if display density should handled by SF any longer
676 class Density {
677 static int getDensityFromProperty(char const* propName) {
678 char property[PROPERTY_VALUE_MAX];
679 int density = 0;
680 if (property_get(propName, property, NULL) > 0) {
681 density = atoi(property);
682 }
683 return density;
684 }
685 public:
686 static int getEmuDensity() {
687 return getDensityFromProperty("qemu.sf.lcd_density"); }
688 static int getBuildDensity() {
689 return getDensityFromProperty("ro.sf.lcd_density"); }
690 };
691
692 configs->clear();
693
694 const Vector<HWComposer::DisplayConfig>& hwConfigs =
695 getHwComposer().getConfigs(type);
696 for (size_t c = 0; c < hwConfigs.size(); ++c) {
697 const HWComposer::DisplayConfig& hwConfig = hwConfigs[c];
698 DisplayInfo info = DisplayInfo();
699
700 float xdpi = hwConfig.xdpi;
701 float ydpi = hwConfig.ydpi;
702
703 if (type == DisplayDevice::DISPLAY_PRIMARY) {
704 // The density of the device is provided by a build property
705 float density = Density::getBuildDensity() / 160.0f;
706 if (density == 0) {
707 // the build doesn't provide a density -- this is wrong!
708 // use xdpi instead
709 ALOGE("ro.sf.lcd_density must be defined as a build property");
710 density = xdpi / 160.0f;
711 }
712 if (Density::getEmuDensity()) {
713 // if "qemu.sf.lcd_density" is specified, it overrides everything
714 xdpi = ydpi = density = Density::getEmuDensity();
715 density /= 160.0f;
716 }
717 info.density = density;
718
719 // TODO: this needs to go away (currently needed only by webkit)
720 sp<const DisplayDevice> hw(getDefaultDisplayDevice());
721 info.orientation = hw->getOrientation();
722 } else {
723 // TODO: where should this value come from?
724 static const int TV_DENSITY = 213;
725 info.density = TV_DENSITY / 160.0f;
726 info.orientation = 0;
727 }
728
729 info.w = hwConfig.width;
730 info.h = hwConfig.height;
731 info.xdpi = xdpi;
732 info.ydpi = ydpi;
733 info.fps = float(1e9 / hwConfig.refresh);
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800734 info.appVsyncOffset = vsyncPhaseOffsetNs;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000735
736 // This is how far in advance a buffer must be queued for
737 // presentation at a given time. If you want a buffer to appear
738 // on the screen at time N, you must submit the buffer before
739 // (N - presentationDeadline).
740 //
741 // Normally it's one full refresh period (to give SF a chance to
742 // latch the buffer), but this can be reduced by configuring a
743 // DispSync offset. Any additional delays introduced by the hardware
744 // composer or panel must be accounted for here.
745 //
746 // We add an additional 1ms to allow for processing time and
747 // differences between the ideal and actual refresh rate.
748 info.presentationDeadline =
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800749 hwConfig.refresh - sfVsyncPhaseOffsetNs + 1000000;
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000750
751 // All non-virtual displays are currently considered secure.
752 info.secure = true;
753
754 configs->push_back(info);
755 }
756
757 return NO_ERROR;
758}
759
760status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>& /* display */,
761 DisplayStatInfo* stats) {
762 if (stats == NULL) {
763 return BAD_VALUE;
764 }
765
766 // FIXME for now we always return stats for the primary display
767 memset(stats, 0, sizeof(*stats));
768 stats->vsyncTime = mPrimaryDispSync.computeNextRefresh(0);
769 stats->vsyncPeriod = mPrimaryDispSync.getPeriod();
770 return NO_ERROR;
771}
772
773int SurfaceFlinger::getActiveConfig(const sp<IBinder>& display) {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700774 sp<const DisplayDevice> device(getDisplayDevice(display));
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000775 if (device != NULL) {
776 return device->getActiveConfig();
777 }
778 return BAD_VALUE;
779}
780
781void SurfaceFlinger::setActiveConfigInternal(const sp<DisplayDevice>& hw, int mode) {
782 ALOGD("Set active config mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(),
783 this);
784 int32_t type = hw->getDisplayType();
785 int currentMode = hw->getActiveConfig();
786
787 if (mode == currentMode) {
788 ALOGD("Screen type=%d is already mode=%d", hw->getDisplayType(), mode);
789 return;
790 }
791
792 if (type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
793 ALOGW("Trying to set config for virtual display");
794 return;
795 }
796
797 hw->setActiveConfig(mode);
798 getHwComposer().setActiveConfig(type, mode);
799}
800
801status_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& display, int mode) {
802 class MessageSetActiveConfig: public MessageBase {
803 SurfaceFlinger& mFlinger;
804 sp<IBinder> mDisplay;
805 int mMode;
806 public:
807 MessageSetActiveConfig(SurfaceFlinger& flinger, const sp<IBinder>& disp,
808 int mode) :
809 mFlinger(flinger), mDisplay(disp) { mMode = mode; }
810 virtual bool handler() {
811 Vector<DisplayInfo> configs;
812 mFlinger.getDisplayConfigs(mDisplay, &configs);
813 if (mMode < 0 || mMode >= static_cast<int>(configs.size())) {
814 ALOGE("Attempt to set active config = %d for display with %zu configs",
815 mMode, configs.size());
816 }
817 sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
818 if (hw == NULL) {
819 ALOGE("Attempt to set active config = %d for null display %p",
820 mMode, mDisplay.get());
821 } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) {
822 ALOGW("Attempt to set active config = %d for virtual display",
823 mMode);
824 } else {
825 mFlinger.setActiveConfigInternal(hw, mMode);
826 }
827 return true;
828 }
829 };
830 sp<MessageBase> msg = new MessageSetActiveConfig(*this, display, mode);
831 postMessageSync(msg);
832 return NO_ERROR;
833}
834
835status_t SurfaceFlinger::getDisplayColorModes(const sp<IBinder>& display,
836 Vector<android_color_mode_t>* outColorModes) {
837 if (outColorModes == nullptr || display.get() == nullptr) {
838 return BAD_VALUE;
839 }
840
841 int32_t type = getDisplayType(display);
842 if (type < 0) return type;
843
844 std::set<android_color_mode_t> colorModes;
845 for (const HWComposer::DisplayConfig& hwConfig : getHwComposer().getConfigs(type)) {
846 colorModes.insert(hwConfig.colorMode);
847 }
848
849 outColorModes->clear();
850 std::copy(colorModes.cbegin(), colorModes.cend(), std::back_inserter(*outColorModes));
851
852 return NO_ERROR;
853}
854
855android_color_mode_t SurfaceFlinger::getActiveColorMode(const sp<IBinder>& display) {
856 if (display.get() == nullptr) return static_cast<android_color_mode_t>(BAD_VALUE);
857
858 int32_t type = getDisplayType(display);
859 if (type < 0) return static_cast<android_color_mode_t>(type);
860
861 return getHwComposer().getColorMode(type);
862}
863
864status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& display,
865 android_color_mode_t colorMode) {
866 if (display.get() == nullptr || colorMode < 0) {
867 return BAD_VALUE;
868 }
869
870 int32_t type = getDisplayType(display);
871 if (type < 0) return type;
872 const Vector<HWComposer::DisplayConfig>& hwConfigs = getHwComposer().getConfigs(type);
873 HWComposer::DisplayConfig desiredConfig = hwConfigs[getHwComposer().getCurrentConfig(type)];
874 desiredConfig.colorMode = colorMode;
875 for (size_t c = 0; c < hwConfigs.size(); ++c) {
876 const HWComposer::DisplayConfig config = hwConfigs[c];
877 if (config == desiredConfig) {
878 return setActiveConfig(display, c);
879 }
880 }
881 return BAD_VALUE;
882}
883
884status_t SurfaceFlinger::clearAnimationFrameStats() {
885 Mutex::Autolock _l(mStateLock);
886 mAnimFrameTracker.clearStats();
887 return NO_ERROR;
888}
889
890status_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const {
891 Mutex::Autolock _l(mStateLock);
892 mAnimFrameTracker.getStats(outStats);
893 return NO_ERROR;
894}
895
896status_t SurfaceFlinger::getHdrCapabilities(const sp<IBinder>& /*display*/,
897 HdrCapabilities* outCapabilities) const {
898 // HWC1 does not provide HDR capabilities
899 *outCapabilities = HdrCapabilities();
900 return NO_ERROR;
901}
902
903status_t SurfaceFlinger::enableVSyncInjections(bool enable) {
904 if (enable == mInjectVSyncs) {
905 return NO_ERROR;
906 }
907
908 if (enable) {
909 mInjectVSyncs = enable;
910 ALOGV("VSync Injections enabled");
911 if (mVSyncInjector.get() == nullptr) {
912 mVSyncInjector = new InjectVSyncSource();
913 mInjectorEventThread = new EventThread(mVSyncInjector, *this, false);
914 }
915 mEventQueue.setEventThread(mInjectorEventThread);
916 } else {
917 mInjectVSyncs = enable;
918 ALOGV("VSync Injections disabled");
919 mEventQueue.setEventThread(mSFEventThread);
920 mVSyncInjector.clear();
921 }
922 return NO_ERROR;
923}
924
925status_t SurfaceFlinger::injectVSync(nsecs_t when) {
926 if (!mInjectVSyncs) {
927 ALOGE("VSync Injections not enabled");
928 return BAD_VALUE;
929 }
930 if (mInjectVSyncs && mInjectorEventThread.get() != nullptr) {
931 ALOGV("Injecting VSync inside SurfaceFlinger");
932 mVSyncInjector->onInjectSyncEvent(when);
933 }
934 return NO_ERROR;
935}
936
Kalle Raitaa099a242017-01-11 11:17:29 -0800937status_t SurfaceFlinger::getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const {
938 IPCThreadState* ipc = IPCThreadState::self();
939 const int pid = ipc->getCallingPid();
940 const int uid = ipc->getCallingUid();
941 if ((uid != AID_SHELL) &&
942 !PermissionCache::checkPermission(sDump, pid, uid)) {
943 ALOGE("Layer debug info permission denied for pid=%d, uid=%d", pid, uid);
944 return PERMISSION_DENIED;
945 }
946
947 // Try to acquire a lock for 1s, fail gracefully
948 status_t err = mStateLock.timedLock(s2ns(1));
949 bool locked = (err == NO_ERROR);
950 if (!locked) {
951 ALOGE("LayerDebugInfo: SurfaceFlinger unresponsive (%s [%d]) - exit", strerror(-err), err);
952 return TIMED_OUT;
953 }
954
955 outLayers->clear();
956 mCurrentState.traverseInZOrder([&](Layer* layer) {
957 outLayers->push_back(layer->getLayerDebugInfo());
958 });
959
960 mStateLock.unlock();
961
962 return NO_ERROR;
963}
964
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000965// ----------------------------------------------------------------------------
966
Jorim Jaggiaaef0982017-06-08 23:55:29 -0700967sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection(
968 ISurfaceComposer::VsyncSource vsyncSource) {
969 if (vsyncSource == eVsyncSourceSurfaceFlinger) {
970 return mSFEventThread->createEventConnection();
971 } else {
972 return mEventThread->createEventConnection();
973 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +0000974}
975
976// ----------------------------------------------------------------------------
977
978void SurfaceFlinger::waitForEvent() {
979 mEventQueue.waitMessage();
980}
981
982void SurfaceFlinger::signalTransaction() {
983 mEventQueue.invalidate();
984}
985
986void SurfaceFlinger::signalLayerUpdate() {
987 mEventQueue.invalidate();
988}
989
990void SurfaceFlinger::signalRefresh() {
991 mEventQueue.refresh();
992}
993
994status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,
995 nsecs_t reltime, uint32_t /* flags */) {
996 return mEventQueue.postMessage(msg, reltime);
997}
998
999status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
1000 nsecs_t reltime, uint32_t /* flags */) {
1001 status_t res = mEventQueue.postMessage(msg, reltime);
1002 if (res == NO_ERROR) {
1003 msg->wait();
1004 }
1005 return res;
1006}
1007
1008void SurfaceFlinger::run() {
1009 do {
1010 waitForEvent();
1011 } while (true);
1012}
1013
1014void SurfaceFlinger::enableHardwareVsync() {
1015 Mutex::Autolock _l(mHWVsyncLock);
1016 if (!mPrimaryHWVsyncEnabled && mHWVsyncAvailable) {
1017 mPrimaryDispSync.beginResync();
1018 //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true);
1019 mEventControlThread->setVsyncEnabled(true);
1020 mPrimaryHWVsyncEnabled = true;
1021 }
1022}
1023
1024void SurfaceFlinger::resyncToHardwareVsync(bool makeAvailable) {
1025 Mutex::Autolock _l(mHWVsyncLock);
1026
1027 if (makeAvailable) {
1028 mHWVsyncAvailable = true;
1029 } else if (!mHWVsyncAvailable) {
1030 // Hardware vsync is not currently available, so abort the resync
1031 // attempt for now
1032 return;
1033 }
1034
1035 const nsecs_t period =
1036 getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
1037
1038 mPrimaryDispSync.reset();
1039 mPrimaryDispSync.setPeriod(period);
1040
1041 if (!mPrimaryHWVsyncEnabled) {
1042 mPrimaryDispSync.beginResync();
1043 //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true);
1044 mEventControlThread->setVsyncEnabled(true);
1045 mPrimaryHWVsyncEnabled = true;
1046 }
1047}
1048
1049void SurfaceFlinger::disableHardwareVsync(bool makeUnavailable) {
1050 Mutex::Autolock _l(mHWVsyncLock);
1051 if (mPrimaryHWVsyncEnabled) {
1052 //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, false);
1053 mEventControlThread->setVsyncEnabled(false);
1054 mPrimaryDispSync.endResync();
1055 mPrimaryHWVsyncEnabled = false;
1056 }
1057 if (makeUnavailable) {
1058 mHWVsyncAvailable = false;
1059 }
1060}
1061
1062void SurfaceFlinger::resyncWithRateLimit() {
1063 static constexpr nsecs_t kIgnoreDelay = ms2ns(500);
1064 if (systemTime() - mLastSwapTime > kIgnoreDelay) {
1065 resyncToHardwareVsync(false);
1066 }
1067}
1068
Steven Thomas3cfac282017-02-06 12:29:30 -08001069void SurfaceFlinger::onVSyncReceived(HWComposer* /*composer*/, int type,
1070 nsecs_t timestamp) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001071 bool needsHwVsync = false;
1072
1073 { // Scope for the lock
1074 Mutex::Autolock _l(mHWVsyncLock);
1075 if (type == 0 && mPrimaryHWVsyncEnabled) {
1076 needsHwVsync = mPrimaryDispSync.addResyncSample(timestamp);
1077 }
1078 }
1079
1080 if (needsHwVsync) {
1081 enableHardwareVsync();
1082 } else {
1083 disableHardwareVsync(false);
1084 }
1085}
1086
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001087void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
Brian Andersond0010582017-03-07 13:20:31 -08001088 std::lock_guard<std::mutex> lock(mCompositorTimingLock);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001089 *compositorTiming = mCompositorTiming;
1090}
1091
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001092void SurfaceFlinger::onHotplugReceived(HWComposer* /*composer*/, int type, bool connected) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001093 if (mEventThread == NULL) {
1094 // This is a temporary workaround for b/7145521. A non-null pointer
1095 // does not mean EventThread has finished initializing, so this
1096 // is not a correct fix.
1097 ALOGW("WARNING: EventThread not started, ignoring hotplug");
1098 return;
1099 }
1100
1101 if (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
1102 Mutex::Autolock _l(mStateLock);
1103 if (connected) {
1104 createBuiltinDisplayLocked((DisplayDevice::DisplayType)type);
1105 } else {
1106 mCurrentState.displays.removeItem(mBuiltinDisplays[type]);
1107 mBuiltinDisplays[type].clear();
1108 }
1109 setTransactionFlags(eDisplayTransactionNeeded);
1110
1111 // Defer EventThread notification until SF has updated mDisplays.
1112 }
1113}
1114
Steven Thomas3cfac282017-02-06 12:29:30 -08001115void SurfaceFlinger::onInvalidateReceived(HWComposer* /*composer*/) {
1116 repaintEverything();
1117}
1118
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001119void SurfaceFlinger::eventControl(int disp, int event, int enabled) {
1120 ATRACE_CALL();
1121 getHwComposer().eventControl(disp, event, enabled);
1122}
1123
1124void SurfaceFlinger::onMessageReceived(int32_t what) {
1125 ATRACE_CALL();
1126 switch (what) {
1127 case MessageQueue::INVALIDATE: {
1128 bool refreshNeeded = handleMessageTransaction();
1129 refreshNeeded |= handleMessageInvalidate();
1130 refreshNeeded |= mRepaintEverything;
1131 if (refreshNeeded) {
1132 // Signal a refresh if a transaction modified the window state,
1133 // a new buffer was latched, or if HWC has requested a full
1134 // repaint
1135 signalRefresh();
1136 }
1137 break;
1138 }
1139 case MessageQueue::REFRESH: {
1140 handleMessageRefresh();
1141 break;
1142 }
1143 }
1144}
1145
1146bool SurfaceFlinger::handleMessageTransaction() {
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08001147 uint32_t transactionFlags = peekTransactionFlags();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001148 if (transactionFlags) {
1149 handleTransaction(transactionFlags);
1150 return true;
1151 }
1152 return false;
1153}
1154
1155bool SurfaceFlinger::handleMessageInvalidate() {
1156 ATRACE_CALL();
1157 return handlePageFlip();
1158}
1159
1160void SurfaceFlinger::handleMessageRefresh() {
1161 ATRACE_CALL();
1162
1163 nsecs_t refreshStartTime = systemTime(SYSTEM_TIME_MONOTONIC);
1164
Brian Andersond6927fb2016-07-23 23:37:30 -07001165 preComposition(refreshStartTime);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001166 rebuildLayerStacks();
1167 setUpHWComposer();
1168 doDebugFlashRegions();
1169 doComposition();
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001170 postComposition(refreshStartTime);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001171}
1172
1173void SurfaceFlinger::doDebugFlashRegions()
1174{
1175 // is debugging enabled
1176 if (CC_LIKELY(!mDebugRegion))
1177 return;
1178
1179 const bool repaintEverything = mRepaintEverything;
1180 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1181 const sp<DisplayDevice>& hw(mDisplays[dpy]);
1182 if (hw->isDisplayOn()) {
1183 // transform the dirty region into this screen's coordinate space
1184 const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
1185 if (!dirtyRegion.isEmpty()) {
1186 // redraw the whole screen
1187 doComposeSurfaces(hw, Region(hw->bounds()));
1188
1189 // and draw the dirty region
1190 const int32_t height = hw->getHeight();
1191 RenderEngine& engine(getRenderEngine());
1192 engine.fillRegionWithColor(dirtyRegion, height, 1, 0, 1, 1);
1193
1194 hw->compositionComplete();
1195 hw->swapBuffers(getHwComposer());
1196 }
1197 }
1198 }
1199
1200 postFramebuffer();
1201
1202 if (mDebugRegion > 1) {
1203 usleep(mDebugRegion * 1000);
1204 }
1205
1206 HWComposer& hwc(getHwComposer());
1207 if (hwc.initCheck() == NO_ERROR) {
1208 status_t err = hwc.prepare();
1209 ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
1210 }
1211}
1212
Brian Andersond6927fb2016-07-23 23:37:30 -07001213void SurfaceFlinger::preComposition(nsecs_t refreshStartTime)
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001214{
1215 bool needExtraInvalidate = false;
Robert Carr2047fae2016-11-28 14:09:09 -08001216 mDrawingState.traverseInZOrder([&](Layer* layer) {
1217 if (layer->onPreComposition(refreshStartTime)) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001218 needExtraInvalidate = true;
1219 }
Robert Carr2047fae2016-11-28 14:09:09 -08001220 });
1221
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001222 if (needExtraInvalidate) {
1223 signalLayerUpdate();
1224 }
1225}
1226
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001227void SurfaceFlinger::updateCompositorTiming(
1228 nsecs_t vsyncPhase, nsecs_t vsyncInterval, nsecs_t compositeTime,
1229 std::shared_ptr<FenceTime>& presentFenceTime) {
1230 // Update queue of past composite+present times and determine the
1231 // most recently known composite to present latency.
1232 mCompositePresentTimes.push({compositeTime, presentFenceTime});
1233 nsecs_t compositeToPresentLatency = -1;
1234 while (!mCompositePresentTimes.empty()) {
1235 CompositePresentTime& cpt = mCompositePresentTimes.front();
1236 // Cached values should have been updated before calling this method,
1237 // which helps avoid duplicate syscalls.
1238 nsecs_t displayTime = cpt.display->getCachedSignalTime();
1239 if (displayTime == Fence::SIGNAL_TIME_PENDING) {
1240 break;
1241 }
1242 compositeToPresentLatency = displayTime - cpt.composite;
1243 mCompositePresentTimes.pop();
1244 }
1245
1246 // Don't let mCompositePresentTimes grow unbounded, just in case.
1247 while (mCompositePresentTimes.size() > 16) {
1248 mCompositePresentTimes.pop();
1249 }
1250
Brian Andersond0010582017-03-07 13:20:31 -08001251 setCompositorTimingSnapped(
1252 vsyncPhase, vsyncInterval, compositeToPresentLatency);
1253}
1254
1255void SurfaceFlinger::setCompositorTimingSnapped(nsecs_t vsyncPhase,
1256 nsecs_t vsyncInterval, nsecs_t compositeToPresentLatency) {
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001257 // Integer division and modulo round toward 0 not -inf, so we need to
1258 // treat negative and positive offsets differently.
Brian Andersond0010582017-03-07 13:20:31 -08001259 nsecs_t idealLatency = (sfVsyncPhaseOffsetNs > 0) ?
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001260 (vsyncInterval - (sfVsyncPhaseOffsetNs % vsyncInterval)) :
1261 ((-sfVsyncPhaseOffsetNs) % vsyncInterval);
1262
Brian Andersond0010582017-03-07 13:20:31 -08001263 // Just in case sfVsyncPhaseOffsetNs == -vsyncInterval.
1264 if (idealLatency <= 0) {
1265 idealLatency = vsyncInterval;
1266 }
1267
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001268 // Snap the latency to a value that removes scheduling jitter from the
1269 // composition and present times, which often have >1ms of jitter.
1270 // Reducing jitter is important if an app attempts to extrapolate
1271 // something (such as user input) to an accurate diasplay time.
1272 // Snapping also allows an app to precisely calculate sfVsyncPhaseOffsetNs
1273 // with (presentLatency % interval).
Brian Andersond0010582017-03-07 13:20:31 -08001274 nsecs_t bias = vsyncInterval / 2;
1275 int64_t extraVsyncs =
1276 (compositeToPresentLatency - idealLatency + bias) / vsyncInterval;
1277 nsecs_t snappedCompositeToPresentLatency = (extraVsyncs > 0) ?
1278 idealLatency + (extraVsyncs * vsyncInterval) : idealLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001279
Brian Andersond0010582017-03-07 13:20:31 -08001280 std::lock_guard<std::mutex> lock(mCompositorTimingLock);
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001281 mCompositorTiming.deadline = vsyncPhase - idealLatency;
1282 mCompositorTiming.interval = vsyncInterval;
Brian Andersond0010582017-03-07 13:20:31 -08001283 mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001284}
1285
1286void SurfaceFlinger::postComposition(nsecs_t refreshStartTime)
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001287{
Brian Andersond6927fb2016-07-23 23:37:30 -07001288 const HWComposer& hwc = getHwComposer();
1289 const sp<const DisplayDevice> hw(getDefaultDisplayDevice());
1290
Brian Andersonfbc80ae2017-05-26 16:23:54 -07001291 mGlCompositionDoneTimeline.updateSignalTimes();
Brian Anderson3d4039d2016-09-23 16:31:30 -07001292 std::shared_ptr<FenceTime> glCompositionDoneFenceTime;
1293 if (getHwComposer().hasGlesComposition(hw->getHwcDisplayId())) {
1294 glCompositionDoneFenceTime =
1295 std::make_shared<FenceTime>(hw->getClientTargetAcquireFence());
1296 mGlCompositionDoneTimeline.push(glCompositionDoneFenceTime);
1297 } else {
1298 glCompositionDoneFenceTime = FenceTime::NO_FENCE;
1299 }
Brian Anderson3d4039d2016-09-23 16:31:30 -07001300
Brian Andersonfbc80ae2017-05-26 16:23:54 -07001301 mDisplayTimeline.updateSignalTimes();
Brian Anderson4e606e32017-03-16 15:34:57 -07001302 sp<Fence> retireFence = mHwc->getDisplayFence(HWC_DISPLAY_PRIMARY);
1303 auto retireFenceTime = std::make_shared<FenceTime>(retireFence);
Brian Anderson3d4039d2016-09-23 16:31:30 -07001304 mDisplayTimeline.push(retireFenceTime);
Brian Andersond6927fb2016-07-23 23:37:30 -07001305
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001306 nsecs_t vsyncPhase = mPrimaryDispSync.computeNextRefresh(0);
1307 nsecs_t vsyncInterval = mPrimaryDispSync.getPeriod();
1308
1309 // We use the refreshStartTime which might be sampled a little later than
1310 // when we started doing work for this frame, but that should be okay
1311 // since updateCompositorTiming has snapping logic.
1312 updateCompositorTiming(
1313 vsyncPhase, vsyncInterval, refreshStartTime, retireFenceTime);
Brian Andersond0010582017-03-07 13:20:31 -08001314 CompositorTiming compositorTiming;
1315 {
1316 std::lock_guard<std::mutex> lock(mCompositorTimingLock);
1317 compositorTiming = mCompositorTiming;
1318 }
Brian Anderson0a61b0c2016-12-07 14:55:56 -08001319
Robert Carr2047fae2016-11-28 14:09:09 -08001320 mDrawingState.traverseInZOrder([&](Layer* layer) {
Brian Anderson4e606e32017-03-16 15:34:57 -07001321 // TODO(brianderson): The retire fence is incorrectly passed in as the
1322 // present fence. Fix this if this file lives on.
Robert Carr2047fae2016-11-28 14:09:09 -08001323 bool frameLatched = layer->onPostComposition(glCompositionDoneFenceTime,
Brian Anderson4e606e32017-03-16 15:34:57 -07001324 retireFenceTime, compositorTiming);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001325 if (frameLatched) {
Robert Carr2047fae2016-11-28 14:09:09 -08001326 recordBufferingStats(layer->getName().string(),
1327 layer->getOccupancyHistory(false));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001328 }
Robert Carr2047fae2016-11-28 14:09:09 -08001329 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001330
Brian Anderson4e606e32017-03-16 15:34:57 -07001331 if (retireFence->isValid()) {
Brian Andersonfbc80ae2017-05-26 16:23:54 -07001332 if (mPrimaryDispSync.addPresentFence(retireFenceTime)) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001333 enableHardwareVsync();
1334 } else {
1335 disableHardwareVsync(false);
1336 }
1337 }
1338
Fabien Sanglardcbf153b2017-03-10 17:57:12 -08001339 if (!hasSyncFramework) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001340 if (hw->isDisplayOn()) {
1341 enableHardwareVsync();
1342 }
1343 }
1344
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001345 if (mAnimCompositionPending) {
1346 mAnimCompositionPending = false;
1347
Brian Anderson3d4039d2016-09-23 16:31:30 -07001348 if (retireFenceTime->isValid()) {
1349 mAnimFrameTracker.setActualPresentFence(std::move(retireFenceTime));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001350 } else {
1351 // The HWC doesn't support present fences, so use the refresh
1352 // timestamp instead.
1353 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY);
1354 mAnimFrameTracker.setActualPresentTime(presentTime);
1355 }
1356 mAnimFrameTracker.advanceFrame();
1357 }
1358
1359 if (hw->getPowerMode() == HWC_POWER_MODE_OFF) {
1360 return;
1361 }
1362
1363 nsecs_t currentTime = systemTime();
1364 if (mHasPoweredOff) {
1365 mHasPoweredOff = false;
1366 } else {
1367 nsecs_t period = mPrimaryDispSync.getPeriod();
1368 nsecs_t elapsedTime = currentTime - mLastSwapTime;
1369 size_t numPeriods = static_cast<size_t>(elapsedTime / period);
1370 if (numPeriods < NUM_BUCKETS - 1) {
1371 mFrameBuckets[numPeriods] += elapsedTime;
1372 } else {
1373 mFrameBuckets[NUM_BUCKETS - 1] += elapsedTime;
1374 }
1375 mTotalTime += elapsedTime;
1376 }
1377 mLastSwapTime = currentTime;
1378}
1379
1380void SurfaceFlinger::rebuildLayerStacks() {
1381 // rebuild the visible layer list per screen
1382 if (CC_UNLIKELY(mVisibleRegionsDirty)) {
1383 ATRACE_CALL();
1384 mVisibleRegionsDirty = false;
1385 invalidateHwcGeometry();
1386
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001387 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1388 Region opaqueRegion;
1389 Region dirtyRegion;
1390 Vector< sp<Layer> > layersSortedByZ;
1391 const sp<DisplayDevice>& hw(mDisplays[dpy]);
1392 const Transform& tr(hw->getTransform());
1393 const Rect bounds(hw->getBounds());
1394 if (hw->isDisplayOn()) {
Chia-I Wuab0c3192017-08-01 11:29:00 -07001395 computeVisibleRegions(hw, dirtyRegion, opaqueRegion);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001396
Robert Carr2047fae2016-11-28 14:09:09 -08001397 mDrawingState.traverseInZOrder([&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07001398 if (layer->getLayerStack() == hw->getLayerStack()) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001399 Region drawRegion(tr.transform(
1400 layer->visibleNonTransparentRegion));
1401 drawRegion.andSelf(bounds);
1402 if (!drawRegion.isEmpty()) {
1403 layersSortedByZ.add(layer);
1404 }
1405 }
Robert Carr2047fae2016-11-28 14:09:09 -08001406 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001407 }
1408 hw->setVisibleLayersSortedByZ(layersSortedByZ);
1409 hw->undefinedRegion.set(bounds);
1410 hw->undefinedRegion.subtractSelf(tr.transform(opaqueRegion));
1411 hw->dirtyRegion.orSelf(dirtyRegion);
1412 }
1413 }
1414}
1415
1416void SurfaceFlinger::setUpHWComposer() {
1417 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1418 bool dirty = !mDisplays[dpy]->getDirtyRegion(false).isEmpty();
1419 bool empty = mDisplays[dpy]->getVisibleLayersSortedByZ().size() == 0;
1420 bool wasEmpty = !mDisplays[dpy]->lastCompositionHadVisibleLayers;
1421
1422 // If nothing has changed (!dirty), don't recompose.
1423 // If something changed, but we don't currently have any visible layers,
1424 // and didn't when we last did a composition, then skip it this time.
1425 // The second rule does two things:
1426 // - When all layers are removed from a display, we'll emit one black
1427 // frame, then nothing more until we get new layers.
1428 // - When a display is created with a private layer stack, we won't
1429 // emit any black frames until a layer is added to the layer stack.
1430 bool mustRecompose = dirty && !(empty && wasEmpty);
1431
1432 ALOGV_IF(mDisplays[dpy]->getDisplayType() == DisplayDevice::DISPLAY_VIRTUAL,
1433 "dpy[%zu]: %s composition (%sdirty %sempty %swasEmpty)", dpy,
1434 mustRecompose ? "doing" : "skipping",
1435 dirty ? "+" : "-",
1436 empty ? "+" : "-",
1437 wasEmpty ? "+" : "-");
1438
1439 mDisplays[dpy]->beginFrame(mustRecompose);
1440
1441 if (mustRecompose) {
1442 mDisplays[dpy]->lastCompositionHadVisibleLayers = !empty;
1443 }
1444 }
1445
1446 HWComposer& hwc(getHwComposer());
1447 if (hwc.initCheck() == NO_ERROR) {
1448 // build the h/w work list
1449 if (CC_UNLIKELY(mHwWorkListDirty)) {
1450 mHwWorkListDirty = false;
1451 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1452 sp<const DisplayDevice> hw(mDisplays[dpy]);
1453 const int32_t id = hw->getHwcDisplayId();
1454 if (id >= 0) {
1455 const Vector< sp<Layer> >& currentLayers(
1456 hw->getVisibleLayersSortedByZ());
1457 const size_t count = currentLayers.size();
1458 if (hwc.createWorkList(id, count) == NO_ERROR) {
1459 HWComposer::LayerListIterator cur = hwc.begin(id);
1460 const HWComposer::LayerListIterator end = hwc.end(id);
1461 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1462 const sp<Layer>& layer(currentLayers[i]);
1463 layer->setGeometry(hw, *cur);
1464 if (mDebugDisableHWC || mDebugRegion || mDaltonize || mHasColorMatrix) {
1465 cur->setSkip(true);
1466 }
1467 }
1468 }
1469 }
1470 }
1471 }
1472
1473 // set the per-frame data
1474 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1475 sp<const DisplayDevice> hw(mDisplays[dpy]);
1476 const int32_t id = hw->getHwcDisplayId();
1477 if (id >= 0) {
1478 const Vector< sp<Layer> >& currentLayers(
1479 hw->getVisibleLayersSortedByZ());
1480 const size_t count = currentLayers.size();
1481 HWComposer::LayerListIterator cur = hwc.begin(id);
1482 const HWComposer::LayerListIterator end = hwc.end(id);
1483 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1484 /*
1485 * update the per-frame h/w composer data for each layer
1486 * and build the transparent region of the FB
1487 */
1488 const sp<Layer>& layer(currentLayers[i]);
1489 layer->setPerFrameData(hw, *cur);
1490 }
1491 }
1492 }
1493
1494 // If possible, attempt to use the cursor overlay on each display.
1495 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1496 sp<const DisplayDevice> hw(mDisplays[dpy]);
1497 const int32_t id = hw->getHwcDisplayId();
1498 if (id >= 0) {
1499 const Vector< sp<Layer> >& currentLayers(
1500 hw->getVisibleLayersSortedByZ());
1501 const size_t count = currentLayers.size();
1502 HWComposer::LayerListIterator cur = hwc.begin(id);
1503 const HWComposer::LayerListIterator end = hwc.end(id);
1504 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1505 const sp<Layer>& layer(currentLayers[i]);
1506 if (layer->isPotentialCursor()) {
1507 cur->setIsCursorLayerHint();
1508 break;
1509 }
1510 }
1511 }
1512 }
1513
1514 status_t err = hwc.prepare();
1515 ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
1516
1517 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1518 sp<const DisplayDevice> hw(mDisplays[dpy]);
1519 hw->prepareFrame(hwc);
1520 }
1521 }
1522}
1523
1524void SurfaceFlinger::doComposition() {
1525 ATRACE_CALL();
1526 const bool repaintEverything = android_atomic_and(0, &mRepaintEverything);
1527 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1528 const sp<DisplayDevice>& hw(mDisplays[dpy]);
1529 if (hw->isDisplayOn()) {
1530 // transform the dirty region into this screen's coordinate space
1531 const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
1532
1533 // repaint the framebuffer (if needed)
1534 doDisplayComposition(hw, dirtyRegion);
1535
1536 hw->dirtyRegion.clear();
1537 hw->flip(hw->swapRegion);
1538 hw->swapRegion.clear();
1539 }
1540 // inform the h/w that we're done compositing
1541 hw->compositionComplete();
1542 }
1543 postFramebuffer();
1544}
1545
1546void SurfaceFlinger::postFramebuffer()
1547{
1548 ATRACE_CALL();
1549
1550 const nsecs_t now = systemTime();
1551 mDebugInSwapBuffers = now;
1552
1553 HWComposer& hwc(getHwComposer());
1554 if (hwc.initCheck() == NO_ERROR) {
1555 if (!hwc.supportsFramebufferTarget()) {
1556 // EGL spec says:
1557 // "surface must be bound to the calling thread's current context,
1558 // for the current rendering API."
1559 getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
1560 }
1561 hwc.commit();
1562 }
1563
1564 // make the default display current because the VirtualDisplayDevice code cannot
1565 // deal with dequeueBuffer() being called outside of the composition loop; however
1566 // the code below can call glFlush() which is allowed (and does in some case) call
1567 // dequeueBuffer().
1568 getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
1569
1570 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1571 sp<const DisplayDevice> hw(mDisplays[dpy]);
1572 const Vector< sp<Layer> >& currentLayers(hw->getVisibleLayersSortedByZ());
1573 hw->onSwapBuffersCompleted(hwc);
1574 const size_t count = currentLayers.size();
1575 int32_t id = hw->getHwcDisplayId();
1576 if (id >=0 && hwc.initCheck() == NO_ERROR) {
1577 HWComposer::LayerListIterator cur = hwc.begin(id);
1578 const HWComposer::LayerListIterator end = hwc.end(id);
1579 for (size_t i = 0; cur != end && i < count; ++i, ++cur) {
1580 currentLayers[i]->onLayerDisplayed(hw, &*cur);
1581 }
1582 } else {
1583 for (size_t i = 0; i < count; i++) {
1584 currentLayers[i]->onLayerDisplayed(hw, NULL);
1585 }
1586 }
1587 }
1588
1589 mLastSwapBufferTime = systemTime() - now;
1590 mDebugInSwapBuffers = 0;
1591
1592 uint32_t flipCount = getDefaultDisplayDevice()->getPageFlipCount();
1593 if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
1594 logFrameStats();
1595 }
1596}
1597
1598void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
1599{
1600 ATRACE_CALL();
1601
1602 // here we keep a copy of the drawing state (that is the state that's
1603 // going to be overwritten by handleTransactionLocked()) outside of
1604 // mStateLock so that the side-effects of the State assignment
1605 // don't happen with mStateLock held (which can cause deadlocks).
1606 State drawingState(mDrawingState);
1607
1608 Mutex::Autolock _l(mStateLock);
1609 const nsecs_t now = systemTime();
1610 mDebugInTransaction = now;
1611
1612 // Here we're guaranteed that some transaction flags are set
1613 // so we can call handleTransactionLocked() unconditionally.
1614 // We call getTransactionFlags(), which will also clear the flags,
1615 // with mStateLock held to guarantee that mCurrentState won't change
1616 // until the transaction is committed.
1617
1618 transactionFlags = getTransactionFlags(eTransactionMask);
1619 handleTransactionLocked(transactionFlags);
1620
1621 mLastTransactionTime = systemTime() - now;
1622 mDebugInTransaction = 0;
1623 invalidateHwcGeometry();
1624 // here the transaction has been committed
1625}
1626
1627void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
1628{
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001629 // Notify all layers of available frames
Robert Carr2047fae2016-11-28 14:09:09 -08001630 mCurrentState.traverseInZOrder([](Layer* layer) {
1631 layer->notifyAvailableFrames();
1632 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001633
1634 /*
1635 * Traversal of the children
1636 * (perform the transaction for each of them if needed)
1637 */
1638
1639 if (transactionFlags & eTraversalNeeded) {
Robert Carr2047fae2016-11-28 14:09:09 -08001640 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001641 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
Robert Carr2047fae2016-11-28 14:09:09 -08001642 if (!trFlags) return;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001643
1644 const uint32_t flags = layer->doTransaction(0);
1645 if (flags & Layer::eVisibleRegion)
1646 mVisibleRegionsDirty = true;
Robert Carr2047fae2016-11-28 14:09:09 -08001647 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001648 }
1649
1650 /*
1651 * Perform display own transactions if needed
1652 */
1653
1654 if (transactionFlags & eDisplayTransactionNeeded) {
1655 // here we take advantage of Vector's copy-on-write semantics to
1656 // improve performance by skipping the transaction entirely when
1657 // know that the lists are identical
1658 const KeyedVector< wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
1659 const KeyedVector< wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
1660 if (!curr.isIdenticalTo(draw)) {
1661 mVisibleRegionsDirty = true;
1662 const size_t cc = curr.size();
1663 size_t dc = draw.size();
1664
1665 // find the displays that were removed
1666 // (ie: in drawing state but not in current state)
1667 // also handle displays that changed
1668 // (ie: displays that are in both lists)
1669 for (size_t i=0 ; i<dc ; i++) {
1670 const ssize_t j = curr.indexOfKey(draw.keyAt(i));
1671 if (j < 0) {
1672 // in drawing state but not in current state
1673 if (!draw[i].isMainDisplay()) {
1674 // Call makeCurrent() on the primary display so we can
1675 // be sure that nothing associated with this display
1676 // is current.
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001677 const sp<const DisplayDevice> defaultDisplay(getDefaultDisplayDeviceLocked());
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001678 defaultDisplay->makeCurrent(mEGLDisplay, mEGLContext);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001679 sp<DisplayDevice> hw(getDisplayDeviceLocked(draw.keyAt(i)));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001680 if (hw != NULL)
1681 hw->disconnect(getHwComposer());
1682 if (draw[i].type < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES)
1683 mEventThread->onHotplugReceived(draw[i].type, false);
1684 mDisplays.removeItem(draw.keyAt(i));
1685 } else {
1686 ALOGW("trying to remove the main display");
1687 }
1688 } else {
1689 // this display is in both lists. see if something changed.
1690 const DisplayDeviceState& state(curr[j]);
1691 const wp<IBinder>& display(curr.keyAt(j));
1692 const sp<IBinder> state_binder = IInterface::asBinder(state.surface);
1693 const sp<IBinder> draw_binder = IInterface::asBinder(draw[i].surface);
1694 if (state_binder != draw_binder) {
1695 // changing the surface is like destroying and
1696 // recreating the DisplayDevice, so we just remove it
1697 // from the drawing state, so that it get re-added
1698 // below.
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001699 sp<DisplayDevice> hw(getDisplayDeviceLocked(display));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001700 if (hw != NULL)
1701 hw->disconnect(getHwComposer());
1702 mDisplays.removeItem(display);
1703 mDrawingState.displays.removeItemsAt(i);
1704 dc--; i--;
1705 // at this point we must loop to the next item
1706 continue;
1707 }
1708
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001709 const sp<DisplayDevice> disp(getDisplayDeviceLocked(display));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001710 if (disp != NULL) {
1711 if (state.layerStack != draw[i].layerStack) {
1712 disp->setLayerStack(state.layerStack);
1713 }
1714 if ((state.orientation != draw[i].orientation)
1715 || (state.viewport != draw[i].viewport)
1716 || (state.frame != draw[i].frame))
1717 {
1718 disp->setProjection(state.orientation,
1719 state.viewport, state.frame);
1720 }
1721 if (state.width != draw[i].width || state.height != draw[i].height) {
1722 disp->setDisplaySize(state.width, state.height);
1723 }
1724 }
1725 }
1726 }
1727
1728 // find displays that were added
1729 // (ie: in current state but not in drawing state)
1730 for (size_t i=0 ; i<cc ; i++) {
1731 if (draw.indexOfKey(curr.keyAt(i)) < 0) {
1732 const DisplayDeviceState& state(curr[i]);
1733
1734 sp<DisplaySurface> dispSurface;
1735 sp<IGraphicBufferProducer> producer;
1736 sp<IGraphicBufferProducer> bqProducer;
1737 sp<IGraphicBufferConsumer> bqConsumer;
Mathias Agopian0556d792017-03-22 15:49:32 -07001738 BufferQueue::createBufferQueue(&bqProducer, &bqConsumer);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001739
1740 int32_t hwcDisplayId = -1;
1741 if (state.isVirtualDisplay()) {
1742 // Virtual displays without a surface are dormant:
1743 // they have external state (layer stack, projection,
1744 // etc.) but no internal state (i.e. a DisplayDevice).
1745 if (state.surface != NULL) {
1746
1747 int width = 0;
1748 int status = state.surface->query(
1749 NATIVE_WINDOW_WIDTH, &width);
1750 ALOGE_IF(status != NO_ERROR,
1751 "Unable to query width (%d)", status);
1752 int height = 0;
1753 status = state.surface->query(
1754 NATIVE_WINDOW_HEIGHT, &height);
1755 ALOGE_IF(status != NO_ERROR,
1756 "Unable to query height (%d)", status);
1757 if (mUseHwcVirtualDisplays &&
Fabien Sanglardc8e387e2017-03-10 10:30:28 -08001758 (SurfaceFlinger::maxVirtualDisplaySize == 0 ||
1759 (width <= static_cast<int>(SurfaceFlinger::maxVirtualDisplaySize) &&
1760 height <= static_cast<int>(SurfaceFlinger::maxVirtualDisplaySize)))) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001761 hwcDisplayId = allocateHwcDisplayId(state.type);
1762 }
1763
1764 sp<VirtualDisplaySurface> vds = new VirtualDisplaySurface(
1765 *mHwc, hwcDisplayId, state.surface,
1766 bqProducer, bqConsumer, state.displayName);
1767
1768 dispSurface = vds;
1769 producer = vds;
1770 }
1771 } else {
1772 ALOGE_IF(state.surface!=NULL,
1773 "adding a supported display, but rendering "
1774 "surface is provided (%p), ignoring it",
1775 state.surface.get());
1776 hwcDisplayId = allocateHwcDisplayId(state.type);
1777 // for supported (by hwc) displays we provide our
1778 // own rendering surface
1779 dispSurface = new FramebufferSurface(*mHwc, state.type,
1780 bqConsumer);
1781 producer = bqProducer;
1782 }
1783
1784 const wp<IBinder>& display(curr.keyAt(i));
1785 if (dispSurface != NULL) {
1786 sp<DisplayDevice> hw = new DisplayDevice(this,
1787 state.type, hwcDisplayId,
1788 mHwc->getFormat(hwcDisplayId), state.isSecure,
1789 display, dispSurface, producer,
Courtney Goeltzenleuchter4f20f9c2017-04-06 08:18:34 -06001790 mRenderEngine->getEGLConfig(), false);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001791 hw->setLayerStack(state.layerStack);
1792 hw->setProjection(state.orientation,
1793 state.viewport, state.frame);
1794 hw->setDisplayName(state.displayName);
1795 mDisplays.add(display, hw);
1796 if (state.isVirtualDisplay()) {
1797 if (hwcDisplayId >= 0) {
1798 mHwc->setVirtualDisplayProperties(hwcDisplayId,
1799 hw->getWidth(), hw->getHeight(),
1800 hw->getFormat());
1801 }
1802 } else {
1803 mEventThread->onHotplugReceived(state.type, true);
1804 }
1805 }
1806 }
1807 }
1808 }
1809 }
1810
1811 if (transactionFlags & (eTraversalNeeded|eDisplayTransactionNeeded)) {
1812 // The transform hint might have changed for some layers
1813 // (either because a display has changed, or because a layer
1814 // as changed).
1815 //
1816 // Walk through all the layers in currentLayers,
1817 // and update their transform hint.
1818 //
1819 // If a layer is visible only on a single display, then that
1820 // display is used to calculate the hint, otherwise we use the
1821 // default display.
1822 //
1823 // NOTE: we do this here, rather than in rebuildLayerStacks() so that
1824 // the hint is set before we acquire a buffer from the surface texture.
1825 //
1826 // NOTE: layer transactions have taken place already, so we use their
1827 // drawing state. However, SurfaceFlinger's own transaction has not
1828 // happened yet, so we must use the current state layer list
1829 // (soon to become the drawing state list).
1830 //
1831 sp<const DisplayDevice> disp;
1832 uint32_t currentlayerStack = 0;
Robert Carr2047fae2016-11-28 14:09:09 -08001833 bool first = true;
1834 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001835 // NOTE: we rely on the fact that layers are sorted by
1836 // layerStack first (so we don't have to traverse the list
1837 // of displays for every layer).
Robert Carr1f0a16a2016-10-24 16:27:39 -07001838 uint32_t layerStack = layer->getLayerStack();
Robert Carr2047fae2016-11-28 14:09:09 -08001839 if (first || currentlayerStack != layerStack) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001840 currentlayerStack = layerStack;
1841 // figure out if this layerstack is mirrored
1842 // (more than one display) if so, pick the default display,
1843 // if not, pick the only display it's on.
1844 disp.clear();
1845 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1846 sp<const DisplayDevice> hw(mDisplays[dpy]);
1847 if (hw->getLayerStack() == currentlayerStack) {
1848 if (disp == NULL) {
1849 disp = hw;
1850 } else {
1851 disp = NULL;
1852 break;
1853 }
1854 }
1855 }
1856 }
1857 if (disp == NULL) {
1858 // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
1859 // redraw after transform hint changes. See bug 8508397.
1860
1861 // could be null when this layer is using a layerStack
1862 // that is not visible on any display. Also can occur at
1863 // screen off/on times.
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07001864 disp = getDefaultDisplayDeviceLocked();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001865 }
1866 layer->updateTransformHint(disp);
Robert Carr2047fae2016-11-28 14:09:09 -08001867
1868 first = false;
1869 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001870 }
1871
1872
1873 /*
1874 * Perform our own transaction if needed
1875 */
Robert Carr1f0a16a2016-10-24 16:27:39 -07001876
1877 if (mLayersAdded) {
1878 mLayersAdded = false;
1879 // Layers have been added.
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001880 mVisibleRegionsDirty = true;
1881 }
1882
1883 // some layers might have been removed, so
1884 // we need to update the regions they're exposing.
1885 if (mLayersRemoved) {
1886 mLayersRemoved = false;
1887 mVisibleRegionsDirty = true;
Robert Carr2047fae2016-11-28 14:09:09 -08001888 mDrawingState.traverseInZOrder([&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07001889 if (mLayersPendingRemoval.indexOf(layer) >= 0) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001890 // this layer is not visible anymore
1891 // TODO: we could traverse the tree from front to back and
1892 // compute the actual visible region
1893 // TODO: we could cache the transformed region
Robert Carr1f0a16a2016-10-24 16:27:39 -07001894 Region visibleReg;
1895 visibleReg.set(layer->computeScreenBounds());
Chia-I Wuab0c3192017-08-01 11:29:00 -07001896 invalidateLayerStack(layer, visibleReg);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001897 }
Robert Carr2047fae2016-11-28 14:09:09 -08001898 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001899 }
1900
1901 commitTransaction();
1902
1903 updateCursorAsync();
1904}
1905
1906void SurfaceFlinger::updateCursorAsync()
1907{
1908 HWComposer& hwc(getHwComposer());
1909 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1910 sp<const DisplayDevice> hw(mDisplays[dpy]);
1911 const int32_t id = hw->getHwcDisplayId();
1912 if (id < 0) {
1913 continue;
1914 }
1915 const Vector< sp<Layer> >& currentLayers(
1916 hw->getVisibleLayersSortedByZ());
1917 const size_t count = currentLayers.size();
1918 HWComposer::LayerListIterator cur = hwc.begin(id);
1919 const HWComposer::LayerListIterator end = hwc.end(id);
1920 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1921 if (cur->getCompositionType() != HWC_CURSOR_OVERLAY) {
1922 continue;
1923 }
1924 const sp<Layer>& layer(currentLayers[i]);
1925 Rect cursorPos = layer->getPosition(hw);
1926 hwc.setCursorPositionAsync(id, cursorPos);
1927 break;
1928 }
1929 }
1930}
1931
1932void SurfaceFlinger::commitTransaction()
1933{
1934 if (!mLayersPendingRemoval.isEmpty()) {
1935 // Notify removed layers now that they can't be drawn from
Robert Carr1f0a16a2016-10-24 16:27:39 -07001936 for (const auto& l : mLayersPendingRemoval) {
1937 recordBufferingStats(l->getName().string(),
1938 l->getOccupancyHistory(true));
1939 l->onRemoved();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001940 }
1941 mLayersPendingRemoval.clear();
1942 }
1943
1944 // If this transaction is part of a window animation then the next frame
1945 // we composite should be considered an animation as well.
1946 mAnimCompositionPending = mAnimTransactionPending;
1947
1948 mDrawingState = mCurrentState;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001949 mDrawingState.traverseInZOrder([](Layer* layer) {
1950 layer->commitChildList();
1951 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001952 mTransactionPending = false;
1953 mAnimTransactionPending = false;
1954 mTransactionCV.broadcast();
1955}
1956
Chia-I Wuab0c3192017-08-01 11:29:00 -07001957void SurfaceFlinger::computeVisibleRegions(const sp<const DisplayDevice>& displayDevice,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001958 Region& outDirtyRegion, Region& outOpaqueRegion)
1959{
1960 ATRACE_CALL();
1961
1962 Region aboveOpaqueLayers;
1963 Region aboveCoveredLayers;
1964 Region dirty;
1965
1966 outDirtyRegion.clear();
1967
Robert Carr2047fae2016-11-28 14:09:09 -08001968 mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001969 // start with the whole surface at its current location
1970 const Layer::State& s(layer->getDrawingState());
1971
1972 // only consider the layers on the given layer stack
Chia-I Wuab0c3192017-08-01 11:29:00 -07001973 if (layer->getLayerStack() != displayDevice->getLayerStack())
Robert Carr2047fae2016-11-28 14:09:09 -08001974 return;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00001975
1976 /*
1977 * opaqueRegion: area of a surface that is fully opaque.
1978 */
1979 Region opaqueRegion;
1980
1981 /*
1982 * visibleRegion: area of a surface that is visible on screen
1983 * and not fully transparent. This is essentially the layer's
1984 * footprint minus the opaque regions above it.
1985 * Areas covered by a translucent surface are considered visible.
1986 */
1987 Region visibleRegion;
1988
1989 /*
1990 * coveredRegion: area of a surface that is covered by all
1991 * visible regions above it (which includes the translucent areas).
1992 */
1993 Region coveredRegion;
1994
1995 /*
1996 * transparentRegion: area of a surface that is hinted to be completely
1997 * transparent. This is only used to tell when the layer has no visible
1998 * non-transparent regions and can be removed from the layer list. It
1999 * does not affect the visibleRegion of this layer or any layers
2000 * beneath it. The hint may not be correct if apps don't respect the
2001 * SurfaceView restrictions (which, sadly, some don't).
2002 */
2003 Region transparentRegion;
2004
2005
2006 // handle hidden surfaces by setting the visible region to empty
2007 if (CC_LIKELY(layer->isVisible())) {
2008 const bool translucent = !layer->isOpaque(s);
Robert Carr1f0a16a2016-10-24 16:27:39 -07002009 Rect bounds(layer->computeScreenBounds());
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002010 visibleRegion.set(bounds);
Robert Carr1f0a16a2016-10-24 16:27:39 -07002011 Transform tr = layer->getTransform();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002012 if (!visibleRegion.isEmpty()) {
2013 // Remove the transparent area from the visible region
2014 if (translucent) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002015 if (tr.preserveRects()) {
2016 // transform the transparent region
2017 transparentRegion = tr.transform(s.activeTransparentRegion);
2018 } else {
2019 // transformation too complex, can't do the
2020 // transparent region optimization.
2021 transparentRegion.clear();
2022 }
2023 }
2024
2025 // compute the opaque region
Robert Carr1f0a16a2016-10-24 16:27:39 -07002026 const int32_t layerOrientation = tr.getOrientation();
chaviw13fdc492017-06-27 12:40:18 -07002027 if (layer->getAlpha()==1.0f && !translucent &&
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002028 ((layerOrientation & Transform::ROT_INVALID) == false)) {
2029 // the opaque region is the layer's footprint
2030 opaqueRegion = visibleRegion;
2031 }
2032 }
2033 }
2034
2035 // Clip the covered region to the visible region
2036 coveredRegion = aboveCoveredLayers.intersect(visibleRegion);
2037
2038 // Update aboveCoveredLayers for next (lower) layer
2039 aboveCoveredLayers.orSelf(visibleRegion);
2040
2041 // subtract the opaque region covered by the layers above us
2042 visibleRegion.subtractSelf(aboveOpaqueLayers);
2043
2044 // compute this layer's dirty region
2045 if (layer->contentDirty) {
2046 // we need to invalidate the whole region
2047 dirty = visibleRegion;
2048 // as well, as the old visible region
2049 dirty.orSelf(layer->visibleRegion);
2050 layer->contentDirty = false;
2051 } else {
2052 /* compute the exposed region:
2053 * the exposed region consists of two components:
2054 * 1) what's VISIBLE now and was COVERED before
2055 * 2) what's EXPOSED now less what was EXPOSED before
2056 *
2057 * note that (1) is conservative, we start with the whole
2058 * visible region but only keep what used to be covered by
2059 * something -- which mean it may have been exposed.
2060 *
2061 * (2) handles areas that were not covered by anything but got
2062 * exposed because of a resize.
2063 */
2064 const Region newExposed = visibleRegion - coveredRegion;
2065 const Region oldVisibleRegion = layer->visibleRegion;
2066 const Region oldCoveredRegion = layer->coveredRegion;
2067 const Region oldExposed = oldVisibleRegion - oldCoveredRegion;
2068 dirty = (visibleRegion&oldCoveredRegion) | (newExposed-oldExposed);
2069 }
2070 dirty.subtractSelf(aboveOpaqueLayers);
2071
2072 // accumulate to the screen dirty region
2073 outDirtyRegion.orSelf(dirty);
2074
2075 // Update aboveOpaqueLayers for next (lower) layer
2076 aboveOpaqueLayers.orSelf(opaqueRegion);
2077
2078 // Store the visible region in screen space
2079 layer->setVisibleRegion(visibleRegion);
2080 layer->setCoveredRegion(coveredRegion);
2081 layer->setVisibleNonTransparentRegion(
2082 visibleRegion.subtract(transparentRegion));
Robert Carr2047fae2016-11-28 14:09:09 -08002083 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002084
2085 outOpaqueRegion = aboveOpaqueLayers;
2086}
2087
Chia-I Wuab0c3192017-08-01 11:29:00 -07002088void SurfaceFlinger::invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty) {
2089 uint32_t layerStack = layer->getLayerStack();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002090 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
2091 const sp<DisplayDevice>& hw(mDisplays[dpy]);
2092 if (hw->getLayerStack() == layerStack) {
2093 hw->dirtyRegion.orSelf(dirty);
2094 }
2095 }
2096}
2097
2098bool SurfaceFlinger::handlePageFlip()
2099{
Brian Andersond6927fb2016-07-23 23:37:30 -07002100 nsecs_t latchTime = systemTime();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002101 Region dirtyRegion;
2102
2103 bool visibleRegions = false;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002104 bool frameQueued = false;
2105
2106 // Store the set of layers that need updates. This set must not change as
2107 // buffers are being latched, as this could result in a deadlock.
2108 // Example: Two producers share the same command stream and:
2109 // 1.) Layer 0 is latched
2110 // 2.) Layer 0 gets a new frame
2111 // 2.) Layer 1 gets a new frame
2112 // 3.) Layer 1 is latched.
2113 // Display is now waiting on Layer 1's frame, which is behind layer 0's
2114 // second frame. But layer 0's second frame could be waiting on display.
2115 Vector<Layer*> layersWithQueuedFrames;
Robert Carr2047fae2016-11-28 14:09:09 -08002116 mDrawingState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002117 if (layer->hasQueuedFrame()) {
2118 frameQueued = true;
2119 if (layer->shouldPresentNow(mPrimaryDispSync)) {
Robert Carr2047fae2016-11-28 14:09:09 -08002120 layersWithQueuedFrames.push_back(layer);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002121 } else {
2122 layer->useEmptyDamage();
2123 }
2124 } else {
2125 layer->useEmptyDamage();
2126 }
Robert Carr2047fae2016-11-28 14:09:09 -08002127 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002128 for (size_t i = 0, count = layersWithQueuedFrames.size() ; i<count ; i++) {
2129 Layer* layer = layersWithQueuedFrames[i];
Brian Andersond6927fb2016-07-23 23:37:30 -07002130 const Region dirty(layer->latchBuffer(visibleRegions, latchTime));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002131 layer->useSurfaceDamage();
Chia-I Wuab0c3192017-08-01 11:29:00 -07002132 invalidateLayerStack(layer, dirty);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002133 }
2134
2135 mVisibleRegionsDirty |= visibleRegions;
2136
2137 // If we will need to wake up at some time in the future to deal with a
2138 // queued frame that shouldn't be displayed during this vsync period, wake
2139 // up during the next vsync period to check again.
2140 if (frameQueued && layersWithQueuedFrames.empty()) {
2141 signalLayerUpdate();
2142 }
2143
2144 // Only continue with the refresh if there is actually new work to do
2145 return !layersWithQueuedFrames.empty();
2146}
2147
2148void SurfaceFlinger::invalidateHwcGeometry()
2149{
2150 mHwWorkListDirty = true;
2151}
2152
2153
2154void SurfaceFlinger::doDisplayComposition(const sp<const DisplayDevice>& hw,
2155 const Region& inDirtyRegion)
2156{
2157 // We only need to actually compose the display if:
2158 // 1) It is being handled by hardware composer, which may need this to
2159 // keep its virtual display state machine in sync, or
2160 // 2) There is work to be done (the dirty region isn't empty)
2161 bool isHwcDisplay = hw->getHwcDisplayId() >= 0;
2162 if (!isHwcDisplay && inDirtyRegion.isEmpty()) {
2163 return;
2164 }
2165
2166 Region dirtyRegion(inDirtyRegion);
2167
2168 // compute the invalid region
2169 hw->swapRegion.orSelf(dirtyRegion);
2170
2171 uint32_t flags = hw->getFlags();
2172 if (flags & DisplayDevice::SWAP_RECTANGLE) {
2173 // we can redraw only what's dirty, but since SWAP_RECTANGLE only
2174 // takes a rectangle, we must make sure to update that whole
2175 // rectangle in that case
2176 dirtyRegion.set(hw->swapRegion.bounds());
2177 } else {
2178 if (flags & DisplayDevice::PARTIAL_UPDATES) {
2179 // We need to redraw the rectangle that will be updated
2180 // (pushed to the framebuffer).
2181 // This is needed because PARTIAL_UPDATES only takes one
2182 // rectangle instead of a region (see DisplayDevice::flip())
2183 dirtyRegion.set(hw->swapRegion.bounds());
2184 } else {
2185 // we need to redraw everything (the whole screen)
2186 dirtyRegion.set(hw->bounds());
2187 hw->swapRegion = dirtyRegion;
2188 }
2189 }
2190
2191 if (CC_LIKELY(!mDaltonize && !mHasColorMatrix)) {
2192 if (!doComposeSurfaces(hw, dirtyRegion)) return;
2193 } else {
2194 RenderEngine& engine(getRenderEngine());
2195 mat4 colorMatrix = mColorMatrix;
2196 if (mDaltonize) {
2197 colorMatrix = colorMatrix * mDaltonizer();
2198 }
2199 mat4 oldMatrix = engine.setupColorTransform(colorMatrix);
2200 doComposeSurfaces(hw, dirtyRegion);
2201 engine.setupColorTransform(oldMatrix);
2202 }
2203
2204 // update the swap region and clear the dirty region
2205 hw->swapRegion.orSelf(dirtyRegion);
2206
2207 // swap buffers (presentation)
2208 hw->swapBuffers(getHwComposer());
2209}
2210
2211bool SurfaceFlinger::doComposeSurfaces(const sp<const DisplayDevice>& hw, const Region& dirty)
2212{
2213 RenderEngine& engine(getRenderEngine());
2214 const int32_t id = hw->getHwcDisplayId();
2215 HWComposer& hwc(getHwComposer());
2216 HWComposer::LayerListIterator cur = hwc.begin(id);
2217 const HWComposer::LayerListIterator end = hwc.end(id);
2218
2219 bool hasGlesComposition = hwc.hasGlesComposition(id);
2220 if (hasGlesComposition) {
2221 if (!hw->makeCurrent(mEGLDisplay, mEGLContext)) {
2222 ALOGW("DisplayDevice::makeCurrent failed. Aborting surface composition for display %s",
2223 hw->getDisplayName().string());
2224 eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
2225 if(!getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext)) {
2226 ALOGE("DisplayDevice::makeCurrent on default display failed. Aborting.");
2227 }
2228 return false;
2229 }
2230
2231 // Never touch the framebuffer if we don't have any framebuffer layers
2232 const bool hasHwcComposition = hwc.hasHwcComposition(id);
2233 if (hasHwcComposition) {
2234 // when using overlays, we assume a fully transparent framebuffer
2235 // NOTE: we could reduce how much we need to clear, for instance
2236 // remove where there are opaque FB layers. however, on some
2237 // GPUs doing a "clean slate" clear might be more efficient.
2238 // We'll revisit later if needed.
2239 engine.clearWithColor(0, 0, 0, 0);
2240 } else {
2241 // we start with the whole screen area
2242 const Region bounds(hw->getBounds());
2243
2244 // we remove the scissor part
2245 // we're left with the letterbox region
2246 // (common case is that letterbox ends-up being empty)
2247 const Region letterbox(bounds.subtract(hw->getScissor()));
2248
2249 // compute the area to clear
2250 Region region(hw->undefinedRegion.merge(letterbox));
2251
2252 // but limit it to the dirty region
2253 region.andSelf(dirty);
2254
2255 // screen is already cleared here
2256 if (!region.isEmpty()) {
2257 // can happen with SurfaceView
2258 drawWormhole(hw, region);
2259 }
2260 }
2261
2262 if (hw->getDisplayType() != DisplayDevice::DISPLAY_PRIMARY) {
2263 // just to be on the safe side, we don't set the
2264 // scissor on the main display. It should never be needed
2265 // anyways (though in theory it could since the API allows it).
2266 const Rect& bounds(hw->getBounds());
2267 const Rect& scissor(hw->getScissor());
2268 if (scissor != bounds) {
2269 // scissor doesn't match the screen's dimensions, so we
2270 // need to clear everything outside of it and enable
2271 // the GL scissor so we don't draw anything where we shouldn't
2272
2273 // enable scissor for this frame
2274 const uint32_t height = hw->getHeight();
2275 engine.setScissor(scissor.left, height - scissor.bottom,
2276 scissor.getWidth(), scissor.getHeight());
2277 }
2278 }
2279 }
2280
2281 /*
2282 * and then, render the layers targeted at the framebuffer
2283 */
2284
2285 const Vector< sp<Layer> >& layers(hw->getVisibleLayersSortedByZ());
2286 const size_t count = layers.size();
2287 const Transform& tr = hw->getTransform();
2288 if (cur != end) {
2289 // we're using h/w composer
2290 for (size_t i=0 ; i<count && cur!=end ; ++i, ++cur) {
2291 const sp<Layer>& layer(layers[i]);
2292 const Region clip(dirty.intersect(tr.transform(layer->visibleRegion)));
2293 if (!clip.isEmpty()) {
2294 switch (cur->getCompositionType()) {
2295 case HWC_CURSOR_OVERLAY:
2296 case HWC_OVERLAY: {
2297 const Layer::State& state(layer->getDrawingState());
2298 if ((cur->getHints() & HWC_HINT_CLEAR_FB)
2299 && i
chaviw13fdc492017-06-27 12:40:18 -07002300 && layer->isOpaque(state) && (state.color.a == 1.0f)
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002301 && hasGlesComposition) {
2302 // never clear the very first layer since we're
2303 // guaranteed the FB is already cleared
Fabien Sanglard17487192016-12-07 13:03:32 -08002304 layer->clearWithOpenGL(hw);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002305 }
2306 break;
2307 }
2308 case HWC_FRAMEBUFFER: {
2309 layer->draw(hw, clip);
2310 break;
2311 }
2312 case HWC_FRAMEBUFFER_TARGET: {
2313 // this should not happen as the iterator shouldn't
2314 // let us get there.
2315 ALOGW("HWC_FRAMEBUFFER_TARGET found in hwc list (index=%zu)", i);
2316 break;
2317 }
2318 }
2319 }
2320 layer->setAcquireFence(hw, *cur);
2321 }
2322 } else {
2323 // we're not using h/w composer
2324 for (size_t i=0 ; i<count ; ++i) {
2325 const sp<Layer>& layer(layers[i]);
2326 const Region clip(dirty.intersect(
2327 tr.transform(layer->visibleRegion)));
2328 if (!clip.isEmpty()) {
2329 layer->draw(hw, clip);
2330 }
2331 }
2332 }
2333
2334 // disable scissor at the end of the frame
2335 engine.disableScissor();
2336 return true;
2337}
2338
2339void SurfaceFlinger::drawWormhole(const sp<const DisplayDevice>& hw, const Region& region) const {
2340 const int32_t height = hw->getHeight();
2341 RenderEngine& engine(getRenderEngine());
2342 engine.fillRegionWithColor(region, height, 0, 0, 0, 0);
2343}
2344
2345status_t SurfaceFlinger::addClientLayer(const sp<Client>& client,
2346 const sp<IBinder>& handle,
2347 const sp<IGraphicBufferProducer>& gbc,
Robert Carr1f0a16a2016-10-24 16:27:39 -07002348 const sp<Layer>& lbc,
2349 const sp<Layer>& parent)
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002350{
2351 // add this layer to the current state list
2352 {
2353 Mutex::Autolock _l(mStateLock);
Robert Carr1f0a16a2016-10-24 16:27:39 -07002354 if (mNumLayers >= MAX_LAYERS) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002355 return NO_MEMORY;
2356 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07002357 if (parent == nullptr) {
2358 mCurrentState.layersSortedByZ.add(lbc);
2359 } else {
Chia-I Wufae51c42017-06-15 12:53:59 -07002360 if (mCurrentState.layersSortedByZ.indexOf(parent) < 0) {
2361 ALOGE("addClientLayer called with a removed parent");
2362 return NAME_NOT_FOUND;
2363 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07002364 parent->addChild(lbc);
2365 }
Chia-I Wufae51c42017-06-15 12:53:59 -07002366
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002367 mGraphicBufferProducerList.add(IInterface::asBinder(gbc));
Robert Carr1f0a16a2016-10-24 16:27:39 -07002368 mLayersAdded = true;
2369 mNumLayers++;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002370 }
2371
2372 // attach this layer to the client
2373 client->attachLayer(handle, lbc);
2374
2375 return NO_ERROR;
2376}
2377
Chia-I Wu515dc9c2017-06-15 12:53:59 -07002378status_t SurfaceFlinger::removeLayer(const sp<Layer>& layer, bool topLevelOnly) {
Robert Carr7f9b8992017-03-10 11:08:39 -08002379 Mutex::Autolock _l(mStateLock);
2380
Robert Carr1f0a16a2016-10-24 16:27:39 -07002381 const auto& p = layer->getParent();
Chia-I Wu515dc9c2017-06-15 12:53:59 -07002382 ssize_t index;
2383 if (p != nullptr) {
2384 if (topLevelOnly) {
2385 return NO_ERROR;
2386 }
2387
Chia-I Wufae51c42017-06-15 12:53:59 -07002388 sp<Layer> ancestor = p;
2389 while (ancestor->getParent() != nullptr) {
2390 ancestor = ancestor->getParent();
2391 }
2392 if (mCurrentState.layersSortedByZ.indexOf(ancestor) < 0) {
2393 ALOGE("removeLayer called with a layer whose parent has been removed");
2394 return NAME_NOT_FOUND;
2395 }
2396
Chia-I Wu515dc9c2017-06-15 12:53:59 -07002397 index = p->removeChild(layer);
2398 } else {
2399 index = mCurrentState.layersSortedByZ.remove(layer);
2400 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07002401
Robert Carr136e2f62017-02-08 17:54:29 -08002402 // As a matter of normal operation, the LayerCleaner will produce a second
2403 // attempt to remove the surface. The Layer will be kept alive in mDrawingState
2404 // so we will succeed in promoting it, but it's already been removed
2405 // from mCurrentState. As long as we can find it in mDrawingState we have no problem
2406 // otherwise something has gone wrong and we are leaking the layer.
2407 if (index < 0 && mDrawingState.layersSortedByZ.indexOf(layer) < 0) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07002408 ALOGE("Failed to find layer (%s) in layer parent (%s).",
2409 layer->getName().string(),
2410 (p != nullptr) ? p->getName().string() : "no-parent");
2411 return BAD_VALUE;
Robert Carr136e2f62017-02-08 17:54:29 -08002412 } else if (index < 0) {
2413 return NO_ERROR;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002414 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07002415
Chia-I Wuc6657022017-08-15 11:18:17 -07002416 layer->onRemovedFromCurrentState();
Robert Carr1f0a16a2016-10-24 16:27:39 -07002417 mLayersPendingRemoval.add(layer);
2418 mLayersRemoved = true;
Chia-I Wufae51c42017-06-15 12:53:59 -07002419 mNumLayers -= 1 + layer->getChildrenCount();
Robert Carr1f0a16a2016-10-24 16:27:39 -07002420 setTransactionFlags(eTransactionNeeded);
2421 return NO_ERROR;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002422}
2423
Fabien Sanglardc8251eb2016-12-07 13:59:48 -08002424uint32_t SurfaceFlinger::peekTransactionFlags() {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002425 return android_atomic_release_load(&mTransactionFlags);
2426}
2427
2428uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) {
2429 return android_atomic_and(~flags, &mTransactionFlags) & flags;
2430}
2431
2432uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) {
2433 uint32_t old = android_atomic_or(flags, &mTransactionFlags);
2434 if ((old & flags)==0) { // wake the server up
2435 signalTransaction();
2436 }
2437 return old;
2438}
2439
2440void SurfaceFlinger::setTransactionState(
2441 const Vector<ComposerState>& state,
2442 const Vector<DisplayState>& displays,
2443 uint32_t flags)
2444{
2445 ATRACE_CALL();
2446 Mutex::Autolock _l(mStateLock);
2447 uint32_t transactionFlags = 0;
2448
2449 if (flags & eAnimation) {
2450 // For window updates that are part of an animation we must wait for
2451 // previous animation "frames" to be handled.
2452 while (mAnimTransactionPending) {
2453 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
2454 if (CC_UNLIKELY(err != NO_ERROR)) {
2455 // just in case something goes wrong in SF, return to the
2456 // caller after a few seconds.
2457 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out "
2458 "waiting for previous animation frame");
2459 mAnimTransactionPending = false;
2460 break;
2461 }
2462 }
2463 }
2464
2465 size_t count = displays.size();
2466 for (size_t i=0 ; i<count ; i++) {
2467 const DisplayState& s(displays[i]);
2468 transactionFlags |= setDisplayStateLocked(s);
2469 }
2470
2471 count = state.size();
2472 for (size_t i=0 ; i<count ; i++) {
2473 const ComposerState& s(state[i]);
2474 // Here we need to check that the interface we're given is indeed
2475 // one of our own. A malicious client could give us a NULL
2476 // IInterface, or one of its own or even one of our own but a
2477 // different type. All these situations would cause us to crash.
2478 //
2479 // NOTE: it would be better to use RTTI as we could directly check
2480 // that we have a Client*. however, RTTI is disabled in Android.
2481 if (s.client != NULL) {
2482 sp<IBinder> binder = IInterface::asBinder(s.client);
2483 if (binder != NULL) {
Fabien Sanglard45b20252017-01-18 16:43:18 -08002484 if (binder->queryLocalInterface(ISurfaceComposerClient::descriptor) != NULL) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002485 sp<Client> client( static_cast<Client *>(s.client.get()) );
2486 transactionFlags |= setClientStateLocked(client, s.state);
2487 }
2488 }
2489 }
2490 }
2491
2492 // If a synchronous transaction is explicitly requested without any changes,
2493 // force a transaction anyway. This can be used as a flush mechanism for
2494 // previous async transactions.
2495 if (transactionFlags == 0 && (flags & eSynchronous)) {
2496 transactionFlags = eTransactionNeeded;
2497 }
2498
2499 if (transactionFlags) {
2500 if (mInterceptor.isEnabled()) {
2501 mInterceptor.saveTransaction(state, mCurrentState.displays, displays, flags);
2502 }
2503
2504 // this triggers the transaction
2505 setTransactionFlags(transactionFlags);
2506
2507 // if this is a synchronous transaction, wait for it to take effect
2508 // before returning.
2509 if (flags & eSynchronous) {
2510 mTransactionPending = true;
2511 }
2512 if (flags & eAnimation) {
2513 mAnimTransactionPending = true;
2514 }
2515 while (mTransactionPending) {
2516 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
2517 if (CC_UNLIKELY(err != NO_ERROR)) {
2518 // just in case something goes wrong in SF, return to the
2519 // called after a few seconds.
2520 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");
2521 mTransactionPending = false;
2522 break;
2523 }
2524 }
2525 }
2526}
2527
2528uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s)
2529{
2530 ssize_t dpyIdx = mCurrentState.displays.indexOfKey(s.token);
2531 if (dpyIdx < 0)
2532 return 0;
2533
2534 uint32_t flags = 0;
2535 DisplayDeviceState& disp(mCurrentState.displays.editValueAt(dpyIdx));
2536 if (disp.isValid()) {
2537 const uint32_t what = s.what;
2538 if (what & DisplayState::eSurfaceChanged) {
2539 if (IInterface::asBinder(disp.surface) != IInterface::asBinder(s.surface)) {
2540 disp.surface = s.surface;
2541 flags |= eDisplayTransactionNeeded;
2542 }
2543 }
2544 if (what & DisplayState::eLayerStackChanged) {
2545 if (disp.layerStack != s.layerStack) {
2546 disp.layerStack = s.layerStack;
2547 flags |= eDisplayTransactionNeeded;
2548 }
2549 }
2550 if (what & DisplayState::eDisplayProjectionChanged) {
2551 if (disp.orientation != s.orientation) {
2552 disp.orientation = s.orientation;
2553 flags |= eDisplayTransactionNeeded;
2554 }
2555 if (disp.frame != s.frame) {
2556 disp.frame = s.frame;
2557 flags |= eDisplayTransactionNeeded;
2558 }
2559 if (disp.viewport != s.viewport) {
2560 disp.viewport = s.viewport;
2561 flags |= eDisplayTransactionNeeded;
2562 }
2563 }
2564 if (what & DisplayState::eDisplaySizeChanged) {
2565 if (disp.width != s.width) {
2566 disp.width = s.width;
2567 flags |= eDisplayTransactionNeeded;
2568 }
2569 if (disp.height != s.height) {
2570 disp.height = s.height;
2571 flags |= eDisplayTransactionNeeded;
2572 }
2573 }
2574 }
2575 return flags;
2576}
2577
2578uint32_t SurfaceFlinger::setClientStateLocked(
2579 const sp<Client>& client,
2580 const layer_state_t& s)
2581{
2582 uint32_t flags = 0;
2583 sp<Layer> layer(client->getLayerUser(s.surface));
2584 if (layer != 0) {
2585 const uint32_t what = s.what;
2586 bool geometryAppliesWithResize =
2587 what & layer_state_t::eGeometryAppliesWithResize;
2588 if (what & layer_state_t::ePositionChanged) {
2589 if (layer->setPosition(s.x, s.y, !geometryAppliesWithResize)) {
2590 flags |= eTraversalNeeded;
2591 }
2592 }
2593 if (what & layer_state_t::eLayerChanged) {
2594 // NOTE: index needs to be calculated before we update the state
Robert Carr1f0a16a2016-10-24 16:27:39 -07002595 const auto& p = layer->getParent();
2596 if (p == nullptr) {
2597 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
2598 if (layer->setLayer(s.z) && idx >= 0) {
2599 mCurrentState.layersSortedByZ.removeAt(idx);
2600 mCurrentState.layersSortedByZ.add(layer);
2601 // we need traversal (state changed)
2602 // AND transaction (list changed)
2603 flags |= eTransactionNeeded|eTraversalNeeded;
2604 }
2605 } else {
2606 if (p->setChildLayer(layer, s.z)) {
2607 flags |= eTransactionNeeded|eTraversalNeeded;
2608 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002609 }
2610 }
chaviw64f7b422017-07-12 10:31:58 -07002611 if (what & layer_state_t::eRelativeLayerChanged) {
2612 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
2613 if (layer->setRelativeLayer(s.relativeLayerHandle, s.z)) {
2614 mCurrentState.layersSortedByZ.removeAt(idx);
2615 mCurrentState.layersSortedByZ.add(layer);
2616 flags |= eTransactionNeeded|eTraversalNeeded;
2617 }
2618 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002619 if (what & layer_state_t::eSizeChanged) {
2620 if (layer->setSize(s.w, s.h)) {
2621 flags |= eTraversalNeeded;
2622 }
2623 }
2624 if (what & layer_state_t::eAlphaChanged) {
chaviw13fdc492017-06-27 12:40:18 -07002625 if (layer->setAlpha(s.alpha))
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002626 flags |= eTraversalNeeded;
2627 }
chaviw13fdc492017-06-27 12:40:18 -07002628 if (what & layer_state_t::eColorChanged) {
2629 if (layer->setColor(s.color)) {
2630 flags |= eTraversalNeeded;
2631 }
2632 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002633 if (what & layer_state_t::eMatrixChanged) {
2634 if (layer->setMatrix(s.matrix))
2635 flags |= eTraversalNeeded;
2636 }
2637 if (what & layer_state_t::eTransparentRegionChanged) {
2638 if (layer->setTransparentRegionHint(s.transparentRegion))
2639 flags |= eTraversalNeeded;
2640 }
2641 if (what & layer_state_t::eFlagsChanged) {
2642 if (layer->setFlags(s.flags, s.mask))
2643 flags |= eTraversalNeeded;
2644 }
2645 if (what & layer_state_t::eCropChanged) {
2646 if (layer->setCrop(s.crop, !geometryAppliesWithResize))
2647 flags |= eTraversalNeeded;
2648 }
2649 if (what & layer_state_t::eFinalCropChanged) {
Robert Carr6fb9ca72017-03-22 18:23:23 -07002650 if (layer->setFinalCrop(s.finalCrop, !geometryAppliesWithResize))
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002651 flags |= eTraversalNeeded;
2652 }
2653 if (what & layer_state_t::eLayerStackChanged) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002654 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
Robert Carr1f0a16a2016-10-24 16:27:39 -07002655 // We only allow setting layer stacks for top level layers,
2656 // everything else inherits layer stack from its parent.
2657 if (layer->hasParent()) {
2658 ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
2659 layer->getName().string());
2660 } else if (idx < 0) {
2661 ALOGE("Attempt to set layer stack on layer without parent (%s) that "
2662 "that also does not appear in the top level layer list. Something"
2663 " has gone wrong.", layer->getName().string());
2664 } else if (layer->setLayerStack(s.layerStack)) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002665 mCurrentState.layersSortedByZ.removeAt(idx);
2666 mCurrentState.layersSortedByZ.add(layer);
2667 // we need traversal (state changed)
2668 // AND transaction (list changed)
2669 flags |= eTransactionNeeded|eTraversalNeeded;
2670 }
2671 }
2672 if (what & layer_state_t::eDeferTransaction) {
Robert Carr0d480722017-01-10 16:42:54 -08002673 if (s.barrierHandle != nullptr) {
2674 layer->deferTransactionUntil(s.barrierHandle, s.frameNumber);
2675 } else if (s.barrierGbp != nullptr) {
2676 const sp<IGraphicBufferProducer>& gbp = s.barrierGbp;
2677 if (authenticateSurfaceTextureLocked(gbp)) {
2678 const auto& otherLayer =
2679 (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
2680 layer->deferTransactionUntil(otherLayer, s.frameNumber);
2681 } else {
2682 ALOGE("Attempt to defer transaction to to an"
2683 " unrecognized GraphicBufferProducer");
2684 }
2685 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002686 // We don't trigger a traversal here because if no other state is
2687 // changed, we don't want this to cause any more work
2688 }
chaviwf1961f72017-09-18 16:41:07 -07002689 if (what & layer_state_t::eReparent) {
2690 if (layer->reparent(s.parentHandleForChild)) {
chaviw06178942017-07-27 10:25:59 -07002691 flags |= eTransactionNeeded|eTraversalNeeded;
2692 }
2693 }
Robert Carr1db73f62016-12-21 12:58:51 -08002694 if (what & layer_state_t::eReparentChildren) {
2695 if (layer->reparentChildren(s.reparentHandle)) {
2696 flags |= eTransactionNeeded|eTraversalNeeded;
2697 }
2698 }
Robert Carr9524cb32017-02-13 11:32:32 -08002699 if (what & layer_state_t::eDetachChildren) {
2700 layer->detachChildren();
2701 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002702 if (what & layer_state_t::eOverrideScalingModeChanged) {
2703 layer->setOverrideScalingMode(s.overrideScalingMode);
2704 // We don't trigger a traversal here because if no other state is
2705 // changed, we don't want this to cause any more work
2706 }
2707 }
2708 return flags;
2709}
2710
2711status_t SurfaceFlinger::createLayer(
2712 const String8& name,
2713 const sp<Client>& client,
2714 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
Albert Chaulk479c60c2017-01-27 14:21:34 -05002715 uint32_t windowType, uint32_t ownerUid, sp<IBinder>* handle,
2716 sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent)
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002717{
2718 if (int32_t(w|h) < 0) {
2719 ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
2720 int(w), int(h));
2721 return BAD_VALUE;
2722 }
2723
2724 status_t result = NO_ERROR;
2725
2726 sp<Layer> layer;
2727
Cody Northropbc755282017-03-31 12:00:08 -06002728 String8 uniqueName = getUniqueLayerName(name);
2729
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002730 switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
2731 case ISurfaceComposerClient::eFXSurfaceNormal:
2732 result = createNormalLayer(client,
Cody Northropbc755282017-03-31 12:00:08 -06002733 uniqueName, w, h, flags, format,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002734 handle, gbp, &layer);
2735 break;
chaviw13fdc492017-06-27 12:40:18 -07002736 case ISurfaceComposerClient::eFXSurfaceColor:
2737 result = createColorLayer(client,
Cody Northropbc755282017-03-31 12:00:08 -06002738 uniqueName, w, h, flags,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002739 handle, gbp, &layer);
2740 break;
2741 default:
2742 result = BAD_VALUE;
2743 break;
2744 }
2745
2746 if (result != NO_ERROR) {
2747 return result;
2748 }
2749
Albert Chaulk479c60c2017-01-27 14:21:34 -05002750 layer->setInfo(windowType, ownerUid);
2751
Robert Carr1f0a16a2016-10-24 16:27:39 -07002752 result = addClientLayer(client, *handle, *gbp, layer, *parent);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002753 if (result != NO_ERROR) {
2754 return result;
2755 }
2756 mInterceptor.saveSurfaceCreation(layer);
2757
2758 setTransactionFlags(eTransactionNeeded);
2759 return result;
2760}
2761
Cody Northropbc755282017-03-31 12:00:08 -06002762String8 SurfaceFlinger::getUniqueLayerName(const String8& name)
2763{
2764 bool matchFound = true;
2765 uint32_t dupeCounter = 0;
2766
2767 // Tack on our counter whether there is a hit or not, so everyone gets a tag
2768 String8 uniqueName = name + "#" + String8(std::to_string(dupeCounter).c_str());
2769
2770 // Loop over layers until we're sure there is no matching name
2771 while (matchFound) {
2772 matchFound = false;
2773 mDrawingState.traverseInZOrder([&](Layer* layer) {
2774 if (layer->getName() == uniqueName) {
2775 matchFound = true;
2776 uniqueName = name + "#" + String8(std::to_string(++dupeCounter).c_str());
2777 }
2778 });
2779 }
2780
2781 ALOGD_IF(dupeCounter > 0, "duplicate layer name: changing %s to %s", name.c_str(), uniqueName.c_str());
2782
2783 return uniqueName;
2784}
2785
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002786status_t SurfaceFlinger::createNormalLayer(const sp<Client>& client,
2787 const String8& name, uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
2788 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
2789{
2790 // initialize the surfaces
2791 switch (format) {
2792 case PIXEL_FORMAT_TRANSPARENT:
2793 case PIXEL_FORMAT_TRANSLUCENT:
2794 format = PIXEL_FORMAT_RGBA_8888;
2795 break;
2796 case PIXEL_FORMAT_OPAQUE:
2797 format = PIXEL_FORMAT_RGBX_8888;
2798 break;
2799 }
2800
2801 *outLayer = new Layer(this, client, name, w, h, flags);
2802 status_t err = (*outLayer)->setBuffers(w, h, format, flags);
2803 if (err == NO_ERROR) {
2804 *handle = (*outLayer)->getHandle();
2805 *gbp = (*outLayer)->getProducer();
2806 }
2807
2808 ALOGE_IF(err, "createNormalLayer() failed (%s)", strerror(-err));
2809 return err;
2810}
2811
chaviw13fdc492017-06-27 12:40:18 -07002812status_t SurfaceFlinger::createColorLayer(const sp<Client>& client,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002813 const String8& name, uint32_t w, uint32_t h, uint32_t flags,
2814 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
2815{
chaviw13fdc492017-06-27 12:40:18 -07002816 *outLayer = new ColorLayer(this, client, name, w, h, flags);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002817 *handle = (*outLayer)->getHandle();
2818 *gbp = (*outLayer)->getProducer();
2819 return NO_ERROR;
2820}
2821
2822status_t SurfaceFlinger::onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle)
2823{
Robert Carr9524cb32017-02-13 11:32:32 -08002824 // called by a client when it wants to remove a Layer
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002825 status_t err = NO_ERROR;
2826 sp<Layer> l(client->getLayerUser(handle));
2827 if (l != NULL) {
2828 mInterceptor.saveSurfaceDeletion(l);
2829 err = removeLayer(l);
2830 ALOGE_IF(err<0 && err != NAME_NOT_FOUND,
2831 "error removing layer=%p (%s)", l.get(), strerror(-err));
2832 }
2833 return err;
2834}
2835
2836status_t SurfaceFlinger::onLayerDestroyed(const wp<Layer>& layer)
2837{
2838 // called by ~LayerCleaner() when all references to the IBinder (handle)
2839 // are gone
Robert Carr9524cb32017-02-13 11:32:32 -08002840 sp<Layer> l = layer.promote();
2841 if (l == nullptr) {
2842 // The layer has already been removed, carry on
2843 return NO_ERROR;
Robert Carr9524cb32017-02-13 11:32:32 -08002844 }
Chia-I Wu515dc9c2017-06-15 12:53:59 -07002845 // If we have a parent, then we can continue to live as long as it does.
2846 return removeLayer(l, true);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002847}
2848
2849// ---------------------------------------------------------------------------
2850
2851void SurfaceFlinger::onInitializeDisplays() {
2852 // reset screen orientation and use primary layer stack
2853 Vector<ComposerState> state;
2854 Vector<DisplayState> displays;
2855 DisplayState d;
2856 d.what = DisplayState::eDisplayProjectionChanged |
2857 DisplayState::eLayerStackChanged;
2858 d.token = mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY];
2859 d.layerStack = 0;
2860 d.orientation = DisplayState::eOrientationDefault;
2861 d.frame.makeInvalid();
2862 d.viewport.makeInvalid();
2863 d.width = 0;
2864 d.height = 0;
2865 displays.add(d);
2866 setTransactionState(state, displays, 0);
2867 setPowerModeInternal(getDisplayDevice(d.token), HWC_POWER_MODE_NORMAL);
2868
2869 const nsecs_t period =
2870 getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
2871 mAnimFrameTracker.setDisplayRefreshPeriod(period);
Brian Andersond0010582017-03-07 13:20:31 -08002872
2873 // Use phase of 0 since phase is not known.
2874 // Use latency of 0, which will snap to the ideal latency.
2875 setCompositorTimingSnapped(0, period, 0);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002876}
2877
2878void SurfaceFlinger::initializeDisplays() {
2879 class MessageScreenInitialized : public MessageBase {
2880 SurfaceFlinger* flinger;
2881 public:
2882 explicit MessageScreenInitialized(SurfaceFlinger* flinger) : flinger(flinger) { }
2883 virtual bool handler() {
2884 flinger->onInitializeDisplays();
2885 return true;
2886 }
2887 };
2888 sp<MessageBase> msg = new MessageScreenInitialized(this);
2889 postMessageAsync(msg); // we may be called from main thread, use async message
2890}
2891
2892void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& hw,
2893 int mode) {
2894 ALOGD("Set power mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(),
2895 this);
2896 int32_t type = hw->getDisplayType();
2897 int currentMode = hw->getPowerMode();
2898
2899 if (mode == currentMode) {
2900 ALOGD("Screen type=%d is already mode=%d", hw->getDisplayType(), mode);
2901 return;
2902 }
2903
2904 hw->setPowerMode(mode);
2905 if (type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
2906 ALOGW("Trying to set power mode for virtual display");
2907 return;
2908 }
2909
2910 if (mInterceptor.isEnabled()) {
2911 Mutex::Autolock _l(mStateLock);
2912 ssize_t idx = mCurrentState.displays.indexOfKey(hw->getDisplayToken());
2913 if (idx < 0) {
2914 ALOGW("Surface Interceptor SavePowerMode: invalid display token");
2915 return;
2916 }
2917 mInterceptor.savePowerModeUpdate(mCurrentState.displays.valueAt(idx).displayId, mode);
2918 }
2919
2920 if (currentMode == HWC_POWER_MODE_OFF) {
2921 // Turn on the display
2922 getHwComposer().setPowerMode(type, mode);
Matthew Bouyack38d49612017-05-12 12:49:32 -07002923 if (type == DisplayDevice::DISPLAY_PRIMARY &&
2924 mode != HWC_POWER_MODE_DOZE_SUSPEND) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002925 // FIXME: eventthread only knows about the main display right now
2926 mEventThread->onScreenAcquired();
2927 resyncToHardwareVsync(true);
2928 }
2929
2930 mVisibleRegionsDirty = true;
2931 mHasPoweredOff = true;
2932 repaintEverything();
2933
2934 struct sched_param param = {0};
2935 param.sched_priority = 1;
2936 if (sched_setscheduler(0, SCHED_FIFO, &param) != 0) {
2937 ALOGW("Couldn't set SCHED_FIFO on display on");
2938 }
2939 } else if (mode == HWC_POWER_MODE_OFF) {
2940 // Turn off the display
2941 struct sched_param param = {0};
2942 if (sched_setscheduler(0, SCHED_OTHER, &param) != 0) {
2943 ALOGW("Couldn't set SCHED_OTHER on display off");
2944 }
2945
2946 if (type == DisplayDevice::DISPLAY_PRIMARY) {
2947 disableHardwareVsync(true); // also cancels any in-progress resync
2948
2949 // FIXME: eventthread only knows about the main display right now
2950 mEventThread->onScreenReleased();
2951 }
2952
2953 getHwComposer().setPowerMode(type, mode);
2954 mVisibleRegionsDirty = true;
2955 // from this point on, SF will stop drawing on this display
Matthew Bouyack38d49612017-05-12 12:49:32 -07002956 } else if (mode == HWC_POWER_MODE_DOZE ||
2957 mode == HWC_POWER_MODE_NORMAL) {
Zheng Zhang8a43fe62017-03-17 11:19:39 +01002958 // Update display while dozing
2959 getHwComposer().setPowerMode(type, mode);
2960 if (type == DisplayDevice::DISPLAY_PRIMARY) {
2961 // FIXME: eventthread only knows about the main display right now
2962 mEventThread->onScreenAcquired();
2963 resyncToHardwareVsync(true);
2964 }
2965 } else if (mode == HWC_POWER_MODE_DOZE_SUSPEND) {
2966 // Leave display going to doze
2967 if (type == DisplayDevice::DISPLAY_PRIMARY) {
2968 disableHardwareVsync(true); // also cancels any in-progress resync
2969 // FIXME: eventthread only knows about the main display right now
2970 mEventThread->onScreenReleased();
2971 }
2972 getHwComposer().setPowerMode(type, mode);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002973 } else {
Matthew Bouyack38d49612017-05-12 12:49:32 -07002974 ALOGE("Attempting to set unknown power mode: %d\n", mode);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00002975 getHwComposer().setPowerMode(type, mode);
2976 }
2977}
2978
2979void SurfaceFlinger::setPowerMode(const sp<IBinder>& display, int mode) {
2980 class MessageSetPowerMode: public MessageBase {
2981 SurfaceFlinger& mFlinger;
2982 sp<IBinder> mDisplay;
2983 int mMode;
2984 public:
2985 MessageSetPowerMode(SurfaceFlinger& flinger,
2986 const sp<IBinder>& disp, int mode) : mFlinger(flinger),
2987 mDisplay(disp) { mMode = mode; }
2988 virtual bool handler() {
2989 sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
2990 if (hw == NULL) {
2991 ALOGE("Attempt to set power mode = %d for null display %p",
2992 mMode, mDisplay.get());
2993 } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) {
2994 ALOGW("Attempt to set power mode = %d for virtual display",
2995 mMode);
2996 } else {
2997 mFlinger.setPowerModeInternal(hw, mMode);
2998 }
2999 return true;
3000 }
3001 };
3002 sp<MessageBase> msg = new MessageSetPowerMode(*this, display, mode);
3003 postMessageSync(msg);
3004}
3005
3006// ---------------------------------------------------------------------------
3007
Vishnu Nair6a408532017-10-24 09:11:27 -07003008status_t SurfaceFlinger::doDump(int fd, const Vector<String16>& args, bool asProto) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003009 String8 result;
3010
3011 IPCThreadState* ipc = IPCThreadState::self();
3012 const int pid = ipc->getCallingPid();
3013 const int uid = ipc->getCallingUid();
Vishnu Nair6a408532017-10-24 09:11:27 -07003014
3015 if (asProto) {
3016 // Return early as SurfaceFlinger does not support dumping sections in proto format
3017 return OK;
3018 }
3019
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003020 if ((uid != AID_SHELL) &&
3021 !PermissionCache::checkPermission(sDump, pid, uid)) {
3022 result.appendFormat("Permission Denial: "
3023 "can't dump SurfaceFlinger from pid=%d, uid=%d\n", pid, uid);
3024 } else {
3025 // Try to get the main lock, but give up after one second
3026 // (this would indicate SF is stuck, but we want to be able to
3027 // print something in dumpsys).
3028 status_t err = mStateLock.timedLock(s2ns(1));
3029 bool locked = (err == NO_ERROR);
3030 if (!locked) {
3031 result.appendFormat(
3032 "SurfaceFlinger appears to be unresponsive (%s [%d]), "
3033 "dumping anyways (no locks held)\n", strerror(-err), err);
3034 }
3035
3036 bool dumpAll = true;
3037 size_t index = 0;
3038 size_t numArgs = args.size();
3039 if (numArgs) {
3040 if ((index < numArgs) &&
3041 (args[index] == String16("--list"))) {
3042 index++;
3043 listLayersLocked(args, index, result);
3044 dumpAll = false;
3045 }
3046
3047 if ((index < numArgs) &&
3048 (args[index] == String16("--latency"))) {
3049 index++;
3050 dumpStatsLocked(args, index, result);
3051 dumpAll = false;
3052 }
3053
3054 if ((index < numArgs) &&
3055 (args[index] == String16("--latency-clear"))) {
3056 index++;
3057 clearStatsLocked(args, index, result);
3058 dumpAll = false;
3059 }
3060
3061 if ((index < numArgs) &&
3062 (args[index] == String16("--dispsync"))) {
3063 index++;
3064 mPrimaryDispSync.dump(result);
3065 dumpAll = false;
3066 }
3067
3068 if ((index < numArgs) &&
3069 (args[index] == String16("--static-screen"))) {
3070 index++;
3071 dumpStaticScreenStats(result);
3072 dumpAll = false;
3073 }
3074
3075 if ((index < numArgs) &&
Brian Andersond6927fb2016-07-23 23:37:30 -07003076 (args[index] == String16("--frame-events"))) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003077 index++;
Brian Andersond6927fb2016-07-23 23:37:30 -07003078 dumpFrameEventsLocked(result);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003079 dumpAll = false;
3080 }
3081 }
3082
3083 if (dumpAll) {
3084 dumpAllLocked(args, index, result);
3085 }
3086
3087 if (locked) {
3088 mStateLock.unlock();
3089 }
3090 }
3091 write(fd, result.string(), result.size());
3092 return NO_ERROR;
3093}
3094
3095void SurfaceFlinger::listLayersLocked(const Vector<String16>& /* args */,
3096 size_t& /* index */, String8& result) const
3097{
Robert Carr2047fae2016-11-28 14:09:09 -08003098 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003099 result.appendFormat("%s\n", layer->getName().string());
Robert Carr2047fae2016-11-28 14:09:09 -08003100 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003101}
3102
3103void SurfaceFlinger::dumpStatsLocked(const Vector<String16>& args, size_t& index,
3104 String8& result) const
3105{
3106 String8 name;
3107 if (index < args.size()) {
3108 name = String8(args[index]);
3109 index++;
3110 }
3111
3112 const nsecs_t period =
3113 getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
3114 result.appendFormat("%" PRId64 "\n", period);
3115
3116 if (name.isEmpty()) {
3117 mAnimFrameTracker.dumpStats(result);
3118 } else {
Robert Carr2047fae2016-11-28 14:09:09 -08003119 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003120 if (name == layer->getName()) {
3121 layer->dumpFrameStats(result);
3122 }
Robert Carr2047fae2016-11-28 14:09:09 -08003123 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003124 }
3125}
3126
3127void SurfaceFlinger::clearStatsLocked(const Vector<String16>& args, size_t& index,
3128 String8& /* result */)
3129{
3130 String8 name;
3131 if (index < args.size()) {
3132 name = String8(args[index]);
3133 index++;
3134 }
3135
Robert Carr2047fae2016-11-28 14:09:09 -08003136 mCurrentState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003137 if (name.isEmpty() || (name == layer->getName())) {
3138 layer->clearFrameStats();
3139 }
Robert Carr2047fae2016-11-28 14:09:09 -08003140 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003141
3142 mAnimFrameTracker.clearStats();
3143}
3144
3145// This should only be called from the main thread. Otherwise it would need
3146// the lock and should use mCurrentState rather than mDrawingState.
3147void SurfaceFlinger::logFrameStats() {
Robert Carr2047fae2016-11-28 14:09:09 -08003148 mDrawingState.traverseInZOrder([&](Layer* layer) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003149 layer->logFrameStats();
Robert Carr2047fae2016-11-28 14:09:09 -08003150 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003151
3152 mAnimFrameTracker.logAndResetStats(String8("<win-anim>"));
3153}
3154
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08003155void SurfaceFlinger::appendSfConfigString(String8& result) const
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003156{
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08003157 result.append(" [sf");
Fabien Sanglardc93afd52017-03-13 13:02:42 -07003158 result.appendFormat(" HAS_CONTEXT_PRIORITY=%d", useContextPriority);
3159
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08003160 if (isLayerTripleBufferingDisabled())
3161 result.append(" DISABLE_TRIPLE_BUFFERING");
Fabien Sanglarda34ed632017-03-14 11:43:52 -07003162
Fabien Sanglardc45a7d92017-03-14 13:24:22 -07003163 result.appendFormat(" PRESENT_TIME_OFFSET=%" PRId64, dispSyncPresentTimeOffset);
Fabien Sanglarda34ed632017-03-14 11:43:52 -07003164 result.appendFormat(" FORCE_HWC_FOR_RBG_TO_YUV=%d", useHwcForRgbToYuv);
Fabien Sanglardc8e387e2017-03-10 10:30:28 -08003165 result.appendFormat(" MAX_VIRT_DISPLAY_DIM=%" PRIu64, maxVirtualDisplaySize);
Fabien Sanglardcbf153b2017-03-10 17:57:12 -08003166 result.appendFormat(" RUNNING_WITHOUT_SYNC_FRAMEWORK=%d", !hasSyncFramework);
Fabien Sanglard1971b632017-03-10 14:50:03 -08003167 result.appendFormat(" NUM_FRAMEBUFFER_SURFACE_BUFFERS=%" PRId64,
3168 maxFrameBufferAcquiredBuffers);
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08003169 result.append("]");
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003170}
3171
3172void SurfaceFlinger::dumpStaticScreenStats(String8& result) const
3173{
3174 result.appendFormat("Static screen stats:\n");
3175 for (size_t b = 0; b < NUM_BUCKETS - 1; ++b) {
3176 float bucketTimeSec = mFrameBuckets[b] / 1e9;
3177 float percent = 100.0f *
3178 static_cast<float>(mFrameBuckets[b]) / mTotalTime;
3179 result.appendFormat(" < %zd frames: %.3f s (%.1f%%)\n",
3180 b + 1, bucketTimeSec, percent);
3181 }
3182 float bucketTimeSec = mFrameBuckets[NUM_BUCKETS - 1] / 1e9;
3183 float percent = 100.0f *
3184 static_cast<float>(mFrameBuckets[NUM_BUCKETS - 1]) / mTotalTime;
3185 result.appendFormat(" %zd+ frames: %.3f s (%.1f%%)\n",
3186 NUM_BUCKETS - 1, bucketTimeSec, percent);
3187}
3188
Brian Andersond6927fb2016-07-23 23:37:30 -07003189void SurfaceFlinger::dumpFrameEventsLocked(String8& result) {
3190 result.appendFormat("Layer frame timestamps:\n");
3191
3192 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
3193 const size_t count = currentLayers.size();
3194 for (size_t i=0 ; i<count ; i++) {
3195 currentLayers[i]->dumpFrameEvents(result);
3196 }
3197}
3198
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003199void SurfaceFlinger::recordBufferingStats(const char* layerName,
3200 std::vector<OccupancyTracker::Segment>&& history) {
3201 Mutex::Autolock lock(mBufferingStatsMutex);
3202 auto& stats = mBufferingStats[layerName];
3203 for (const auto& segment : history) {
3204 if (!segment.usedThirdBuffer) {
3205 stats.twoBufferTime += segment.totalTime;
3206 }
3207 if (segment.occupancyAverage < 1.0f) {
3208 stats.doubleBufferedTime += segment.totalTime;
3209 } else if (segment.occupancyAverage < 2.0f) {
3210 stats.tripleBufferedTime += segment.totalTime;
3211 }
3212 ++stats.numSegments;
3213 stats.totalTime += segment.totalTime;
3214 }
3215}
3216
3217void SurfaceFlinger::dumpBufferingStats(String8& result) const {
3218 result.append("Buffering stats:\n");
3219 result.append(" [Layer name] <Active time> <Two buffer> "
3220 "<Double buffered> <Triple buffered>\n");
3221 Mutex::Autolock lock(mBufferingStatsMutex);
3222 typedef std::tuple<std::string, float, float, float> BufferTuple;
3223 std::map<float, BufferTuple, std::greater<float>> sorted;
3224 for (const auto& statsPair : mBufferingStats) {
3225 const char* name = statsPair.first.c_str();
3226 const BufferingStats& stats = statsPair.second;
3227 if (stats.numSegments == 0) {
3228 continue;
3229 }
3230 float activeTime = ns2ms(stats.totalTime) / 1000.0f;
3231 float twoBufferRatio = static_cast<float>(stats.twoBufferTime) /
3232 stats.totalTime;
3233 float doubleBufferRatio = static_cast<float>(
3234 stats.doubleBufferedTime) / stats.totalTime;
3235 float tripleBufferRatio = static_cast<float>(
3236 stats.tripleBufferedTime) / stats.totalTime;
3237 sorted.insert({activeTime, {name, twoBufferRatio,
3238 doubleBufferRatio, tripleBufferRatio}});
3239 }
3240 for (const auto& sortedPair : sorted) {
3241 float activeTime = sortedPair.first;
3242 const BufferTuple& values = sortedPair.second;
3243 result.appendFormat(" [%s] %.2f %.3f %.3f %.3f\n",
3244 std::get<0>(values).c_str(), activeTime,
3245 std::get<1>(values), std::get<2>(values),
3246 std::get<3>(values));
3247 }
3248 result.append("\n");
3249}
3250
3251void SurfaceFlinger::dumpAllLocked(const Vector<String16>& args, size_t& index,
3252 String8& result) const
3253{
3254 bool colorize = false;
3255 if (index < args.size()
3256 && (args[index] == String16("--color"))) {
3257 colorize = true;
3258 index++;
3259 }
3260
3261 Colorizer colorizer(colorize);
3262
3263 // figure out if we're stuck somewhere
3264 const nsecs_t now = systemTime();
3265 const nsecs_t inSwapBuffers(mDebugInSwapBuffers);
3266 const nsecs_t inTransaction(mDebugInTransaction);
3267 nsecs_t inSwapBuffersDuration = (inSwapBuffers) ? now-inSwapBuffers : 0;
3268 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
3269
3270 /*
3271 * Dump library configuration.
3272 */
3273
3274 colorizer.bold(result);
3275 result.append("Build configuration:");
3276 colorizer.reset(result);
3277 appendSfConfigString(result);
3278 appendUiConfigString(result);
3279 appendGuiConfigString(result);
3280 result.append("\n");
3281
3282 colorizer.bold(result);
3283 result.append("Sync configuration: ");
3284 colorizer.reset(result);
3285 result.append(SyncFeatures::getInstance().toString());
3286 result.append("\n");
3287
3288 colorizer.bold(result);
3289 result.append("DispSync configuration: ");
3290 colorizer.reset(result);
3291 result.appendFormat("app phase %" PRId64 " ns, sf phase %" PRId64 " ns, "
Fabien Sanglardc45a7d92017-03-14 13:24:22 -07003292 "present offset %" PRId64 " ns (refresh %" PRId64 " ns)",
3293 vsyncPhaseOffsetNs, sfVsyncPhaseOffsetNs, dispSyncPresentTimeOffset,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003294 mHwc->getRefreshPeriod(HWC_DISPLAY_PRIMARY));
3295 result.append("\n");
3296
3297 // Dump static screen stats
3298 result.append("\n");
3299 dumpStaticScreenStats(result);
3300 result.append("\n");
3301
3302 dumpBufferingStats(result);
3303
3304 /*
3305 * Dump the visible layer list
3306 */
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003307 colorizer.bold(result);
Robert Carr1f0a16a2016-10-24 16:27:39 -07003308 result.appendFormat("Visible layers (count = %zu)\n", mNumLayers);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003309 colorizer.reset(result);
Robert Carr2047fae2016-11-28 14:09:09 -08003310 mCurrentState.traverseInZOrder([&](Layer* layer) {
Kalle Raitaa099a242017-01-11 11:17:29 -08003311 result.append(to_string(layer->getLayerDebugInfo()).c_str());
Robert Carr2047fae2016-11-28 14:09:09 -08003312 });
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003313
3314 /*
3315 * Dump Display state
3316 */
3317
3318 colorizer.bold(result);
3319 result.appendFormat("Displays (%zu entries)\n", mDisplays.size());
3320 colorizer.reset(result);
3321 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
3322 const sp<const DisplayDevice>& hw(mDisplays[dpy]);
3323 hw->dump(result);
3324 }
3325
3326 /*
3327 * Dump SurfaceFlinger global state
3328 */
3329
3330 colorizer.bold(result);
3331 result.append("SurfaceFlinger global state:\n");
3332 colorizer.reset(result);
3333
3334 HWComposer& hwc(getHwComposer());
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07003335 sp<const DisplayDevice> hw(getDefaultDisplayDeviceLocked());
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003336
3337 colorizer.bold(result);
3338 result.appendFormat("EGL implementation : %s\n",
3339 eglQueryStringImplementationANDROID(mEGLDisplay, EGL_VERSION));
3340 colorizer.reset(result);
3341 result.appendFormat("%s\n",
3342 eglQueryStringImplementationANDROID(mEGLDisplay, EGL_EXTENSIONS));
3343
3344 mRenderEngine->dump(result);
3345
3346 hw->undefinedRegion.dump(result, "undefinedRegion");
3347 result.appendFormat(" orientation=%d, isDisplayOn=%d\n",
3348 hw->getOrientation(), hw->isDisplayOn());
3349 result.appendFormat(
3350 " last eglSwapBuffers() time: %f us\n"
3351 " last transaction time : %f us\n"
3352 " transaction-flags : %08x\n"
3353 " refresh-rate : %f fps\n"
3354 " x-dpi : %f\n"
3355 " y-dpi : %f\n"
3356 " gpu_to_cpu_unsupported : %d\n"
3357 ,
3358 mLastSwapBufferTime/1000.0,
3359 mLastTransactionTime/1000.0,
3360 mTransactionFlags,
3361 1e9 / hwc.getRefreshPeriod(HWC_DISPLAY_PRIMARY),
3362 hwc.getDpiX(HWC_DISPLAY_PRIMARY),
3363 hwc.getDpiY(HWC_DISPLAY_PRIMARY),
3364 !mGpuToCpuSupported);
3365
3366 result.appendFormat(" eglSwapBuffers time: %f us\n",
3367 inSwapBuffersDuration/1000.0);
3368
3369 result.appendFormat(" transaction time: %f us\n",
3370 inTransactionDuration/1000.0);
3371
3372 /*
3373 * VSYNC state
3374 */
3375 mEventThread->dump(result);
3376
3377 /*
3378 * Dump HWComposer state
3379 */
3380 colorizer.bold(result);
3381 result.append("h/w composer state:\n");
3382 colorizer.reset(result);
3383 result.appendFormat(" h/w composer %s and %s\n",
3384 hwc.initCheck()==NO_ERROR ? "present" : "not present",
3385 (mDebugDisableHWC || mDebugRegion || mDaltonize
3386 || mHasColorMatrix) ? "disabled" : "enabled");
3387 hwc.dump(result);
3388
3389 /*
3390 * Dump gralloc state
3391 */
3392 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
3393 alloc.dump(result);
3394}
3395
3396const Vector< sp<Layer> >&
3397SurfaceFlinger::getLayerSortedByZForHwcDisplay(int id) {
3398 // Note: mStateLock is held here
3399 wp<IBinder> dpy;
3400 for (size_t i=0 ; i<mDisplays.size() ; i++) {
3401 if (mDisplays.valueAt(i)->getHwcDisplayId() == id) {
3402 dpy = mDisplays.keyAt(i);
3403 break;
3404 }
3405 }
3406 if (dpy == NULL) {
3407 ALOGE("getLayerSortedByZForHwcDisplay: invalid hwc display id %d", id);
3408 // Just use the primary display so we have something to return
3409 dpy = getBuiltInDisplay(DisplayDevice::DISPLAY_PRIMARY);
3410 }
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07003411 return getDisplayDeviceLocked(dpy)->getVisibleLayersSortedByZ();
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003412}
3413
3414bool SurfaceFlinger::startDdmConnection()
3415{
3416 void* libddmconnection_dso =
3417 dlopen("libsurfaceflinger_ddmconnection.so", RTLD_NOW);
3418 if (!libddmconnection_dso) {
3419 return false;
3420 }
3421 void (*DdmConnection_start)(const char* name);
3422 DdmConnection_start =
3423 (decltype(DdmConnection_start))dlsym(libddmconnection_dso, "DdmConnection_start");
3424 if (!DdmConnection_start) {
3425 dlclose(libddmconnection_dso);
3426 return false;
3427 }
3428 (*DdmConnection_start)(getServiceName());
3429 return true;
3430}
3431
3432status_t SurfaceFlinger::onTransact(
3433 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
3434{
3435 switch (code) {
3436 case CREATE_CONNECTION:
3437 case CREATE_DISPLAY:
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003438 case BOOT_FINISHED:
3439 case CLEAR_ANIMATION_FRAME_STATS:
3440 case GET_ANIMATION_FRAME_STATS:
3441 case SET_POWER_MODE:
3442 case GET_HDR_CAPABILITIES:
3443 {
3444 // codes that require permission check
3445 IPCThreadState* ipc = IPCThreadState::self();
3446 const int pid = ipc->getCallingPid();
3447 const int uid = ipc->getCallingUid();
3448 if ((uid != AID_GRAPHICS && uid != AID_SYSTEM) &&
3449 !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)) {
3450 ALOGE("Permission Denial: "
3451 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
3452 return PERMISSION_DENIED;
3453 }
3454 break;
3455 }
Robert Carr1db73f62016-12-21 12:58:51 -08003456 /*
3457 * Calling setTransactionState is safe, because you need to have been
3458 * granted a reference to Client* and Handle* to do anything with it.
3459 *
3460 * Creating a scoped connection is safe, as per discussion in ISurfaceComposer.h
3461 */
3462 case SET_TRANSACTION_STATE:
3463 case CREATE_SCOPED_CONNECTION:
3464 {
3465 break;
3466 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003467 case CAPTURE_SCREEN:
3468 {
3469 // codes that require permission check
3470 IPCThreadState* ipc = IPCThreadState::self();
3471 const int pid = ipc->getCallingPid();
3472 const int uid = ipc->getCallingUid();
3473 if ((uid != AID_GRAPHICS) &&
3474 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
3475 ALOGE("Permission Denial: "
3476 "can't read framebuffer pid=%d, uid=%d", pid, uid);
3477 return PERMISSION_DENIED;
3478 }
3479 break;
3480 }
3481 }
3482
3483 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
3484 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
3485 CHECK_INTERFACE(ISurfaceComposer, data, reply);
3486 if (CC_UNLIKELY(!PermissionCache::checkCallingPermission(sHardwareTest))) {
3487 IPCThreadState* ipc = IPCThreadState::self();
3488 const int pid = ipc->getCallingPid();
3489 const int uid = ipc->getCallingUid();
3490 ALOGE("Permission Denial: "
3491 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
3492 return PERMISSION_DENIED;
3493 }
3494 int n;
3495 switch (code) {
3496 case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
3497 case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
3498 return NO_ERROR;
3499 case 1002: // SHOW_UPDATES
3500 n = data.readInt32();
3501 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
3502 invalidateHwcGeometry();
3503 repaintEverything();
3504 return NO_ERROR;
3505 case 1004:{ // repaint everything
3506 repaintEverything();
3507 return NO_ERROR;
3508 }
3509 case 1005:{ // force transaction
3510 setTransactionFlags(
3511 eTransactionNeeded|
3512 eDisplayTransactionNeeded|
3513 eTraversalNeeded);
3514 return NO_ERROR;
3515 }
3516 case 1006:{ // send empty update
3517 signalRefresh();
3518 return NO_ERROR;
3519 }
3520 case 1008: // toggle use of hw composer
3521 n = data.readInt32();
3522 mDebugDisableHWC = n ? 1 : 0;
3523 invalidateHwcGeometry();
3524 repaintEverything();
3525 return NO_ERROR;
3526 case 1009: // toggle use of transform hint
3527 n = data.readInt32();
3528 mDebugDisableTransformHint = n ? 1 : 0;
3529 invalidateHwcGeometry();
3530 repaintEverything();
3531 return NO_ERROR;
3532 case 1010: // interrogate.
3533 reply->writeInt32(0);
3534 reply->writeInt32(0);
3535 reply->writeInt32(mDebugRegion);
3536 reply->writeInt32(0);
3537 reply->writeInt32(mDebugDisableHWC);
3538 return NO_ERROR;
3539 case 1013: {
3540 Mutex::Autolock _l(mStateLock);
3541 sp<const DisplayDevice> hw(getDefaultDisplayDevice());
3542 reply->writeInt32(hw->getPageFlipCount());
3543 return NO_ERROR;
3544 }
3545 case 1014: {
3546 // daltonize
3547 n = data.readInt32();
3548 switch (n % 10) {
3549 case 1:
3550 mDaltonizer.setType(ColorBlindnessType::Protanomaly);
3551 break;
3552 case 2:
3553 mDaltonizer.setType(ColorBlindnessType::Deuteranomaly);
3554 break;
3555 case 3:
3556 mDaltonizer.setType(ColorBlindnessType::Tritanomaly);
3557 break;
3558 }
3559 if (n >= 10) {
3560 mDaltonizer.setMode(ColorBlindnessMode::Correction);
3561 } else {
3562 mDaltonizer.setMode(ColorBlindnessMode::Simulation);
3563 }
3564 mDaltonize = n > 0;
3565 invalidateHwcGeometry();
3566 repaintEverything();
3567 return NO_ERROR;
3568 }
3569 case 1015: {
3570 // apply a color matrix
3571 n = data.readInt32();
3572 mHasColorMatrix = n ? 1 : 0;
3573 if (n) {
3574 // color matrix is sent as mat3 matrix followed by vec3
3575 // offset, then packed into a mat4 where the last row is
3576 // the offset and extra values are 0
3577 for (size_t i = 0 ; i < 4; i++) {
3578 for (size_t j = 0; j < 4; j++) {
3579 mColorMatrix[i][j] = data.readFloat();
3580 }
3581 }
3582 } else {
3583 mColorMatrix = mat4();
3584 }
3585 invalidateHwcGeometry();
3586 repaintEverything();
3587 return NO_ERROR;
3588 }
3589 // This is an experimental interface
3590 // Needs to be shifted to proper binder interface when we productize
3591 case 1016: {
3592 n = data.readInt32();
3593 mPrimaryDispSync.setRefreshSkipCount(n);
3594 return NO_ERROR;
3595 }
3596 case 1017: {
3597 n = data.readInt32();
3598 mForceFullDamage = static_cast<bool>(n);
3599 return NO_ERROR;
3600 }
3601 case 1018: { // Modify Choreographer's phase offset
3602 n = data.readInt32();
3603 mEventThread->setPhaseOffset(static_cast<nsecs_t>(n));
3604 return NO_ERROR;
3605 }
3606 case 1019: { // Modify SurfaceFlinger's phase offset
3607 n = data.readInt32();
3608 mSFEventThread->setPhaseOffset(static_cast<nsecs_t>(n));
3609 return NO_ERROR;
3610 }
3611 case 1020: { // Layer updates interceptor
3612 n = data.readInt32();
3613 if (n) {
3614 ALOGV("Interceptor enabled");
3615 mInterceptor.enable(mDrawingState.layersSortedByZ, mDrawingState.displays);
3616 }
3617 else{
3618 ALOGV("Interceptor disabled");
3619 mInterceptor.disable();
3620 }
3621 return NO_ERROR;
3622 }
3623 case 1021: { // Disable HWC virtual displays
3624 n = data.readInt32();
3625 mUseHwcVirtualDisplays = !n;
3626 return NO_ERROR;
3627 }
3628 }
3629 }
3630 return err;
3631}
3632
3633void SurfaceFlinger::repaintEverything() {
3634 android_atomic_or(1, &mRepaintEverything);
3635 signalTransaction();
3636}
3637
3638// ---------------------------------------------------------------------------
3639// Capture screen into an IGraphiBufferProducer
3640// ---------------------------------------------------------------------------
3641
3642/* The code below is here to handle b/8734824
3643 *
3644 * We create a IGraphicBufferProducer wrapper that forwards all calls
3645 * from the surfaceflinger thread to the calling binder thread, where they
3646 * are executed. This allows the calling thread in the calling process to be
3647 * reused and not depend on having "enough" binder threads to handle the
3648 * requests.
3649 */
3650class GraphicProducerWrapper : public BBinder, public MessageHandler {
3651 /* Parts of GraphicProducerWrapper are run on two different threads,
3652 * communicating by sending messages via Looper but also by shared member
3653 * data. Coherence maintenance is subtle and in places implicit (ugh).
3654 *
3655 * Don't rely on Looper's sendMessage/handleMessage providing
3656 * release/acquire semantics for any data not actually in the Message.
3657 * Data going from surfaceflinger to binder threads needs to be
3658 * synchronized explicitly.
3659 *
3660 * Barrier open/wait do provide release/acquire semantics. This provides
3661 * implicit synchronization for data coming back from binder to
3662 * surfaceflinger threads.
3663 */
3664
3665 sp<IGraphicBufferProducer> impl;
3666 sp<Looper> looper;
3667 status_t result;
3668 bool exitPending;
3669 bool exitRequested;
3670 Barrier barrier;
3671 uint32_t code;
3672 Parcel const* data;
3673 Parcel* reply;
3674
3675 enum {
3676 MSG_API_CALL,
3677 MSG_EXIT
3678 };
3679
3680 /*
3681 * Called on surfaceflinger thread. This is called by our "fake"
3682 * BpGraphicBufferProducer. We package the data and reply Parcel and
3683 * forward them to the binder thread.
3684 */
3685 virtual status_t transact(uint32_t code,
3686 const Parcel& data, Parcel* reply, uint32_t /* flags */) {
3687 this->code = code;
3688 this->data = &data;
3689 this->reply = reply;
3690 if (exitPending) {
3691 // if we've exited, we run the message synchronously right here.
3692 // note (JH): as far as I can tell from looking at the code, this
3693 // never actually happens. if it does, i'm not sure if it happens
3694 // on the surfaceflinger or binder thread.
3695 handleMessage(Message(MSG_API_CALL));
3696 } else {
3697 barrier.close();
3698 // Prevent stores to this->{code, data, reply} from being
3699 // reordered later than the construction of Message.
3700 atomic_thread_fence(memory_order_release);
3701 looper->sendMessage(this, Message(MSG_API_CALL));
3702 barrier.wait();
3703 }
3704 return result;
3705 }
3706
3707 /*
3708 * here we run on the binder thread. All we've got to do is
3709 * call the real BpGraphicBufferProducer.
3710 */
3711 virtual void handleMessage(const Message& message) {
3712 int what = message.what;
3713 // Prevent reads below from happening before the read from Message
3714 atomic_thread_fence(memory_order_acquire);
3715 if (what == MSG_API_CALL) {
3716 result = IInterface::asBinder(impl)->transact(code, data[0], reply);
3717 barrier.open();
3718 } else if (what == MSG_EXIT) {
3719 exitRequested = true;
3720 }
3721 }
3722
3723public:
3724 explicit GraphicProducerWrapper(const sp<IGraphicBufferProducer>& impl)
3725 : impl(impl),
3726 looper(new Looper(true)),
3727 result(NO_ERROR),
3728 exitPending(false),
3729 exitRequested(false),
3730 code(0),
3731 data(NULL),
3732 reply(NULL)
3733 {}
3734
3735 // Binder thread
3736 status_t waitForResponse() {
3737 do {
3738 looper->pollOnce(-1);
3739 } while (!exitRequested);
3740 return result;
3741 }
3742
3743 // Client thread
3744 void exit(status_t result) {
3745 this->result = result;
3746 exitPending = true;
3747 // Ensure this->result is visible to the binder thread before it
3748 // handles the message.
3749 atomic_thread_fence(memory_order_release);
3750 looper->sendMessage(this, Message(MSG_EXIT));
3751 }
3752};
3753
3754
3755status_t SurfaceFlinger::captureScreen(const sp<IBinder>& display,
3756 const sp<IGraphicBufferProducer>& producer,
3757 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Robert Carrae060832016-11-28 10:51:00 -08003758 int32_t minLayerZ, int32_t maxLayerZ,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003759 bool useIdentityTransform, ISurfaceComposer::Rotation rotation) {
3760
3761 if (CC_UNLIKELY(display == 0))
3762 return BAD_VALUE;
3763
3764 if (CC_UNLIKELY(producer == 0))
3765 return BAD_VALUE;
3766
3767 // if we have secure windows on this display, never allow the screen capture
3768 // unless the producer interface is local (i.e.: we can take a screenshot for
3769 // ourselves).
3770 bool isLocalScreenshot = IInterface::asBinder(producer)->localBinder();
3771
3772 // Convert to surfaceflinger's internal rotation type.
3773 Transform::orientation_flags rotationFlags;
3774 switch (rotation) {
3775 case ISurfaceComposer::eRotateNone:
3776 rotationFlags = Transform::ROT_0;
3777 break;
3778 case ISurfaceComposer::eRotate90:
3779 rotationFlags = Transform::ROT_90;
3780 break;
3781 case ISurfaceComposer::eRotate180:
3782 rotationFlags = Transform::ROT_180;
3783 break;
3784 case ISurfaceComposer::eRotate270:
3785 rotationFlags = Transform::ROT_270;
3786 break;
3787 default:
3788 rotationFlags = Transform::ROT_0;
3789 ALOGE("Invalid rotation passed to captureScreen(): %d\n", rotation);
3790 break;
3791 }
3792
3793 class MessageCaptureScreen : public MessageBase {
3794 SurfaceFlinger* flinger;
3795 sp<IBinder> display;
3796 sp<IGraphicBufferProducer> producer;
3797 Rect sourceCrop;
3798 uint32_t reqWidth, reqHeight;
Robert Carrae060832016-11-28 10:51:00 -08003799 int32_t minLayerZ,maxLayerZ;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003800 bool useIdentityTransform;
3801 Transform::orientation_flags rotation;
3802 status_t result;
3803 bool isLocalScreenshot;
3804 public:
3805 MessageCaptureScreen(SurfaceFlinger* flinger,
3806 const sp<IBinder>& display,
3807 const sp<IGraphicBufferProducer>& producer,
3808 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Robert Carrae060832016-11-28 10:51:00 -08003809 int32_t minLayerZ, int32_t maxLayerZ,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003810 bool useIdentityTransform,
3811 Transform::orientation_flags rotation,
3812 bool isLocalScreenshot)
3813 : flinger(flinger), display(display), producer(producer),
3814 sourceCrop(sourceCrop), reqWidth(reqWidth), reqHeight(reqHeight),
3815 minLayerZ(minLayerZ), maxLayerZ(maxLayerZ),
3816 useIdentityTransform(useIdentityTransform),
3817 rotation(rotation), result(PERMISSION_DENIED),
3818 isLocalScreenshot(isLocalScreenshot)
3819 {
3820 }
3821 status_t getResult() const {
3822 return result;
3823 }
3824 virtual bool handler() {
3825 Mutex::Autolock _l(flinger->mStateLock);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -07003826 sp<const DisplayDevice> hw(flinger->getDisplayDeviceLocked(display));
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003827 result = flinger->captureScreenImplLocked(hw, producer,
3828 sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ,
3829 useIdentityTransform, rotation, isLocalScreenshot);
3830 static_cast<GraphicProducerWrapper*>(IInterface::asBinder(producer).get())->exit(result);
3831 return true;
3832 }
3833 };
3834
3835 // this creates a "fake" BBinder which will serve as a "fake" remote
3836 // binder to receive the marshaled calls and forward them to the
3837 // real remote (a BpGraphicBufferProducer)
3838 sp<GraphicProducerWrapper> wrapper = new GraphicProducerWrapper(producer);
3839
3840 // the asInterface() call below creates our "fake" BpGraphicBufferProducer
3841 // which does the marshaling work forwards to our "fake remote" above.
3842 sp<MessageBase> msg = new MessageCaptureScreen(this,
3843 display, IGraphicBufferProducer::asInterface( wrapper ),
3844 sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ,
3845 useIdentityTransform, rotationFlags, isLocalScreenshot);
3846
3847 status_t res = postMessageAsync(msg);
3848 if (res == NO_ERROR) {
3849 res = wrapper->waitForResponse();
3850 }
3851 return res;
3852}
3853
3854
3855void SurfaceFlinger::renderScreenImplLocked(
3856 const sp<const DisplayDevice>& hw,
3857 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Robert Carrae060832016-11-28 10:51:00 -08003858 int32_t minLayerZ, int32_t maxLayerZ,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003859 bool yswap, bool useIdentityTransform, Transform::orientation_flags rotation)
3860{
3861 ATRACE_CALL();
3862 RenderEngine& engine(getRenderEngine());
3863
3864 // get screen geometry
3865 const int32_t hw_w = hw->getWidth();
3866 const int32_t hw_h = hw->getHeight();
3867 const bool filtering = static_cast<int32_t>(reqWidth) != hw_w ||
3868 static_cast<int32_t>(reqHeight) != hw_h;
3869
3870 // if a default or invalid sourceCrop is passed in, set reasonable values
3871 if (sourceCrop.width() == 0 || sourceCrop.height() == 0 ||
3872 !sourceCrop.isValid()) {
3873 sourceCrop.setLeftTop(Point(0, 0));
3874 sourceCrop.setRightBottom(Point(hw_w, hw_h));
3875 }
3876
3877 // ensure that sourceCrop is inside screen
3878 if (sourceCrop.left < 0) {
3879 ALOGE("Invalid crop rect: l = %d (< 0)", sourceCrop.left);
3880 }
3881 if (sourceCrop.right > hw_w) {
3882 ALOGE("Invalid crop rect: r = %d (> %d)", sourceCrop.right, hw_w);
3883 }
3884 if (sourceCrop.top < 0) {
3885 ALOGE("Invalid crop rect: t = %d (< 0)", sourceCrop.top);
3886 }
3887 if (sourceCrop.bottom > hw_h) {
3888 ALOGE("Invalid crop rect: b = %d (> %d)", sourceCrop.bottom, hw_h);
3889 }
3890
3891 // make sure to clear all GL error flags
3892 engine.checkErrors();
3893
3894 // set-up our viewport
3895 engine.setViewportAndProjection(
3896 reqWidth, reqHeight, sourceCrop, hw_h, yswap, rotation);
3897 engine.disableTexturing();
3898
3899 // redraw the screen entirely...
3900 engine.clearWithColor(0, 0, 0, 1);
3901
Robert Carr1f0a16a2016-10-24 16:27:39 -07003902 // We loop through the first level of layers without traversing,
3903 // as we need to interpret min/max layer Z in the top level Z space.
3904 for (const auto& layer : mDrawingState.layersSortedByZ) {
3905 if (layer->getLayerStack() != hw->getLayerStack()) {
3906 continue;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003907 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07003908 const Layer::State& state(layer->getDrawingState());
3909 if (state.z < minLayerZ || state.z > maxLayerZ) {
3910 continue;
3911 }
Dan Stoza412903f2017-04-27 13:42:17 -07003912 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003913 if (!layer->isVisible()) {
3914 return;
3915 }
3916 if (filtering) layer->setFiltering(true);
3917 layer->draw(hw, useIdentityTransform);
3918 if (filtering) layer->setFiltering(false);
3919 });
3920 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003921
3922 // compositionComplete is needed for older driver
3923 hw->compositionComplete();
3924 hw->setViewportAndProjection();
3925}
3926
3927
3928status_t SurfaceFlinger::captureScreenImplLocked(
3929 const sp<const DisplayDevice>& hw,
3930 const sp<IGraphicBufferProducer>& producer,
3931 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Robert Carrae060832016-11-28 10:51:00 -08003932 int32_t minLayerZ, int32_t maxLayerZ,
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003933 bool useIdentityTransform, Transform::orientation_flags rotation,
3934 bool isLocalScreenshot)
3935{
3936 ATRACE_CALL();
3937
3938 // get screen geometry
3939 uint32_t hw_w = hw->getWidth();
3940 uint32_t hw_h = hw->getHeight();
3941
3942 if (rotation & Transform::ROT_90) {
3943 std::swap(hw_w, hw_h);
3944 }
3945
3946 if ((reqWidth > hw_w) || (reqHeight > hw_h)) {
3947 ALOGE("size mismatch (%d, %d) > (%d, %d)",
3948 reqWidth, reqHeight, hw_w, hw_h);
3949 return BAD_VALUE;
3950 }
3951
3952 reqWidth = (!reqWidth) ? hw_w : reqWidth;
3953 reqHeight = (!reqHeight) ? hw_h : reqHeight;
3954
3955 bool secureLayerIsVisible = false;
Robert Carr1f0a16a2016-10-24 16:27:39 -07003956 for (const auto& layer : mDrawingState.layersSortedByZ) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003957 const Layer::State& state(layer->getDrawingState());
Robert Carr1f0a16a2016-10-24 16:27:39 -07003958 if ((layer->getLayerStack() != hw->getLayerStack()) ||
3959 (state.z < minLayerZ || state.z > maxLayerZ)) {
3960 continue;
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003961 }
Dan Stoza412903f2017-04-27 13:42:17 -07003962 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer *layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07003963 secureLayerIsVisible = secureLayerIsVisible || (layer->isVisible() &&
3964 layer->isSecure());
3965 });
3966 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00003967
3968 if (!isLocalScreenshot && secureLayerIsVisible) {
3969 ALOGW("FB is protected: PERMISSION_DENIED");
3970 return PERMISSION_DENIED;
3971 }
3972
3973 // create a surface (because we're a producer, and we need to
3974 // dequeue/queue a buffer)
3975 sp<Surface> sur = new Surface(producer, false);
3976 ANativeWindow* window = sur.get();
3977
3978 status_t result = native_window_api_connect(window, NATIVE_WINDOW_API_EGL);
3979 if (result == NO_ERROR) {
3980 uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
3981 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
3982
3983 int err = 0;
3984 err = native_window_set_buffers_dimensions(window, reqWidth, reqHeight);
3985 err |= native_window_set_scaling_mode(window, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
3986 err |= native_window_set_buffers_format(window, HAL_PIXEL_FORMAT_RGBA_8888);
3987 err |= native_window_set_usage(window, usage);
3988
3989 if (err == NO_ERROR) {
3990 ANativeWindowBuffer* buffer;
3991 /* TODO: Once we have the sync framework everywhere this can use
3992 * server-side waits on the fence that dequeueBuffer returns.
3993 */
3994 result = native_window_dequeue_buffer_and_wait(window, &buffer);
3995 if (result == NO_ERROR) {
3996 int syncFd = -1;
3997 // create an EGLImage from the buffer so we can later
3998 // turn it into a texture
3999 EGLImageKHR image = eglCreateImageKHR(mEGLDisplay, EGL_NO_CONTEXT,
4000 EGL_NATIVE_BUFFER_ANDROID, buffer, NULL);
4001 if (image != EGL_NO_IMAGE_KHR) {
4002 // this binds the given EGLImage as a framebuffer for the
4003 // duration of this scope.
4004 RenderEngine::BindImageAsFramebuffer imageBond(getRenderEngine(), image);
4005 if (imageBond.getStatus() == NO_ERROR) {
4006 // this will in fact render into our dequeued buffer
4007 // via an FBO, which means we didn't have to create
4008 // an EGLSurface and therefore we're not
4009 // dependent on the context's EGLConfig.
4010 renderScreenImplLocked(
4011 hw, sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ, true,
4012 useIdentityTransform, rotation);
4013
4014 // Attempt to create a sync khr object that can produce a sync point. If that
4015 // isn't available, create a non-dupable sync object in the fallback path and
4016 // wait on it directly.
4017 EGLSyncKHR sync;
4018 if (!DEBUG_SCREENSHOTS) {
4019 sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, NULL);
4020 // native fence fd will not be populated until flush() is done.
4021 getRenderEngine().flush();
4022 } else {
4023 sync = EGL_NO_SYNC_KHR;
4024 }
4025 if (sync != EGL_NO_SYNC_KHR) {
4026 // get the sync fd
4027 syncFd = eglDupNativeFenceFDANDROID(mEGLDisplay, sync);
4028 if (syncFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
4029 ALOGW("captureScreen: failed to dup sync khr object");
4030 syncFd = -1;
4031 }
4032 eglDestroySyncKHR(mEGLDisplay, sync);
4033 } else {
4034 // fallback path
4035 sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, NULL);
4036 if (sync != EGL_NO_SYNC_KHR) {
4037 EGLint result = eglClientWaitSyncKHR(mEGLDisplay, sync,
4038 EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, 2000000000 /*2 sec*/);
4039 EGLint eglErr = eglGetError();
4040 if (result == EGL_TIMEOUT_EXPIRED_KHR) {
4041 ALOGW("captureScreen: fence wait timed out");
4042 } else {
4043 ALOGW_IF(eglErr != EGL_SUCCESS,
4044 "captureScreen: error waiting on EGL fence: %#x", eglErr);
4045 }
4046 eglDestroySyncKHR(mEGLDisplay, sync);
4047 } else {
4048 ALOGW("captureScreen: error creating EGL fence: %#x", eglGetError());
4049 }
4050 }
4051 if (DEBUG_SCREENSHOTS) {
4052 uint32_t* pixels = new uint32_t[reqWidth*reqHeight];
4053 getRenderEngine().readPixels(0, 0, reqWidth, reqHeight, pixels);
4054 checkScreenshot(reqWidth, reqHeight, reqWidth, pixels,
4055 hw, minLayerZ, maxLayerZ);
4056 delete [] pixels;
4057 }
4058
4059 } else {
4060 ALOGE("got GL_FRAMEBUFFER_COMPLETE_OES error while taking screenshot");
4061 result = INVALID_OPERATION;
4062 window->cancelBuffer(window, buffer, syncFd);
4063 buffer = NULL;
4064 }
4065 // destroy our image
4066 eglDestroyImageKHR(mEGLDisplay, image);
4067 } else {
4068 result = BAD_VALUE;
4069 }
4070 if (buffer) {
4071 // queueBuffer takes ownership of syncFd
4072 result = window->queueBuffer(window, buffer, syncFd);
4073 }
4074 }
4075 } else {
4076 result = BAD_VALUE;
4077 }
4078 native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
4079 }
4080
4081 return result;
4082}
4083
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004084void SurfaceFlinger::checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
Robert Carrae060832016-11-28 10:51:00 -08004085 const sp<const DisplayDevice>& hw, int32_t minLayerZ, int32_t maxLayerZ) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004086 if (DEBUG_SCREENSHOTS) {
4087 for (size_t y=0 ; y<h ; y++) {
4088 uint32_t const * p = (uint32_t const *)vaddr + y*s;
4089 for (size_t x=0 ; x<w ; x++) {
4090 if (p[x] != 0xFF000000) return;
4091 }
4092 }
4093 ALOGE("*** we just took a black screenshot ***\n"
4094 "requested minz=%d, maxz=%d, layerStack=%d",
4095 minLayerZ, maxLayerZ, hw->getLayerStack());
Robert Carr2047fae2016-11-28 14:09:09 -08004096 size_t i = 0;
Robert Carr1f0a16a2016-10-24 16:27:39 -07004097 for (const auto& layer : mDrawingState.layersSortedByZ) {
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004098 const Layer::State& state(layer->getDrawingState());
Robert Carr1f0a16a2016-10-24 16:27:39 -07004099 if (layer->getLayerStack() == hw->getLayerStack() && state.z >= minLayerZ &&
4100 state.z <= maxLayerZ) {
Dan Stoza412903f2017-04-27 13:42:17 -07004101 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
chaviw13fdc492017-06-27 12:40:18 -07004102 ALOGE("%c index=%zu, name=%s, layerStack=%d, z=%d, visible=%d, flags=%x, alpha=%.3f",
Robert Carr1f0a16a2016-10-24 16:27:39 -07004103 layer->isVisible() ? '+' : '-',
4104 i, layer->getName().string(), layer->getLayerStack(), state.z,
chaviw13fdc492017-06-27 12:40:18 -07004105 layer->isVisible(), state.flags, static_cast<float>(state.color.a));
Robert Carr1f0a16a2016-10-24 16:27:39 -07004106 i++;
4107 });
4108 }
4109 }
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004110 }
4111}
4112
4113// ---------------------------------------------------------------------------
4114
Dan Stoza412903f2017-04-27 13:42:17 -07004115void SurfaceFlinger::State::traverseInZOrder(const LayerVector::Visitor& visitor) const {
4116 layersSortedByZ.traverseInZOrder(stateSet, visitor);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004117}
4118
Dan Stoza412903f2017-04-27 13:42:17 -07004119void SurfaceFlinger::State::traverseInReverseZOrder(const LayerVector::Visitor& visitor) const {
4120 layersSortedByZ.traverseInReverseZOrder(stateSet, visitor);
Fabien Sanglard9d96de42016-10-11 00:15:18 +00004121}
4122
4123}; // namespace android
4124
4125
4126#if defined(__gl_h_)
4127#error "don't include gl/gl.h in this file"
4128#endif
4129
4130#if defined(__gl2_h_)
4131#error "don't include gl2/gl2.h in this file"
4132#endif