2 * Copyright (C) 2007 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
20 #include <sys/types.h>
25 #include <stdatomic.h>
29 #include <cutils/log.h>
30 #include <cutils/properties.h>
32 #include <binder/IPCThreadState.h>
33 #include <binder/IServiceManager.h>
34 #include <binder/MemoryHeapBase.h>
35 #include <binder/PermissionCache.h>
37 #include <ui/DisplayInfo.h>
38 #include <ui/DisplayStatInfo.h>
40 #include <gui/BitTube.h>
41 #include <gui/BufferQueue.h>
42 #include <gui/GuiConfig.h>
43 #include <gui/IDisplayEventConnection.h>
44 #include <gui/Surface.h>
45 #include <gui/GraphicBufferAlloc.h>
47 #include <ui/GraphicBufferAllocator.h>
48 #include <ui/HdrCapabilities.h>
49 #include <ui/PixelFormat.h>
50 #include <ui/UiConfig.h>
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>
59 #include <private/android_filesystem_config.h>
60 #include <private/gui/SyncFeatures.h>
66 #include "Colorizer.h"
67 #include "DdmConnection.h"
68 #include "DisplayDevice.h"
70 #include "EventControlThread.h"
71 #include "EventThread.h"
74 #include "SurfaceFlinger.h"
76 #include "DisplayHardware/FramebufferSurface.h"
77 #include "DisplayHardware/HWComposer.h"
78 #include "DisplayHardware/VirtualDisplaySurface.h"
80 #include "Effects/Daltonizer.h"
82 #include "RenderEngine/RenderEngine.h"
83 #include <cutils/compiler.h>
85 #define DISPLAY_COUNT 1
88 * DEBUG_SCREENSHOTS: set to true to check that screenshots are not all
91 #define DEBUG_SCREENSHOTS false
93 EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name);
97 // This is the phase offset in nanoseconds of the software vsync event
98 // relative to the vsync event reported by HWComposer. The software vsync
99 // event is when SurfaceFlinger and Choreographer-based applications run each
102 // This phase offset allows adjustment of the minimum latency from application
103 // wake-up (by Choregographer) time to the time at which the resulting window
104 // image is displayed. This value may be either positive (after the HW vsync)
105 // or negative (before the HW vsync). Setting it to 0 will result in a
106 // minimum latency of two vsync periods because the app and SurfaceFlinger
107 // will run just after the HW vsync. Setting it to a positive number will
108 // result in the minimum latency being:
110 // (2 * VSYNC_PERIOD - (vsyncPhaseOffsetNs % VSYNC_PERIOD))
112 // Note that reducing this latency makes it more likely for the applications
113 // to not have their window content image ready in time. When this happens
114 // the latency will end up being an additional vsync period, and animations
115 // will hiccup. Therefore, this latency should be tuned somewhat
116 // conservatively (or at least with awareness of the trade-off being made).
117 static const int64_t vsyncPhaseOffsetNs = VSYNC_EVENT_PHASE_OFFSET_NS;
119 // This is the phase offset at which SurfaceFlinger's composition runs.
120 static const int64_t sfVsyncPhaseOffsetNs = SF_VSYNC_EVENT_PHASE_OFFSET_NS;
122 // ---------------------------------------------------------------------------
124 const String16 sHardwareTest("android.permission.HARDWARE_TEST");
125 const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER");
126 const String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER");
127 const String16 sDump("android.permission.DUMP");
129 // ---------------------------------------------------------------------------
131 SurfaceFlinger::SurfaceFlinger()
132 : BnSurfaceComposer(),
133 mTransactionFlags(0),
134 mTransactionPending(false),
135 mAnimTransactionPending(false),
136 mLayersRemoved(false),
137 mRepaintEverything(0),
139 mBootTime(systemTime()),
140 mVisibleRegionsDirty(false),
141 mHwWorkListDirty(false),
142 mAnimCompositionPending(false),
146 mDebugDisableTransformHint(0),
147 mDebugInSwapBuffers(0),
148 mLastSwapBufferTime(0),
149 mDebugInTransaction(0),
150 mLastTransactionTime(0),
151 mBootFinished(false),
152 mForceFullDamage(false),
153 mPrimaryDispSync("PrimaryDispSync"),
154 mPrimaryHWVsyncEnabled(false),
155 mHWVsyncAvailable(false),
157 mHasColorMatrix(false),
158 mHasPoweredOff(false),
163 ALOGI("SurfaceFlinger is starting");
165 // debugging stuff...
166 char value[PROPERTY_VALUE_MAX];
168 property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");
169 mGpuToCpuSupported = !atoi(value);
171 property_get("debug.sf.showupdates", value, "0");
172 mDebugRegion = atoi(value);
174 property_get("debug.sf.ddms", value, "0");
175 mDebugDDMS = atoi(value);
177 if (!startDdmConnection()) {
178 // start failed, and DDMS debugging not enabled
182 ALOGI_IF(mDebugRegion, "showupdates enabled");
183 ALOGI_IF(mDebugDDMS, "DDMS debugging enabled");
185 property_get("debug.sf.disable_hwc_vds", value, "0");
186 mUseHwcVirtualDisplays = !atoi(value);
187 ALOGI_IF(!mUseHwcVirtualDisplays, "Disabling HWC virtual displays");
190 void SurfaceFlinger::onFirstRef()
192 mEventQueue.init(this);
195 SurfaceFlinger::~SurfaceFlinger()
197 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
198 eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
199 eglTerminate(display);
202 void SurfaceFlinger::binderDied(const wp<IBinder>& /* who */)
204 // the window manager died on us. prepare its eulogy.
206 // restore initial conditions (default device unblank, etc)
207 initializeDisplays();
209 // restart the boot-animation
213 sp<ISurfaceComposerClient> SurfaceFlinger::createConnection()
215 sp<ISurfaceComposerClient> bclient;
216 sp<Client> client(new Client(this));
217 status_t err = client->initCheck();
218 if (err == NO_ERROR) {
224 sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName,
227 class DisplayToken : public BBinder {
228 sp<SurfaceFlinger> flinger;
229 virtual ~DisplayToken() {
230 // no more references, this display must be terminated
231 Mutex::Autolock _l(flinger->mStateLock);
232 flinger->mCurrentState.displays.removeItem(this);
233 flinger->setTransactionFlags(eDisplayTransactionNeeded);
236 DisplayToken(const sp<SurfaceFlinger>& flinger)
241 sp<BBinder> token = new DisplayToken(this);
243 Mutex::Autolock _l(mStateLock);
244 DisplayDeviceState info(DisplayDevice::DISPLAY_VIRTUAL, secure);
245 info.displayName = displayName;
246 mCurrentState.displays.add(token, info);
251 void SurfaceFlinger::destroyDisplay(const sp<IBinder>& display) {
252 Mutex::Autolock _l(mStateLock);
254 ssize_t idx = mCurrentState.displays.indexOfKey(display);
256 ALOGW("destroyDisplay: invalid display token");
260 const DisplayDeviceState& info(mCurrentState.displays.valueAt(idx));
261 if (!info.isVirtualDisplay()) {
262 ALOGE("destroyDisplay called for non-virtual display");
266 mCurrentState.displays.removeItemsAt(idx);
267 setTransactionFlags(eDisplayTransactionNeeded);
270 void SurfaceFlinger::createBuiltinDisplayLocked(DisplayDevice::DisplayType type) {
271 ALOGW_IF(mBuiltinDisplays[type],
272 "Overwriting display token for display type %d", type);
273 mBuiltinDisplays[type] = new BBinder();
274 // All non-virtual displays are currently considered secure.
275 DisplayDeviceState info(type, true);
276 mCurrentState.displays.add(mBuiltinDisplays[type], info);
279 sp<IBinder> SurfaceFlinger::getBuiltInDisplay(int32_t id) {
280 if (uint32_t(id) >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
281 ALOGE("getDefaultDisplay: id=%d is not a valid default display id", id);
284 return mBuiltinDisplays[id];
287 sp<IGraphicBufferAlloc> SurfaceFlinger::createGraphicBufferAlloc()
289 sp<GraphicBufferAlloc> gba(new GraphicBufferAlloc());
293 void SurfaceFlinger::bootFinished()
295 const nsecs_t now = systemTime();
296 const nsecs_t duration = now - mBootTime;
297 ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
298 mBootFinished = true;
300 // wait patiently for the window manager death
301 const String16 name("window");
302 sp<IBinder> window(defaultServiceManager()->getService(name));
304 window->linkToDeath(static_cast<IBinder::DeathRecipient*>(this));
307 // stop boot animation
308 // formerly we would just kill the process, but we now ask it to exit so it
309 // can choose where to stop the animation.
310 property_set("service.bootanim.exit", "1");
312 const int LOGTAG_SF_STOP_BOOTANIM = 60110;
313 LOG_EVENT_LONG(LOGTAG_SF_STOP_BOOTANIM,
314 ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
317 void SurfaceFlinger::deleteTextureAsync(uint32_t texture) {
318 class MessageDestroyGLTexture : public MessageBase {
319 RenderEngine& engine;
322 MessageDestroyGLTexture(RenderEngine& engine, uint32_t texture)
323 : engine(engine), texture(texture) {
325 virtual bool handler() {
326 engine.deleteTextures(1, &texture);
330 postMessageAsync(new MessageDestroyGLTexture(getRenderEngine(), texture));
333 class DispSyncSource : public VSyncSource, private DispSync::Callback {
335 DispSyncSource(DispSync* dispSync, nsecs_t phaseOffset, bool traceVsync,
339 mTraceVsync(traceVsync),
340 mVsyncOnLabel(String8::format("VsyncOn-%s", name)),
341 mVsyncEventLabel(String8::format("VSYNC-%s", name)),
346 mPhaseOffset(phaseOffset),
349 virtual ~DispSyncSource() {}
351 virtual void setVSyncEnabled(bool enable) {
352 Mutex::Autolock lock(mVsyncMutex);
354 status_t err = mDispSync->addEventListener(mName, mPhaseOffset,
355 static_cast<DispSync::Callback*>(this));
356 if (err != NO_ERROR) {
357 ALOGE("error registering vsync callback: %s (%d)",
358 strerror(-err), err);
360 //ATRACE_INT(mVsyncOnLabel.string(), 1);
362 status_t err = mDispSync->removeEventListener(
363 static_cast<DispSync::Callback*>(this));
364 if (err != NO_ERROR) {
365 ALOGE("error unregistering vsync callback: %s (%d)",
366 strerror(-err), err);
368 //ATRACE_INT(mVsyncOnLabel.string(), 0);
373 virtual void setCallback(const sp<VSyncSource::Callback>& callback) {
374 Mutex::Autolock lock(mCallbackMutex);
375 mCallback = callback;
378 virtual void setPhaseOffset(nsecs_t phaseOffset) {
379 Mutex::Autolock lock(mVsyncMutex);
381 // Normalize phaseOffset to [0, period)
382 auto period = mDispSync->getPeriod();
383 phaseOffset %= period;
384 if (phaseOffset < 0) {
385 // If we're here, then phaseOffset is in (-period, 0). After this
386 // operation, it will be in (0, period)
387 phaseOffset += period;
389 mPhaseOffset = phaseOffset;
391 // If we're not enabled, we don't need to mess with the listeners
396 // Remove the listener with the old offset
397 status_t err = mDispSync->removeEventListener(
398 static_cast<DispSync::Callback*>(this));
399 if (err != NO_ERROR) {
400 ALOGE("error unregistering vsync callback: %s (%d)",
401 strerror(-err), err);
404 // Add a listener with the new offset
405 err = mDispSync->addEventListener(mName, mPhaseOffset,
406 static_cast<DispSync::Callback*>(this));
407 if (err != NO_ERROR) {
408 ALOGE("error registering vsync callback: %s (%d)",
409 strerror(-err), err);
414 virtual void onDispSyncEvent(nsecs_t when) {
415 sp<VSyncSource::Callback> callback;
417 Mutex::Autolock lock(mCallbackMutex);
418 callback = mCallback;
421 mValue = (mValue + 1) % 2;
422 ATRACE_INT(mVsyncEventLabel.string(), mValue);
426 if (callback != NULL) {
427 callback->onVSyncEvent(when);
431 const char* const mName;
435 const bool mTraceVsync;
436 const String8 mVsyncOnLabel;
437 const String8 mVsyncEventLabel;
441 Mutex mCallbackMutex; // Protects the following
442 sp<VSyncSource::Callback> mCallback;
444 Mutex mVsyncMutex; // Protects the following
445 nsecs_t mPhaseOffset;
449 void SurfaceFlinger::init() {
450 ALOGI( "SurfaceFlinger's main thread ready to run. "
451 "Initializing graphics H/W...");
453 Mutex::Autolock _l(mStateLock);
455 // initialize EGL for the default display
456 mEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
457 eglInitialize(mEGLDisplay, NULL, NULL);
459 // start the EventThread
460 sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,
461 vsyncPhaseOffsetNs, true, "app");
462 mEventThread = new EventThread(vsyncSrc, *this);
463 sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,
464 sfVsyncPhaseOffsetNs, true, "sf");
465 mSFEventThread = new EventThread(sfVsyncSrc, *this);
466 mEventQueue.setEventThread(mSFEventThread);
468 // set SFEventThread to SCHED_FIFO to minimize jitter
469 struct sched_param param = {0};
470 param.sched_priority = 2;
471 if (sched_setscheduler(mSFEventThread->getTid(), SCHED_FIFO, ¶m) != 0) {
472 ALOGE("Couldn't set SCHED_FIFO for SFEventThread");
476 // Initialize the H/W composer object. There may or may not be an
477 // actual hardware composer underneath.
478 mHwc = new HWComposer(this,
479 *static_cast<HWComposer::EventHandler *>(this));
481 // get a RenderEngine for the given display / config (can't fail)
482 mRenderEngine = RenderEngine::create(mEGLDisplay, mHwc->getVisualID());
484 // retrieve the EGL context that was selected/created
485 mEGLContext = mRenderEngine->getEGLContext();
487 LOG_ALWAYS_FATAL_IF(mEGLContext == EGL_NO_CONTEXT,
488 "couldn't create EGLContext");
490 // initialize our non-virtual displays
491 for (size_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {
492 DisplayDevice::DisplayType type((DisplayDevice::DisplayType)i);
493 // set-up the displays that are already connected
494 if (mHwc->isConnected(i) || type==DisplayDevice::DISPLAY_PRIMARY) {
495 // All non-virtual displays are currently considered secure.
496 bool isSecure = true;
497 createBuiltinDisplayLocked(type);
498 wp<IBinder> token = mBuiltinDisplays[i];
500 sp<IGraphicBufferProducer> producer;
501 sp<IGraphicBufferConsumer> consumer;
502 BufferQueue::createBufferQueue(&producer, &consumer,
503 new GraphicBufferAlloc());
505 sp<FramebufferSurface> fbs = new FramebufferSurface(*mHwc, i,
507 int32_t hwcId = allocateHwcDisplayId(type);
508 sp<DisplayDevice> hw = new DisplayDevice(this,
509 type, hwcId, mHwc->getFormat(hwcId), isSecure, token,
511 mRenderEngine->getEGLConfig());
512 if (i > DisplayDevice::DISPLAY_PRIMARY) {
513 // FIXME: currently we don't get blank/unblank requests
514 // for displays other than the main display, so we always
515 // assume a connected display is unblanked.
516 ALOGD("marking display %zu as acquired/unblanked", i);
517 hw->setPowerMode(HWC_POWER_MODE_NORMAL);
519 mDisplays.add(token, hw);
523 // make the GLContext current so that we can create textures when creating Layers
524 // (which may happens before we render something)
525 getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
527 mEventControlThread = new EventControlThread(this);
528 mEventControlThread->run("EventControl", PRIORITY_URGENT_DISPLAY);
530 // set a fake vsync period if there is no HWComposer
531 if (mHwc->initCheck() != NO_ERROR) {
532 mPrimaryDispSync.setPeriod(16666667);
535 // initialize our drawing state
536 mDrawingState = mCurrentState;
538 // set initial conditions (e.g. unblank default device)
539 initializeDisplays();
541 mRenderEngine->primeCache();
543 // start boot animation
547 int32_t SurfaceFlinger::allocateHwcDisplayId(DisplayDevice::DisplayType type) {
548 return (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) ?
549 type : mHwc->allocateDisplayId();
552 void SurfaceFlinger::startBootAnim() {
553 // start boot animation
554 property_set("service.bootanim.exit", "0");
555 property_set("ctl.start", "bootanim");
558 size_t SurfaceFlinger::getMaxTextureSize() const {
559 return mRenderEngine->getMaxTextureSize();
562 size_t SurfaceFlinger::getMaxViewportDims() const {
563 return mRenderEngine->getMaxViewportDims();
566 // ----------------------------------------------------------------------------
568 bool SurfaceFlinger::authenticateSurfaceTexture(
569 const sp<IGraphicBufferProducer>& bufferProducer) const {
570 Mutex::Autolock _l(mStateLock);
571 sp<IBinder> surfaceTextureBinder(IInterface::asBinder(bufferProducer));
572 return mGraphicBufferProducerList.indexOf(surfaceTextureBinder) >= 0;
575 status_t SurfaceFlinger::getDisplayConfigs(const sp<IBinder>& display,
576 Vector<DisplayInfo>* configs) {
577 if ((configs == NULL) || (display.get() == NULL)) {
581 int32_t type = getDisplayType(display);
582 if (type < 0) return type;
584 // TODO: Not sure if display density should handled by SF any longer
586 static int getDensityFromProperty(char const* propName) {
587 char property[PROPERTY_VALUE_MAX];
589 if (property_get(propName, property, NULL) > 0) {
590 density = atoi(property);
595 static int getEmuDensity() {
596 return getDensityFromProperty("qemu.sf.lcd_density"); }
597 static int getBuildDensity() {
598 return getDensityFromProperty("ro.sf.lcd_density"); }
603 const Vector<HWComposer::DisplayConfig>& hwConfigs =
604 getHwComposer().getConfigs(type);
605 for (size_t c = 0; c < hwConfigs.size(); ++c) {
606 const HWComposer::DisplayConfig& hwConfig = hwConfigs[c];
607 DisplayInfo info = DisplayInfo();
609 float xdpi = hwConfig.xdpi;
610 float ydpi = hwConfig.ydpi;
612 if (type == DisplayDevice::DISPLAY_PRIMARY) {
613 // The density of the device is provided by a build property
614 float density = Density::getBuildDensity() / 160.0f;
616 // the build doesn't provide a density -- this is wrong!
618 ALOGE("ro.sf.lcd_density must be defined as a build property");
619 density = xdpi / 160.0f;
621 if (Density::getEmuDensity()) {
622 // if "qemu.sf.lcd_density" is specified, it overrides everything
623 xdpi = ydpi = density = Density::getEmuDensity();
626 info.density = density;
628 // TODO: this needs to go away (currently needed only by webkit)
629 sp<const DisplayDevice> hw(getDefaultDisplayDevice());
630 info.orientation = hw->getOrientation();
632 // TODO: where should this value come from?
633 static const int TV_DENSITY = 213;
634 info.density = TV_DENSITY / 160.0f;
635 info.orientation = 0;
638 info.w = hwConfig.width;
639 info.h = hwConfig.height;
642 info.fps = float(1e9 / hwConfig.refresh);
643 info.appVsyncOffset = VSYNC_EVENT_PHASE_OFFSET_NS;
645 // This is how far in advance a buffer must be queued for
646 // presentation at a given time. If you want a buffer to appear
647 // on the screen at time N, you must submit the buffer before
648 // (N - presentationDeadline).
650 // Normally it's one full refresh period (to give SF a chance to
651 // latch the buffer), but this can be reduced by configuring a
652 // DispSync offset. Any additional delays introduced by the hardware
653 // composer or panel must be accounted for here.
655 // We add an additional 1ms to allow for processing time and
656 // differences between the ideal and actual refresh rate.
657 info.presentationDeadline =
658 hwConfig.refresh - SF_VSYNC_EVENT_PHASE_OFFSET_NS + 1000000;
660 // All non-virtual displays are currently considered secure.
663 configs->push_back(info);
669 status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>& /* display */,
670 DisplayStatInfo* stats) {
675 // FIXME for now we always return stats for the primary display
676 memset(stats, 0, sizeof(*stats));
677 stats->vsyncTime = mPrimaryDispSync.computeNextRefresh(0);
678 stats->vsyncPeriod = mPrimaryDispSync.getPeriod();
682 int SurfaceFlinger::getActiveConfig(const sp<IBinder>& display) {
683 sp<DisplayDevice> device(getDisplayDevice(display));
684 if (device != NULL) {
685 return device->getActiveConfig();
690 void SurfaceFlinger::setActiveConfigInternal(const sp<DisplayDevice>& hw, int mode) {
691 ALOGD("Set active config mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(),
693 int32_t type = hw->getDisplayType();
694 int currentMode = hw->getActiveConfig();
696 if (mode == currentMode) {
697 ALOGD("Screen type=%d is already mode=%d", hw->getDisplayType(), mode);
701 if (type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
702 ALOGW("Trying to set config for virtual display");
706 hw->setActiveConfig(mode);
707 getHwComposer().setActiveConfig(type, mode);
710 status_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& display, int mode) {
711 class MessageSetActiveConfig: public MessageBase {
712 SurfaceFlinger& mFlinger;
713 sp<IBinder> mDisplay;
716 MessageSetActiveConfig(SurfaceFlinger& flinger, const sp<IBinder>& disp,
718 mFlinger(flinger), mDisplay(disp) { mMode = mode; }
719 virtual bool handler() {
720 Vector<DisplayInfo> configs;
721 mFlinger.getDisplayConfigs(mDisplay, &configs);
722 if (mMode < 0 || mMode >= static_cast<int>(configs.size())) {
723 ALOGE("Attempt to set active config = %d for display with %zu configs",
724 mMode, configs.size());
726 sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
728 ALOGE("Attempt to set active config = %d for null display %p",
729 mMode, mDisplay.get());
730 } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) {
731 ALOGW("Attempt to set active config = %d for virtual display",
734 mFlinger.setActiveConfigInternal(hw, mMode);
739 sp<MessageBase> msg = new MessageSetActiveConfig(*this, display, mode);
740 postMessageSync(msg);
744 status_t SurfaceFlinger::getDisplayColorModes(const sp<IBinder>& display,
745 Vector<android_color_mode_t>* outColorModes) {
746 if (outColorModes == nullptr || display.get() == nullptr) {
750 int32_t type = getDisplayType(display);
751 if (type < 0) return type;
753 std::set<android_color_mode_t> colorModes;
754 for (const HWComposer::DisplayConfig& hwConfig : getHwComposer().getConfigs(type)) {
755 colorModes.insert(hwConfig.colorMode);
758 outColorModes->clear();
759 std::copy(colorModes.cbegin(), colorModes.cend(), std::back_inserter(*outColorModes));
764 android_color_mode_t SurfaceFlinger::getActiveColorMode(const sp<IBinder>& display) {
765 if (display.get() == nullptr) return static_cast<android_color_mode_t>(BAD_VALUE);
767 int32_t type = getDisplayType(display);
768 if (type < 0) return static_cast<android_color_mode_t>(type);
770 return getHwComposer().getColorMode(type);
773 status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& display,
774 android_color_mode_t colorMode) {
775 if (display.get() == nullptr || colorMode < 0) {
779 int32_t type = getDisplayType(display);
780 if (type < 0) return type;
781 const Vector<HWComposer::DisplayConfig>& hwConfigs = getHwComposer().getConfigs(type);
782 HWComposer::DisplayConfig desiredConfig = hwConfigs[getHwComposer().getCurrentConfig(type)];
783 desiredConfig.colorMode = colorMode;
784 for (size_t c = 0; c < hwConfigs.size(); ++c) {
785 const HWComposer::DisplayConfig config = hwConfigs[c];
786 if (config == desiredConfig) {
787 return setActiveConfig(display, c);
793 status_t SurfaceFlinger::clearAnimationFrameStats() {
794 Mutex::Autolock _l(mStateLock);
795 mAnimFrameTracker.clearStats();
799 status_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const {
800 Mutex::Autolock _l(mStateLock);
801 mAnimFrameTracker.getStats(outStats);
805 status_t SurfaceFlinger::getHdrCapabilities(const sp<IBinder>& /*display*/,
806 HdrCapabilities* outCapabilities) const {
807 // HWC1 does not provide HDR capabilities
808 *outCapabilities = HdrCapabilities();
812 // ----------------------------------------------------------------------------
814 sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection() {
815 return mEventThread->createEventConnection();
818 // ----------------------------------------------------------------------------
820 void SurfaceFlinger::waitForEvent() {
821 mEventQueue.waitMessage();
824 void SurfaceFlinger::signalTransaction() {
825 mEventQueue.invalidate();
828 void SurfaceFlinger::signalLayerUpdate() {
829 mEventQueue.invalidate();
832 void SurfaceFlinger::signalRefresh() {
833 mEventQueue.refresh();
836 status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,
837 nsecs_t reltime, uint32_t /* flags */) {
838 return mEventQueue.postMessage(msg, reltime);
841 status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
842 nsecs_t reltime, uint32_t /* flags */) {
843 status_t res = mEventQueue.postMessage(msg, reltime);
844 if (res == NO_ERROR) {
850 void SurfaceFlinger::run() {
856 void SurfaceFlinger::enableHardwareVsync() {
857 Mutex::Autolock _l(mHWVsyncLock);
858 if (!mPrimaryHWVsyncEnabled && mHWVsyncAvailable) {
859 mPrimaryDispSync.beginResync();
860 //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true);
861 mEventControlThread->setVsyncEnabled(true);
862 mPrimaryHWVsyncEnabled = true;
866 void SurfaceFlinger::resyncToHardwareVsync(bool makeAvailable) {
867 Mutex::Autolock _l(mHWVsyncLock);
870 mHWVsyncAvailable = true;
871 } else if (!mHWVsyncAvailable) {
872 // Hardware vsync is not currently available, so abort the resync
877 const nsecs_t period =
878 getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
880 mPrimaryDispSync.reset();
881 mPrimaryDispSync.setPeriod(period);
883 if (!mPrimaryHWVsyncEnabled) {
884 mPrimaryDispSync.beginResync();
885 //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true);
886 mEventControlThread->setVsyncEnabled(true);
887 mPrimaryHWVsyncEnabled = true;
891 void SurfaceFlinger::disableHardwareVsync(bool makeUnavailable) {
892 Mutex::Autolock _l(mHWVsyncLock);
893 if (mPrimaryHWVsyncEnabled) {
894 //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, false);
895 mEventControlThread->setVsyncEnabled(false);
896 mPrimaryDispSync.endResync();
897 mPrimaryHWVsyncEnabled = false;
899 if (makeUnavailable) {
900 mHWVsyncAvailable = false;
904 void SurfaceFlinger::resyncWithRateLimit() {
905 static constexpr nsecs_t kIgnoreDelay = ms2ns(500);
906 if (systemTime() - mLastSwapTime > kIgnoreDelay) {
907 resyncToHardwareVsync(false);
911 void SurfaceFlinger::onVSyncReceived(int type, nsecs_t timestamp) {
912 bool needsHwVsync = false;
914 { // Scope for the lock
915 Mutex::Autolock _l(mHWVsyncLock);
916 if (type == 0 && mPrimaryHWVsyncEnabled) {
917 needsHwVsync = mPrimaryDispSync.addResyncSample(timestamp);
922 enableHardwareVsync();
924 disableHardwareVsync(false);
928 void SurfaceFlinger::onHotplugReceived(int type, bool connected) {
929 if (mEventThread == NULL) {
930 // This is a temporary workaround for b/7145521. A non-null pointer
931 // does not mean EventThread has finished initializing, so this
932 // is not a correct fix.
933 ALOGW("WARNING: EventThread not started, ignoring hotplug");
937 if (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
938 Mutex::Autolock _l(mStateLock);
940 createBuiltinDisplayLocked((DisplayDevice::DisplayType)type);
942 mCurrentState.displays.removeItem(mBuiltinDisplays[type]);
943 mBuiltinDisplays[type].clear();
945 setTransactionFlags(eDisplayTransactionNeeded);
947 // Defer EventThread notification until SF has updated mDisplays.
951 void SurfaceFlinger::eventControl(int disp, int event, int enabled) {
953 getHwComposer().eventControl(disp, event, enabled);
956 void SurfaceFlinger::onMessageReceived(int32_t what) {
959 case MessageQueue::INVALIDATE: {
960 bool refreshNeeded = handleMessageTransaction();
961 refreshNeeded |= handleMessageInvalidate();
962 refreshNeeded |= mRepaintEverything;
964 // Signal a refresh if a transaction modified the window state,
965 // a new buffer was latched, or if HWC has requested a full
971 case MessageQueue::REFRESH: {
972 handleMessageRefresh();
978 bool SurfaceFlinger::handleMessageTransaction() {
979 uint32_t transactionFlags = peekTransactionFlags(eTransactionMask);
980 if (transactionFlags) {
981 handleTransaction(transactionFlags);
987 bool SurfaceFlinger::handleMessageInvalidate() {
989 return handlePageFlip();
992 void SurfaceFlinger::handleMessageRefresh() {
995 nsecs_t refreshStartTime = systemTime(SYSTEM_TIME_MONOTONIC);
998 rebuildLayerStacks();
1000 doDebugFlashRegions();
1002 postComposition(refreshStartTime);
1005 void SurfaceFlinger::doDebugFlashRegions()
1007 // is debugging enabled
1008 if (CC_LIKELY(!mDebugRegion))
1011 const bool repaintEverything = mRepaintEverything;
1012 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1013 const sp<DisplayDevice>& hw(mDisplays[dpy]);
1014 if (hw->isDisplayOn()) {
1015 // transform the dirty region into this screen's coordinate space
1016 const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
1017 if (!dirtyRegion.isEmpty()) {
1018 // redraw the whole screen
1019 doComposeSurfaces(hw, Region(hw->bounds()));
1021 // and draw the dirty region
1022 const int32_t height = hw->getHeight();
1023 RenderEngine& engine(getRenderEngine());
1024 engine.fillRegionWithColor(dirtyRegion, height, 1, 0, 1, 1);
1026 hw->compositionComplete();
1027 hw->swapBuffers(getHwComposer());
1034 if (mDebugRegion > 1) {
1035 usleep(mDebugRegion * 1000);
1038 HWComposer& hwc(getHwComposer());
1039 if (hwc.initCheck() == NO_ERROR) {
1040 status_t err = hwc.prepare();
1041 ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
1045 void SurfaceFlinger::preComposition()
1047 bool needExtraInvalidate = false;
1048 const LayerVector& layers(mDrawingState.layersSortedByZ);
1049 const size_t count = layers.size();
1050 for (size_t i=0 ; i<count ; i++) {
1051 if (layers[i]->onPreComposition()) {
1052 needExtraInvalidate = true;
1055 if (needExtraInvalidate) {
1056 signalLayerUpdate();
1060 void SurfaceFlinger::postComposition(nsecs_t refreshStartTime)
1062 const LayerVector& layers(mDrawingState.layersSortedByZ);
1063 const size_t count = layers.size();
1064 for (size_t i=0 ; i<count ; i++) {
1065 bool frameLatched = layers[i]->onPostComposition();
1067 recordBufferingStats(layers[i]->getName().string(),
1068 layers[i]->getOccupancyHistory(false));
1072 const HWComposer& hwc = getHwComposer();
1073 sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY);
1075 if (presentFence->isValid()) {
1076 if (mPrimaryDispSync.addPresentFence(presentFence)) {
1077 enableHardwareVsync();
1079 disableHardwareVsync(false);
1083 const sp<const DisplayDevice> hw(getDefaultDisplayDevice());
1084 if (kIgnorePresentFences) {
1085 if (hw->isDisplayOn()) {
1086 enableHardwareVsync();
1090 mFenceTracker.addFrame(refreshStartTime, presentFence,
1091 hw->getVisibleLayersSortedByZ(), hw->getClientTargetAcquireFence());
1093 if (mAnimCompositionPending) {
1094 mAnimCompositionPending = false;
1096 if (presentFence->isValid()) {
1097 mAnimFrameTracker.setActualPresentFence(presentFence);
1099 // The HWC doesn't support present fences, so use the refresh
1100 // timestamp instead.
1101 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY);
1102 mAnimFrameTracker.setActualPresentTime(presentTime);
1104 mAnimFrameTracker.advanceFrame();
1107 if (hw->getPowerMode() == HWC_POWER_MODE_OFF) {
1111 nsecs_t currentTime = systemTime();
1112 if (mHasPoweredOff) {
1113 mHasPoweredOff = false;
1115 nsecs_t period = mPrimaryDispSync.getPeriod();
1116 nsecs_t elapsedTime = currentTime - mLastSwapTime;
1117 size_t numPeriods = static_cast<size_t>(elapsedTime / period);
1118 if (numPeriods < NUM_BUCKETS - 1) {
1119 mFrameBuckets[numPeriods] += elapsedTime;
1121 mFrameBuckets[NUM_BUCKETS - 1] += elapsedTime;
1123 mTotalTime += elapsedTime;
1125 mLastSwapTime = currentTime;
1128 void SurfaceFlinger::rebuildLayerStacks() {
1129 // rebuild the visible layer list per screen
1130 if (CC_UNLIKELY(mVisibleRegionsDirty)) {
1132 mVisibleRegionsDirty = false;
1133 invalidateHwcGeometry();
1135 const LayerVector& layers(mDrawingState.layersSortedByZ);
1136 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1137 Region opaqueRegion;
1139 Vector< sp<Layer> > layersSortedByZ;
1140 const sp<DisplayDevice>& hw(mDisplays[dpy]);
1141 const Transform& tr(hw->getTransform());
1142 const Rect bounds(hw->getBounds());
1143 if (hw->isDisplayOn()) {
1144 SurfaceFlinger::computeVisibleRegions(layers,
1145 hw->getLayerStack(), dirtyRegion, opaqueRegion);
1147 const size_t count = layers.size();
1148 for (size_t i=0 ; i<count ; i++) {
1149 const sp<Layer>& layer(layers[i]);
1150 const Layer::State& s(layer->getDrawingState());
1151 if (s.layerStack == hw->getLayerStack()) {
1152 Region drawRegion(tr.transform(
1153 layer->visibleNonTransparentRegion));
1154 drawRegion.andSelf(bounds);
1155 if (!drawRegion.isEmpty()) {
1156 layersSortedByZ.add(layer);
1161 hw->setVisibleLayersSortedByZ(layersSortedByZ);
1162 hw->undefinedRegion.set(bounds);
1163 hw->undefinedRegion.subtractSelf(tr.transform(opaqueRegion));
1164 hw->dirtyRegion.orSelf(dirtyRegion);
1169 void SurfaceFlinger::setUpHWComposer() {
1170 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1171 bool dirty = !mDisplays[dpy]->getDirtyRegion(false).isEmpty();
1172 bool empty = mDisplays[dpy]->getVisibleLayersSortedByZ().size() == 0;
1173 bool wasEmpty = !mDisplays[dpy]->lastCompositionHadVisibleLayers;
1175 // If nothing has changed (!dirty), don't recompose.
1176 // If something changed, but we don't currently have any visible layers,
1177 // and didn't when we last did a composition, then skip it this time.
1178 // The second rule does two things:
1179 // - When all layers are removed from a display, we'll emit one black
1180 // frame, then nothing more until we get new layers.
1181 // - When a display is created with a private layer stack, we won't
1182 // emit any black frames until a layer is added to the layer stack.
1183 bool mustRecompose = dirty && !(empty && wasEmpty);
1185 ALOGV_IF(mDisplays[dpy]->getDisplayType() == DisplayDevice::DISPLAY_VIRTUAL,
1186 "dpy[%zu]: %s composition (%sdirty %sempty %swasEmpty)", dpy,
1187 mustRecompose ? "doing" : "skipping",
1190 wasEmpty ? "+" : "-");
1192 mDisplays[dpy]->beginFrame(mustRecompose);
1194 if (mustRecompose) {
1195 mDisplays[dpy]->lastCompositionHadVisibleLayers = !empty;
1199 HWComposer& hwc(getHwComposer());
1200 if (hwc.initCheck() == NO_ERROR) {
1201 // build the h/w work list
1202 if (CC_UNLIKELY(mHwWorkListDirty)) {
1203 mHwWorkListDirty = false;
1204 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1205 sp<const DisplayDevice> hw(mDisplays[dpy]);
1206 const int32_t id = hw->getHwcDisplayId();
1208 const Vector< sp<Layer> >& currentLayers(
1209 hw->getVisibleLayersSortedByZ());
1210 const size_t count = currentLayers.size();
1211 if (hwc.createWorkList(id, count) == NO_ERROR) {
1212 HWComposer::LayerListIterator cur = hwc.begin(id);
1213 const HWComposer::LayerListIterator end = hwc.end(id);
1214 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1215 const sp<Layer>& layer(currentLayers[i]);
1216 layer->setGeometry(hw, *cur);
1217 if (mDebugDisableHWC || mDebugRegion || mDaltonize || mHasColorMatrix) {
1226 // set the per-frame data
1227 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1228 sp<const DisplayDevice> hw(mDisplays[dpy]);
1229 const int32_t id = hw->getHwcDisplayId();
1231 const Vector< sp<Layer> >& currentLayers(
1232 hw->getVisibleLayersSortedByZ());
1233 const size_t count = currentLayers.size();
1234 HWComposer::LayerListIterator cur = hwc.begin(id);
1235 const HWComposer::LayerListIterator end = hwc.end(id);
1236 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1238 * update the per-frame h/w composer data for each layer
1239 * and build the transparent region of the FB
1241 const sp<Layer>& layer(currentLayers[i]);
1242 layer->setPerFrameData(hw, *cur);
1247 // If possible, attempt to use the cursor overlay on each display.
1248 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1249 sp<const DisplayDevice> hw(mDisplays[dpy]);
1250 const int32_t id = hw->getHwcDisplayId();
1252 const Vector< sp<Layer> >& currentLayers(
1253 hw->getVisibleLayersSortedByZ());
1254 const size_t count = currentLayers.size();
1255 HWComposer::LayerListIterator cur = hwc.begin(id);
1256 const HWComposer::LayerListIterator end = hwc.end(id);
1257 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1258 const sp<Layer>& layer(currentLayers[i]);
1259 if (layer->isPotentialCursor()) {
1260 cur->setIsCursorLayerHint();
1267 status_t err = hwc.prepare();
1268 ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
1270 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1271 sp<const DisplayDevice> hw(mDisplays[dpy]);
1272 hw->prepareFrame(hwc);
1277 void SurfaceFlinger::doComposition() {
1279 const bool repaintEverything = android_atomic_and(0, &mRepaintEverything);
1280 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1281 const sp<DisplayDevice>& hw(mDisplays[dpy]);
1282 if (hw->isDisplayOn()) {
1283 // transform the dirty region into this screen's coordinate space
1284 const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
1286 // repaint the framebuffer (if needed)
1287 doDisplayComposition(hw, dirtyRegion);
1289 hw->dirtyRegion.clear();
1290 hw->flip(hw->swapRegion);
1291 hw->swapRegion.clear();
1293 // inform the h/w that we're done compositing
1294 hw->compositionComplete();
1299 void SurfaceFlinger::postFramebuffer()
1303 const nsecs_t now = systemTime();
1304 mDebugInSwapBuffers = now;
1306 HWComposer& hwc(getHwComposer());
1307 if (hwc.initCheck() == NO_ERROR) {
1308 if (!hwc.supportsFramebufferTarget()) {
1310 // "surface must be bound to the calling thread's current context,
1311 // for the current rendering API."
1312 getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
1317 // make the default display current because the VirtualDisplayDevice code cannot
1318 // deal with dequeueBuffer() being called outside of the composition loop; however
1319 // the code below can call glFlush() which is allowed (and does in some case) call
1321 getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
1323 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1324 sp<const DisplayDevice> hw(mDisplays[dpy]);
1325 const Vector< sp<Layer> >& currentLayers(hw->getVisibleLayersSortedByZ());
1326 hw->onSwapBuffersCompleted(hwc);
1327 const size_t count = currentLayers.size();
1328 int32_t id = hw->getHwcDisplayId();
1329 if (id >=0 && hwc.initCheck() == NO_ERROR) {
1330 HWComposer::LayerListIterator cur = hwc.begin(id);
1331 const HWComposer::LayerListIterator end = hwc.end(id);
1332 for (size_t i = 0; cur != end && i < count; ++i, ++cur) {
1333 currentLayers[i]->onLayerDisplayed(hw, &*cur);
1336 for (size_t i = 0; i < count; i++) {
1337 currentLayers[i]->onLayerDisplayed(hw, NULL);
1342 mLastSwapBufferTime = systemTime() - now;
1343 mDebugInSwapBuffers = 0;
1345 uint32_t flipCount = getDefaultDisplayDevice()->getPageFlipCount();
1346 if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
1351 void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
1355 // here we keep a copy of the drawing state (that is the state that's
1356 // going to be overwritten by handleTransactionLocked()) outside of
1357 // mStateLock so that the side-effects of the State assignment
1358 // don't happen with mStateLock held (which can cause deadlocks).
1359 State drawingState(mDrawingState);
1361 Mutex::Autolock _l(mStateLock);
1362 const nsecs_t now = systemTime();
1363 mDebugInTransaction = now;
1365 // Here we're guaranteed that some transaction flags are set
1366 // so we can call handleTransactionLocked() unconditionally.
1367 // We call getTransactionFlags(), which will also clear the flags,
1368 // with mStateLock held to guarantee that mCurrentState won't change
1369 // until the transaction is committed.
1371 transactionFlags = getTransactionFlags(eTransactionMask);
1372 handleTransactionLocked(transactionFlags);
1374 mLastTransactionTime = systemTime() - now;
1375 mDebugInTransaction = 0;
1376 invalidateHwcGeometry();
1377 // here the transaction has been committed
1380 void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
1382 const LayerVector& currentLayers(mCurrentState.layersSortedByZ);
1383 const size_t count = currentLayers.size();
1385 // Notify all layers of available frames
1386 for (size_t i = 0; i < count; ++i) {
1387 currentLayers[i]->notifyAvailableFrames();
1391 * Traversal of the children
1392 * (perform the transaction for each of them if needed)
1395 if (transactionFlags & eTraversalNeeded) {
1396 for (size_t i=0 ; i<count ; i++) {
1397 const sp<Layer>& layer(currentLayers[i]);
1398 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
1399 if (!trFlags) continue;
1401 const uint32_t flags = layer->doTransaction(0);
1402 if (flags & Layer::eVisibleRegion)
1403 mVisibleRegionsDirty = true;
1408 * Perform display own transactions if needed
1411 if (transactionFlags & eDisplayTransactionNeeded) {
1412 // here we take advantage of Vector's copy-on-write semantics to
1413 // improve performance by skipping the transaction entirely when
1414 // know that the lists are identical
1415 const KeyedVector< wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
1416 const KeyedVector< wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
1417 if (!curr.isIdenticalTo(draw)) {
1418 mVisibleRegionsDirty = true;
1419 const size_t cc = curr.size();
1420 size_t dc = draw.size();
1422 // find the displays that were removed
1423 // (ie: in drawing state but not in current state)
1424 // also handle displays that changed
1425 // (ie: displays that are in both lists)
1426 for (size_t i=0 ; i<dc ; i++) {
1427 const ssize_t j = curr.indexOfKey(draw.keyAt(i));
1429 // in drawing state but not in current state
1430 if (!draw[i].isMainDisplay()) {
1431 // Call makeCurrent() on the primary display so we can
1432 // be sure that nothing associated with this display
1434 const sp<const DisplayDevice> defaultDisplay(getDefaultDisplayDevice());
1435 defaultDisplay->makeCurrent(mEGLDisplay, mEGLContext);
1436 sp<DisplayDevice> hw(getDisplayDevice(draw.keyAt(i)));
1438 hw->disconnect(getHwComposer());
1439 if (draw[i].type < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES)
1440 mEventThread->onHotplugReceived(draw[i].type, false);
1441 mDisplays.removeItem(draw.keyAt(i));
1443 ALOGW("trying to remove the main display");
1446 // this display is in both lists. see if something changed.
1447 const DisplayDeviceState& state(curr[j]);
1448 const wp<IBinder>& display(curr.keyAt(j));
1449 const sp<IBinder> state_binder = IInterface::asBinder(state.surface);
1450 const sp<IBinder> draw_binder = IInterface::asBinder(draw[i].surface);
1451 if (state_binder != draw_binder) {
1452 // changing the surface is like destroying and
1453 // recreating the DisplayDevice, so we just remove it
1454 // from the drawing state, so that it get re-added
1456 sp<DisplayDevice> hw(getDisplayDevice(display));
1458 hw->disconnect(getHwComposer());
1459 mDisplays.removeItem(display);
1460 mDrawingState.displays.removeItemsAt(i);
1462 // at this point we must loop to the next item
1466 const sp<DisplayDevice> disp(getDisplayDevice(display));
1468 if (state.layerStack != draw[i].layerStack) {
1469 disp->setLayerStack(state.layerStack);
1471 if ((state.orientation != draw[i].orientation)
1472 || (state.viewport != draw[i].viewport)
1473 || (state.frame != draw[i].frame))
1475 disp->setProjection(state.orientation,
1476 state.viewport, state.frame);
1478 if (state.width != draw[i].width || state.height != draw[i].height) {
1479 disp->setDisplaySize(state.width, state.height);
1485 // find displays that were added
1486 // (ie: in current state but not in drawing state)
1487 for (size_t i=0 ; i<cc ; i++) {
1488 if (draw.indexOfKey(curr.keyAt(i)) < 0) {
1489 const DisplayDeviceState& state(curr[i]);
1491 sp<DisplaySurface> dispSurface;
1492 sp<IGraphicBufferProducer> producer;
1493 sp<IGraphicBufferProducer> bqProducer;
1494 sp<IGraphicBufferConsumer> bqConsumer;
1495 BufferQueue::createBufferQueue(&bqProducer, &bqConsumer,
1496 new GraphicBufferAlloc());
1498 int32_t hwcDisplayId = -1;
1499 if (state.isVirtualDisplay()) {
1500 // Virtual displays without a surface are dormant:
1501 // they have external state (layer stack, projection,
1502 // etc.) but no internal state (i.e. a DisplayDevice).
1503 if (state.surface != NULL) {
1506 int status = state.surface->query(
1507 NATIVE_WINDOW_WIDTH, &width);
1508 ALOGE_IF(status != NO_ERROR,
1509 "Unable to query width (%d)", status);
1511 status = state.surface->query(
1512 NATIVE_WINDOW_HEIGHT, &height);
1513 ALOGE_IF(status != NO_ERROR,
1514 "Unable to query height (%d)", status);
1515 if (mUseHwcVirtualDisplays &&
1516 (MAX_VIRTUAL_DISPLAY_DIMENSION == 0 ||
1517 (width <= MAX_VIRTUAL_DISPLAY_DIMENSION &&
1518 height <= MAX_VIRTUAL_DISPLAY_DIMENSION))) {
1519 hwcDisplayId = allocateHwcDisplayId(state.type);
1522 sp<VirtualDisplaySurface> vds = new VirtualDisplaySurface(
1523 *mHwc, hwcDisplayId, state.surface,
1524 bqProducer, bqConsumer, state.displayName);
1530 ALOGE_IF(state.surface!=NULL,
1531 "adding a supported display, but rendering "
1532 "surface is provided (%p), ignoring it",
1533 state.surface.get());
1534 hwcDisplayId = allocateHwcDisplayId(state.type);
1535 // for supported (by hwc) displays we provide our
1536 // own rendering surface
1537 dispSurface = new FramebufferSurface(*mHwc, state.type,
1539 producer = bqProducer;
1542 const wp<IBinder>& display(curr.keyAt(i));
1543 if (dispSurface != NULL) {
1544 sp<DisplayDevice> hw = new DisplayDevice(this,
1545 state.type, hwcDisplayId,
1546 mHwc->getFormat(hwcDisplayId), state.isSecure,
1547 display, dispSurface, producer,
1548 mRenderEngine->getEGLConfig());
1549 hw->setLayerStack(state.layerStack);
1550 hw->setProjection(state.orientation,
1551 state.viewport, state.frame);
1552 hw->setDisplayName(state.displayName);
1553 mDisplays.add(display, hw);
1554 if (state.isVirtualDisplay()) {
1555 if (hwcDisplayId >= 0) {
1556 mHwc->setVirtualDisplayProperties(hwcDisplayId,
1557 hw->getWidth(), hw->getHeight(),
1561 mEventThread->onHotplugReceived(state.type, true);
1569 if (transactionFlags & (eTraversalNeeded|eDisplayTransactionNeeded)) {
1570 // The transform hint might have changed for some layers
1571 // (either because a display has changed, or because a layer
1574 // Walk through all the layers in currentLayers,
1575 // and update their transform hint.
1577 // If a layer is visible only on a single display, then that
1578 // display is used to calculate the hint, otherwise we use the
1581 // NOTE: we do this here, rather than in rebuildLayerStacks() so that
1582 // the hint is set before we acquire a buffer from the surface texture.
1584 // NOTE: layer transactions have taken place already, so we use their
1585 // drawing state. However, SurfaceFlinger's own transaction has not
1586 // happened yet, so we must use the current state layer list
1587 // (soon to become the drawing state list).
1589 sp<const DisplayDevice> disp;
1590 uint32_t currentlayerStack = 0;
1591 for (size_t i=0; i<count; i++) {
1592 // NOTE: we rely on the fact that layers are sorted by
1593 // layerStack first (so we don't have to traverse the list
1594 // of displays for every layer).
1595 const sp<Layer>& layer(currentLayers[i]);
1596 uint32_t layerStack = layer->getDrawingState().layerStack;
1597 if (i==0 || currentlayerStack != layerStack) {
1598 currentlayerStack = layerStack;
1599 // figure out if this layerstack is mirrored
1600 // (more than one display) if so, pick the default display,
1601 // if not, pick the only display it's on.
1603 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1604 sp<const DisplayDevice> hw(mDisplays[dpy]);
1605 if (hw->getLayerStack() == currentlayerStack) {
1616 // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
1617 // redraw after transform hint changes. See bug 8508397.
1619 // could be null when this layer is using a layerStack
1620 // that is not visible on any display. Also can occur at
1621 // screen off/on times.
1622 disp = getDefaultDisplayDevice();
1624 layer->updateTransformHint(disp);
1630 * Perform our own transaction if needed
1633 const LayerVector& layers(mDrawingState.layersSortedByZ);
1634 if (currentLayers.size() > layers.size()) {
1635 // layers have been added
1636 mVisibleRegionsDirty = true;
1639 // some layers might have been removed, so
1640 // we need to update the regions they're exposing.
1641 if (mLayersRemoved) {
1642 mLayersRemoved = false;
1643 mVisibleRegionsDirty = true;
1644 const size_t count = layers.size();
1645 for (size_t i=0 ; i<count ; i++) {
1646 const sp<Layer>& layer(layers[i]);
1647 if (currentLayers.indexOf(layer) < 0) {
1648 // this layer is not visible anymore
1649 // TODO: we could traverse the tree from front to back and
1650 // compute the actual visible region
1651 // TODO: we could cache the transformed region
1652 const Layer::State& s(layer->getDrawingState());
1653 Region visibleReg = s.active.transform.transform(
1654 Region(Rect(s.active.w, s.active.h)));
1655 invalidateLayerStack(s.layerStack, visibleReg);
1660 commitTransaction();
1662 updateCursorAsync();
1665 void SurfaceFlinger::updateCursorAsync()
1667 HWComposer& hwc(getHwComposer());
1668 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1669 sp<const DisplayDevice> hw(mDisplays[dpy]);
1670 const int32_t id = hw->getHwcDisplayId();
1674 const Vector< sp<Layer> >& currentLayers(
1675 hw->getVisibleLayersSortedByZ());
1676 const size_t count = currentLayers.size();
1677 HWComposer::LayerListIterator cur = hwc.begin(id);
1678 const HWComposer::LayerListIterator end = hwc.end(id);
1679 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1680 if (cur->getCompositionType() != HWC_CURSOR_OVERLAY) {
1683 const sp<Layer>& layer(currentLayers[i]);
1684 Rect cursorPos = layer->getPosition(hw);
1685 hwc.setCursorPositionAsync(id, cursorPos);
1691 void SurfaceFlinger::commitTransaction()
1693 if (!mLayersPendingRemoval.isEmpty()) {
1694 // Notify removed layers now that they can't be drawn from
1695 for (size_t i = 0; i < mLayersPendingRemoval.size(); i++) {
1696 recordBufferingStats(mLayersPendingRemoval[i]->getName().string(),
1697 mLayersPendingRemoval[i]->getOccupancyHistory(true));
1698 mLayersPendingRemoval[i]->onRemoved();
1700 mLayersPendingRemoval.clear();
1703 // If this transaction is part of a window animation then the next frame
1704 // we composite should be considered an animation as well.
1705 mAnimCompositionPending = mAnimTransactionPending;
1707 mDrawingState = mCurrentState;
1708 mTransactionPending = false;
1709 mAnimTransactionPending = false;
1710 mTransactionCV.broadcast();
1713 void SurfaceFlinger::computeVisibleRegions(
1714 const LayerVector& currentLayers, uint32_t layerStack,
1715 Region& outDirtyRegion, Region& outOpaqueRegion)
1719 Region aboveOpaqueLayers;
1720 Region aboveCoveredLayers;
1723 outDirtyRegion.clear();
1725 size_t i = currentLayers.size();
1727 const sp<Layer>& layer = currentLayers[i];
1729 // start with the whole surface at its current location
1730 const Layer::State& s(layer->getDrawingState());
1732 // only consider the layers on the given layer stack
1733 if (s.layerStack != layerStack)
1737 * opaqueRegion: area of a surface that is fully opaque.
1739 Region opaqueRegion;
1742 * visibleRegion: area of a surface that is visible on screen
1743 * and not fully transparent. This is essentially the layer's
1744 * footprint minus the opaque regions above it.
1745 * Areas covered by a translucent surface are considered visible.
1747 Region visibleRegion;
1750 * coveredRegion: area of a surface that is covered by all
1751 * visible regions above it (which includes the translucent areas).
1753 Region coveredRegion;
1756 * transparentRegion: area of a surface that is hinted to be completely
1757 * transparent. This is only used to tell when the layer has no visible
1758 * non-transparent regions and can be removed from the layer list. It
1759 * does not affect the visibleRegion of this layer or any layers
1760 * beneath it. The hint may not be correct if apps don't respect the
1761 * SurfaceView restrictions (which, sadly, some don't).
1763 Region transparentRegion;
1766 // handle hidden surfaces by setting the visible region to empty
1767 if (CC_LIKELY(layer->isVisible())) {
1768 const bool translucent = !layer->isOpaque(s);
1769 Rect bounds(s.active.transform.transform(layer->computeBounds()));
1770 visibleRegion.set(bounds);
1771 if (!visibleRegion.isEmpty()) {
1772 // Remove the transparent area from the visible region
1774 const Transform tr(s.active.transform);
1775 if (tr.preserveRects()) {
1776 // transform the transparent region
1777 transparentRegion = tr.transform(s.activeTransparentRegion);
1779 // transformation too complex, can't do the
1780 // transparent region optimization.
1781 transparentRegion.clear();
1785 // compute the opaque region
1786 const int32_t layerOrientation = s.active.transform.getOrientation();
1787 if (s.alpha==255 && !translucent &&
1788 ((layerOrientation & Transform::ROT_INVALID) == false)) {
1789 // the opaque region is the layer's footprint
1790 opaqueRegion = visibleRegion;
1795 // Clip the covered region to the visible region
1796 coveredRegion = aboveCoveredLayers.intersect(visibleRegion);
1798 // Update aboveCoveredLayers for next (lower) layer
1799 aboveCoveredLayers.orSelf(visibleRegion);
1801 // subtract the opaque region covered by the layers above us
1802 visibleRegion.subtractSelf(aboveOpaqueLayers);
1804 // compute this layer's dirty region
1805 if (layer->contentDirty) {
1806 // we need to invalidate the whole region
1807 dirty = visibleRegion;
1808 // as well, as the old visible region
1809 dirty.orSelf(layer->visibleRegion);
1810 layer->contentDirty = false;
1812 /* compute the exposed region:
1813 * the exposed region consists of two components:
1814 * 1) what's VISIBLE now and was COVERED before
1815 * 2) what's EXPOSED now less what was EXPOSED before
1817 * note that (1) is conservative, we start with the whole
1818 * visible region but only keep what used to be covered by
1819 * something -- which mean it may have been exposed.
1821 * (2) handles areas that were not covered by anything but got
1822 * exposed because of a resize.
1824 const Region newExposed = visibleRegion - coveredRegion;
1825 const Region oldVisibleRegion = layer->visibleRegion;
1826 const Region oldCoveredRegion = layer->coveredRegion;
1827 const Region oldExposed = oldVisibleRegion - oldCoveredRegion;
1828 dirty = (visibleRegion&oldCoveredRegion) | (newExposed-oldExposed);
1830 dirty.subtractSelf(aboveOpaqueLayers);
1832 // accumulate to the screen dirty region
1833 outDirtyRegion.orSelf(dirty);
1835 // Update aboveOpaqueLayers for next (lower) layer
1836 aboveOpaqueLayers.orSelf(opaqueRegion);
1838 // Store the visible region in screen space
1839 layer->setVisibleRegion(visibleRegion);
1840 layer->setCoveredRegion(coveredRegion);
1841 layer->setVisibleNonTransparentRegion(
1842 visibleRegion.subtract(transparentRegion));
1845 outOpaqueRegion = aboveOpaqueLayers;
1848 void SurfaceFlinger::invalidateLayerStack(uint32_t layerStack,
1849 const Region& dirty) {
1850 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1851 const sp<DisplayDevice>& hw(mDisplays[dpy]);
1852 if (hw->getLayerStack() == layerStack) {
1853 hw->dirtyRegion.orSelf(dirty);
1858 bool SurfaceFlinger::handlePageFlip()
1862 bool visibleRegions = false;
1863 const LayerVector& layers(mDrawingState.layersSortedByZ);
1864 bool frameQueued = false;
1866 // Store the set of layers that need updates. This set must not change as
1867 // buffers are being latched, as this could result in a deadlock.
1868 // Example: Two producers share the same command stream and:
1869 // 1.) Layer 0 is latched
1870 // 2.) Layer 0 gets a new frame
1871 // 2.) Layer 1 gets a new frame
1872 // 3.) Layer 1 is latched.
1873 // Display is now waiting on Layer 1's frame, which is behind layer 0's
1874 // second frame. But layer 0's second frame could be waiting on display.
1875 Vector<Layer*> layersWithQueuedFrames;
1876 for (size_t i = 0, count = layers.size(); i<count ; i++) {
1877 const sp<Layer>& layer(layers[i]);
1878 if (layer->hasQueuedFrame()) {
1880 if (layer->shouldPresentNow(mPrimaryDispSync)) {
1881 layersWithQueuedFrames.push_back(layer.get());
1883 layer->useEmptyDamage();
1886 layer->useEmptyDamage();
1889 for (size_t i = 0, count = layersWithQueuedFrames.size() ; i<count ; i++) {
1890 Layer* layer = layersWithQueuedFrames[i];
1891 const Region dirty(layer->latchBuffer(visibleRegions));
1892 layer->useSurfaceDamage();
1893 const Layer::State& s(layer->getDrawingState());
1894 invalidateLayerStack(s.layerStack, dirty);
1897 mVisibleRegionsDirty |= visibleRegions;
1899 // If we will need to wake up at some time in the future to deal with a
1900 // queued frame that shouldn't be displayed during this vsync period, wake
1901 // up during the next vsync period to check again.
1902 if (frameQueued && layersWithQueuedFrames.empty()) {
1903 signalLayerUpdate();
1906 // Only continue with the refresh if there is actually new work to do
1907 return !layersWithQueuedFrames.empty();
1910 void SurfaceFlinger::invalidateHwcGeometry()
1912 mHwWorkListDirty = true;
1916 void SurfaceFlinger::doDisplayComposition(const sp<const DisplayDevice>& hw,
1917 const Region& inDirtyRegion)
1919 // We only need to actually compose the display if:
1920 // 1) It is being handled by hardware composer, which may need this to
1921 // keep its virtual display state machine in sync, or
1922 // 2) There is work to be done (the dirty region isn't empty)
1923 bool isHwcDisplay = hw->getHwcDisplayId() >= 0;
1924 if (!isHwcDisplay && inDirtyRegion.isEmpty()) {
1928 Region dirtyRegion(inDirtyRegion);
1930 // compute the invalid region
1931 hw->swapRegion.orSelf(dirtyRegion);
1933 uint32_t flags = hw->getFlags();
1934 if (flags & DisplayDevice::SWAP_RECTANGLE) {
1935 // we can redraw only what's dirty, but since SWAP_RECTANGLE only
1936 // takes a rectangle, we must make sure to update that whole
1937 // rectangle in that case
1938 dirtyRegion.set(hw->swapRegion.bounds());
1940 if (flags & DisplayDevice::PARTIAL_UPDATES) {
1941 // We need to redraw the rectangle that will be updated
1942 // (pushed to the framebuffer).
1943 // This is needed because PARTIAL_UPDATES only takes one
1944 // rectangle instead of a region (see DisplayDevice::flip())
1945 dirtyRegion.set(hw->swapRegion.bounds());
1947 // we need to redraw everything (the whole screen)
1948 dirtyRegion.set(hw->bounds());
1949 hw->swapRegion = dirtyRegion;
1953 if (CC_LIKELY(!mDaltonize && !mHasColorMatrix)) {
1954 if (!doComposeSurfaces(hw, dirtyRegion)) return;
1956 RenderEngine& engine(getRenderEngine());
1957 mat4 colorMatrix = mColorMatrix;
1959 colorMatrix = colorMatrix * mDaltonizer();
1961 mat4 oldMatrix = engine.setupColorTransform(colorMatrix);
1962 doComposeSurfaces(hw, dirtyRegion);
1963 engine.setupColorTransform(oldMatrix);
1966 // update the swap region and clear the dirty region
1967 hw->swapRegion.orSelf(dirtyRegion);
1969 // swap buffers (presentation)
1970 hw->swapBuffers(getHwComposer());
1973 bool SurfaceFlinger::doComposeSurfaces(const sp<const DisplayDevice>& hw, const Region& dirty)
1975 RenderEngine& engine(getRenderEngine());
1976 const int32_t id = hw->getHwcDisplayId();
1977 HWComposer& hwc(getHwComposer());
1978 HWComposer::LayerListIterator cur = hwc.begin(id);
1979 const HWComposer::LayerListIterator end = hwc.end(id);
1981 bool hasGlesComposition = hwc.hasGlesComposition(id);
1982 if (hasGlesComposition) {
1983 if (!hw->makeCurrent(mEGLDisplay, mEGLContext)) {
1984 ALOGW("DisplayDevice::makeCurrent failed. Aborting surface composition for display %s",
1985 hw->getDisplayName().string());
1986 eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
1987 if(!getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext)) {
1988 ALOGE("DisplayDevice::makeCurrent on default display failed. Aborting.");
1993 // Never touch the framebuffer if we don't have any framebuffer layers
1994 const bool hasHwcComposition = hwc.hasHwcComposition(id);
1995 if (hasHwcComposition) {
1996 // when using overlays, we assume a fully transparent framebuffer
1997 // NOTE: we could reduce how much we need to clear, for instance
1998 // remove where there are opaque FB layers. however, on some
1999 // GPUs doing a "clean slate" clear might be more efficient.
2000 // We'll revisit later if needed.
2001 engine.clearWithColor(0, 0, 0, 0);
2003 // we start with the whole screen area
2004 const Region bounds(hw->getBounds());
2006 // we remove the scissor part
2007 // we're left with the letterbox region
2008 // (common case is that letterbox ends-up being empty)
2009 const Region letterbox(bounds.subtract(hw->getScissor()));
2011 // compute the area to clear
2012 Region region(hw->undefinedRegion.merge(letterbox));
2014 // but limit it to the dirty region
2015 region.andSelf(dirty);
2017 // screen is already cleared here
2018 if (!region.isEmpty()) {
2019 // can happen with SurfaceView
2020 drawWormhole(hw, region);
2024 if (hw->getDisplayType() != DisplayDevice::DISPLAY_PRIMARY) {
2025 // just to be on the safe side, we don't set the
2026 // scissor on the main display. It should never be needed
2027 // anyways (though in theory it could since the API allows it).
2028 const Rect& bounds(hw->getBounds());
2029 const Rect& scissor(hw->getScissor());
2030 if (scissor != bounds) {
2031 // scissor doesn't match the screen's dimensions, so we
2032 // need to clear everything outside of it and enable
2033 // the GL scissor so we don't draw anything where we shouldn't
2035 // enable scissor for this frame
2036 const uint32_t height = hw->getHeight();
2037 engine.setScissor(scissor.left, height - scissor.bottom,
2038 scissor.getWidth(), scissor.getHeight());
2044 * and then, render the layers targeted at the framebuffer
2047 const Vector< sp<Layer> >& layers(hw->getVisibleLayersSortedByZ());
2048 const size_t count = layers.size();
2049 const Transform& tr = hw->getTransform();
2051 // we're using h/w composer
2052 for (size_t i=0 ; i<count && cur!=end ; ++i, ++cur) {
2053 const sp<Layer>& layer(layers[i]);
2054 const Region clip(dirty.intersect(tr.transform(layer->visibleRegion)));
2055 if (!clip.isEmpty()) {
2056 switch (cur->getCompositionType()) {
2057 case HWC_CURSOR_OVERLAY:
2059 const Layer::State& state(layer->getDrawingState());
2060 if ((cur->getHints() & HWC_HINT_CLEAR_FB)
2062 && layer->isOpaque(state) && (state.alpha == 0xFF)
2063 && hasGlesComposition) {
2064 // never clear the very first layer since we're
2065 // guaranteed the FB is already cleared
2066 layer->clearWithOpenGL(hw, clip);
2070 case HWC_FRAMEBUFFER: {
2071 layer->draw(hw, clip);
2074 case HWC_FRAMEBUFFER_TARGET: {
2075 // this should not happen as the iterator shouldn't
2076 // let us get there.
2077 ALOGW("HWC_FRAMEBUFFER_TARGET found in hwc list (index=%zu)", i);
2082 layer->setAcquireFence(hw, *cur);
2085 // we're not using h/w composer
2086 for (size_t i=0 ; i<count ; ++i) {
2087 const sp<Layer>& layer(layers[i]);
2088 const Region clip(dirty.intersect(
2089 tr.transform(layer->visibleRegion)));
2090 if (!clip.isEmpty()) {
2091 layer->draw(hw, clip);
2096 // disable scissor at the end of the frame
2097 engine.disableScissor();
2101 void SurfaceFlinger::drawWormhole(const sp<const DisplayDevice>& hw, const Region& region) const {
2102 const int32_t height = hw->getHeight();
2103 RenderEngine& engine(getRenderEngine());
2104 engine.fillRegionWithColor(region, height, 0, 0, 0, 0);
2107 status_t SurfaceFlinger::addClientLayer(const sp<Client>& client,
2108 const sp<IBinder>& handle,
2109 const sp<IGraphicBufferProducer>& gbc,
2110 const sp<Layer>& lbc)
2112 // add this layer to the current state list
2114 Mutex::Autolock _l(mStateLock);
2115 if (mCurrentState.layersSortedByZ.size() >= MAX_LAYERS) {
2118 mCurrentState.layersSortedByZ.add(lbc);
2119 mGraphicBufferProducerList.add(IInterface::asBinder(gbc));
2122 // attach this layer to the client
2123 client->attachLayer(handle, lbc);
2128 status_t SurfaceFlinger::removeLayer(const wp<Layer>& weakLayer) {
2129 Mutex::Autolock _l(mStateLock);
2130 sp<Layer> layer = weakLayer.promote();
2131 if (layer == nullptr) {
2132 // The layer has already been removed, carry on
2136 ssize_t index = mCurrentState.layersSortedByZ.remove(layer);
2138 mLayersPendingRemoval.push(layer);
2139 mLayersRemoved = true;
2140 setTransactionFlags(eTransactionNeeded);
2143 return status_t(index);
2146 uint32_t SurfaceFlinger::peekTransactionFlags(uint32_t /* flags */) {
2147 return android_atomic_release_load(&mTransactionFlags);
2150 uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) {
2151 return android_atomic_and(~flags, &mTransactionFlags) & flags;
2154 uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) {
2155 uint32_t old = android_atomic_or(flags, &mTransactionFlags);
2156 if ((old & flags)==0) { // wake the server up
2157 signalTransaction();
2162 void SurfaceFlinger::setTransactionState(
2163 const Vector<ComposerState>& state,
2164 const Vector<DisplayState>& displays,
2168 Mutex::Autolock _l(mStateLock);
2169 uint32_t transactionFlags = 0;
2171 if (flags & eAnimation) {
2172 // For window updates that are part of an animation we must wait for
2173 // previous animation "frames" to be handled.
2174 while (mAnimTransactionPending) {
2175 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
2176 if (CC_UNLIKELY(err != NO_ERROR)) {
2177 // just in case something goes wrong in SF, return to the
2178 // caller after a few seconds.
2179 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out "
2180 "waiting for previous animation frame");
2181 mAnimTransactionPending = false;
2187 size_t count = displays.size();
2188 for (size_t i=0 ; i<count ; i++) {
2189 const DisplayState& s(displays[i]);
2190 transactionFlags |= setDisplayStateLocked(s);
2193 count = state.size();
2194 for (size_t i=0 ; i<count ; i++) {
2195 const ComposerState& s(state[i]);
2196 // Here we need to check that the interface we're given is indeed
2197 // one of our own. A malicious client could give us a NULL
2198 // IInterface, or one of its own or even one of our own but a
2199 // different type. All these situations would cause us to crash.
2201 // NOTE: it would be better to use RTTI as we could directly check
2202 // that we have a Client*. however, RTTI is disabled in Android.
2203 if (s.client != NULL) {
2204 sp<IBinder> binder = IInterface::asBinder(s.client);
2205 if (binder != NULL) {
2206 if (binder->queryLocalInterface(ISurfaceComposerClient::descriptor) != NULL) {
2207 sp<Client> client( static_cast<Client *>(s.client.get()) );
2208 transactionFlags |= setClientStateLocked(client, s.state);
2214 // If a synchronous transaction is explicitly requested without any changes,
2215 // force a transaction anyway. This can be used as a flush mechanism for
2216 // previous async transactions.
2217 if (transactionFlags == 0 && (flags & eSynchronous)) {
2218 transactionFlags = eTransactionNeeded;
2221 if (transactionFlags) {
2222 // this triggers the transaction
2223 setTransactionFlags(transactionFlags);
2225 // if this is a synchronous transaction, wait for it to take effect
2226 // before returning.
2227 if (flags & eSynchronous) {
2228 mTransactionPending = true;
2230 if (flags & eAnimation) {
2231 mAnimTransactionPending = true;
2233 while (mTransactionPending) {
2234 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
2235 if (CC_UNLIKELY(err != NO_ERROR)) {
2236 // just in case something goes wrong in SF, return to the
2237 // called after a few seconds.
2238 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");
2239 mTransactionPending = false;
2246 uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s)
2248 ssize_t dpyIdx = mCurrentState.displays.indexOfKey(s.token);
2253 DisplayDeviceState& disp(mCurrentState.displays.editValueAt(dpyIdx));
2254 if (disp.isValid()) {
2255 const uint32_t what = s.what;
2256 if (what & DisplayState::eSurfaceChanged) {
2257 if (IInterface::asBinder(disp.surface) != IInterface::asBinder(s.surface)) {
2258 disp.surface = s.surface;
2259 flags |= eDisplayTransactionNeeded;
2262 if (what & DisplayState::eLayerStackChanged) {
2263 if (disp.layerStack != s.layerStack) {
2264 disp.layerStack = s.layerStack;
2265 flags |= eDisplayTransactionNeeded;
2268 if (what & DisplayState::eDisplayProjectionChanged) {
2269 if (disp.orientation != s.orientation) {
2270 disp.orientation = s.orientation;
2271 flags |= eDisplayTransactionNeeded;
2273 if (disp.frame != s.frame) {
2274 disp.frame = s.frame;
2275 flags |= eDisplayTransactionNeeded;
2277 if (disp.viewport != s.viewport) {
2278 disp.viewport = s.viewport;
2279 flags |= eDisplayTransactionNeeded;
2282 if (what & DisplayState::eDisplaySizeChanged) {
2283 if (disp.width != s.width) {
2284 disp.width = s.width;
2285 flags |= eDisplayTransactionNeeded;
2287 if (disp.height != s.height) {
2288 disp.height = s.height;
2289 flags |= eDisplayTransactionNeeded;
2296 uint32_t SurfaceFlinger::setClientStateLocked(
2297 const sp<Client>& client,
2298 const layer_state_t& s)
2301 sp<Layer> layer(client->getLayerUser(s.surface));
2303 const uint32_t what = s.what;
2304 bool geometryAppliesWithResize =
2305 what & layer_state_t::eGeometryAppliesWithResize;
2306 if (what & layer_state_t::ePositionChanged) {
2307 if (layer->setPosition(s.x, s.y, !geometryAppliesWithResize)) {
2308 flags |= eTraversalNeeded;
2311 if (what & layer_state_t::eLayerChanged) {
2312 // NOTE: index needs to be calculated before we update the state
2313 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
2314 if (layer->setLayer(s.z) && idx >= 0) {
2315 mCurrentState.layersSortedByZ.removeAt(idx);
2316 mCurrentState.layersSortedByZ.add(layer);
2317 // we need traversal (state changed)
2318 // AND transaction (list changed)
2319 flags |= eTransactionNeeded|eTraversalNeeded;
2322 if (what & layer_state_t::eSizeChanged) {
2323 if (layer->setSize(s.w, s.h)) {
2324 flags |= eTraversalNeeded;
2327 if (what & layer_state_t::eAlphaChanged) {
2328 if (layer->setAlpha(uint8_t(255.0f*s.alpha+0.5f)))
2329 flags |= eTraversalNeeded;
2331 if (what & layer_state_t::eMatrixChanged) {
2332 if (layer->setMatrix(s.matrix))
2333 flags |= eTraversalNeeded;
2335 if (what & layer_state_t::eTransparentRegionChanged) {
2336 if (layer->setTransparentRegionHint(s.transparentRegion))
2337 flags |= eTraversalNeeded;
2339 if (what & layer_state_t::eFlagsChanged) {
2340 if (layer->setFlags(s.flags, s.mask))
2341 flags |= eTraversalNeeded;
2343 if (what & layer_state_t::eCropChanged) {
2344 if (layer->setCrop(s.crop, !geometryAppliesWithResize))
2345 flags |= eTraversalNeeded;
2347 if (what & layer_state_t::eFinalCropChanged) {
2348 if (layer->setFinalCrop(s.finalCrop))
2349 flags |= eTraversalNeeded;
2351 if (what & layer_state_t::eLayerStackChanged) {
2352 // NOTE: index needs to be calculated before we update the state
2353 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
2354 if (layer->setLayerStack(s.layerStack) && idx >= 0) {
2355 mCurrentState.layersSortedByZ.removeAt(idx);
2356 mCurrentState.layersSortedByZ.add(layer);
2357 // we need traversal (state changed)
2358 // AND transaction (list changed)
2359 flags |= eTransactionNeeded|eTraversalNeeded;
2362 if (what & layer_state_t::eDeferTransaction) {
2363 layer->deferTransactionUntil(s.handle, s.frameNumber);
2364 // We don't trigger a traversal here because if no other state is
2365 // changed, we don't want this to cause any more work
2367 if (what & layer_state_t::eOverrideScalingModeChanged) {
2368 layer->setOverrideScalingMode(s.overrideScalingMode);
2369 // We don't trigger a traversal here because if no other state is
2370 // changed, we don't want this to cause any more work
2376 status_t SurfaceFlinger::createLayer(
2377 const String8& name,
2378 const sp<Client>& client,
2379 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
2380 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp)
2382 //ALOGD("createLayer for (%d x %d), name=%s", w, h, name.string());
2383 if (int32_t(w|h) < 0) {
2384 ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
2389 status_t result = NO_ERROR;
2393 switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
2394 case ISurfaceComposerClient::eFXSurfaceNormal:
2395 result = createNormalLayer(client,
2396 name, w, h, flags, format,
2397 handle, gbp, &layer);
2399 case ISurfaceComposerClient::eFXSurfaceDim:
2400 result = createDimLayer(client,
2402 handle, gbp, &layer);
2409 if (result != NO_ERROR) {
2413 result = addClientLayer(client, *handle, *gbp, layer);
2414 if (result != NO_ERROR) {
2418 setTransactionFlags(eTransactionNeeded);
2422 status_t SurfaceFlinger::createNormalLayer(const sp<Client>& client,
2423 const String8& name, uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
2424 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
2426 // initialize the surfaces
2428 case PIXEL_FORMAT_TRANSPARENT:
2429 case PIXEL_FORMAT_TRANSLUCENT:
2430 format = PIXEL_FORMAT_RGBA_8888;
2432 case PIXEL_FORMAT_OPAQUE:
2433 format = PIXEL_FORMAT_RGBX_8888;
2437 *outLayer = new Layer(this, client, name, w, h, flags);
2438 status_t err = (*outLayer)->setBuffers(w, h, format, flags);
2439 if (err == NO_ERROR) {
2440 *handle = (*outLayer)->getHandle();
2441 *gbp = (*outLayer)->getProducer();
2444 ALOGE_IF(err, "createNormalLayer() failed (%s)", strerror(-err));
2448 status_t SurfaceFlinger::createDimLayer(const sp<Client>& client,
2449 const String8& name, uint32_t w, uint32_t h, uint32_t flags,
2450 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
2452 *outLayer = new LayerDim(this, client, name, w, h, flags);
2453 *handle = (*outLayer)->getHandle();
2454 *gbp = (*outLayer)->getProducer();
2458 status_t SurfaceFlinger::onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle)
2460 // called by the window manager when it wants to remove a Layer
2461 status_t err = NO_ERROR;
2462 sp<Layer> l(client->getLayerUser(handle));
2464 err = removeLayer(l);
2465 ALOGE_IF(err<0 && err != NAME_NOT_FOUND,
2466 "error removing layer=%p (%s)", l.get(), strerror(-err));
2471 status_t SurfaceFlinger::onLayerDestroyed(const wp<Layer>& layer)
2473 // called by ~LayerCleaner() when all references to the IBinder (handle)
2475 return removeLayer(layer);
2478 // ---------------------------------------------------------------------------
2480 void SurfaceFlinger::onInitializeDisplays() {
2481 // reset screen orientation and use primary layer stack
2482 Vector<ComposerState> state;
2483 Vector<DisplayState> displays;
2485 d.what = DisplayState::eDisplayProjectionChanged |
2486 DisplayState::eLayerStackChanged;
2487 d.token = mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY];
2489 d.orientation = DisplayState::eOrientationDefault;
2490 d.frame.makeInvalid();
2491 d.viewport.makeInvalid();
2495 setTransactionState(state, displays, 0);
2496 setPowerModeInternal(getDisplayDevice(d.token), HWC_POWER_MODE_NORMAL);
2498 const nsecs_t period =
2499 getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
2500 mAnimFrameTracker.setDisplayRefreshPeriod(period);
2503 void SurfaceFlinger::initializeDisplays() {
2504 class MessageScreenInitialized : public MessageBase {
2505 SurfaceFlinger* flinger;
2507 MessageScreenInitialized(SurfaceFlinger* flinger) : flinger(flinger) { }
2508 virtual bool handler() {
2509 flinger->onInitializeDisplays();
2513 sp<MessageBase> msg = new MessageScreenInitialized(this);
2514 postMessageAsync(msg); // we may be called from main thread, use async message
2517 void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& hw,
2519 ALOGD("Set power mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(),
2521 int32_t type = hw->getDisplayType();
2522 int currentMode = hw->getPowerMode();
2524 if (mode == currentMode) {
2525 ALOGD("Screen type=%d is already mode=%d", hw->getDisplayType(), mode);
2529 hw->setPowerMode(mode);
2530 if (type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
2531 ALOGW("Trying to set power mode for virtual display");
2535 if (currentMode == HWC_POWER_MODE_OFF) {
2536 // Turn on the display
2537 getHwComposer().setPowerMode(type, mode);
2538 if (type == DisplayDevice::DISPLAY_PRIMARY) {
2539 // FIXME: eventthread only knows about the main display right now
2540 mEventThread->onScreenAcquired();
2541 resyncToHardwareVsync(true);
2544 mVisibleRegionsDirty = true;
2545 mHasPoweredOff = true;
2546 repaintEverything();
2548 struct sched_param param = {0};
2549 param.sched_priority = 1;
2550 if (sched_setscheduler(0, SCHED_FIFO, ¶m) != 0) {
2551 ALOGW("Couldn't set SCHED_FIFO on display on");
2553 } else if (mode == HWC_POWER_MODE_OFF) {
2554 // Turn off the display
2555 struct sched_param param = {0};
2556 if (sched_setscheduler(0, SCHED_OTHER, ¶m) != 0) {
2557 ALOGW("Couldn't set SCHED_OTHER on display off");
2560 if (type == DisplayDevice::DISPLAY_PRIMARY) {
2561 disableHardwareVsync(true); // also cancels any in-progress resync
2563 // FIXME: eventthread only knows about the main display right now
2564 mEventThread->onScreenReleased();
2567 getHwComposer().setPowerMode(type, mode);
2568 mVisibleRegionsDirty = true;
2569 // from this point on, SF will stop drawing on this display
2571 getHwComposer().setPowerMode(type, mode);
2575 void SurfaceFlinger::setPowerMode(const sp<IBinder>& display, int mode) {
2576 class MessageSetPowerMode: public MessageBase {
2577 SurfaceFlinger& mFlinger;
2578 sp<IBinder> mDisplay;
2581 MessageSetPowerMode(SurfaceFlinger& flinger,
2582 const sp<IBinder>& disp, int mode) : mFlinger(flinger),
2583 mDisplay(disp) { mMode = mode; }
2584 virtual bool handler() {
2585 sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
2587 ALOGE("Attempt to set power mode = %d for null display %p",
2588 mMode, mDisplay.get());
2589 } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) {
2590 ALOGW("Attempt to set power mode = %d for virtual display",
2593 mFlinger.setPowerModeInternal(hw, mMode);
2598 sp<MessageBase> msg = new MessageSetPowerMode(*this, display, mode);
2599 postMessageSync(msg);
2602 // ---------------------------------------------------------------------------
2604 status_t SurfaceFlinger::dump(int fd, const Vector<String16>& args)
2608 IPCThreadState* ipc = IPCThreadState::self();
2609 const int pid = ipc->getCallingPid();
2610 const int uid = ipc->getCallingUid();
2611 if ((uid != AID_SHELL) &&
2612 !PermissionCache::checkPermission(sDump, pid, uid)) {
2613 result.appendFormat("Permission Denial: "
2614 "can't dump SurfaceFlinger from pid=%d, uid=%d\n", pid, uid);
2616 // Try to get the main lock, but give up after one second
2617 // (this would indicate SF is stuck, but we want to be able to
2618 // print something in dumpsys).
2619 status_t err = mStateLock.timedLock(s2ns(1));
2620 bool locked = (err == NO_ERROR);
2622 result.appendFormat(
2623 "SurfaceFlinger appears to be unresponsive (%s [%d]), "
2624 "dumping anyways (no locks held)\n", strerror(-err), err);
2627 bool dumpAll = true;
2629 size_t numArgs = args.size();
2631 if ((index < numArgs) &&
2632 (args[index] == String16("--list"))) {
2634 listLayersLocked(args, index, result);
2638 if ((index < numArgs) &&
2639 (args[index] == String16("--latency"))) {
2641 dumpStatsLocked(args, index, result);
2645 if ((index < numArgs) &&
2646 (args[index] == String16("--latency-clear"))) {
2648 clearStatsLocked(args, index, result);
2652 if ((index < numArgs) &&
2653 (args[index] == String16("--dispsync"))) {
2655 mPrimaryDispSync.dump(result);
2659 if ((index < numArgs) &&
2660 (args[index] == String16("--static-screen"))) {
2662 dumpStaticScreenStats(result);
2666 if ((index < numArgs) &&
2667 (args[index] == String16("--fences"))) {
2669 mFenceTracker.dump(&result);
2675 dumpAllLocked(args, index, result);
2679 mStateLock.unlock();
2682 write(fd, result.string(), result.size());
2686 void SurfaceFlinger::listLayersLocked(const Vector<String16>& /* args */,
2687 size_t& /* index */, String8& result) const
2689 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
2690 const size_t count = currentLayers.size();
2691 for (size_t i=0 ; i<count ; i++) {
2692 const sp<Layer>& layer(currentLayers[i]);
2693 result.appendFormat("%s\n", layer->getName().string());
2697 void SurfaceFlinger::dumpStatsLocked(const Vector<String16>& args, size_t& index,
2698 String8& result) const
2701 if (index < args.size()) {
2702 name = String8(args[index]);
2706 const nsecs_t period =
2707 getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
2708 result.appendFormat("%" PRId64 "\n", period);
2710 if (name.isEmpty()) {
2711 mAnimFrameTracker.dumpStats(result);
2713 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
2714 const size_t count = currentLayers.size();
2715 for (size_t i=0 ; i<count ; i++) {
2716 const sp<Layer>& layer(currentLayers[i]);
2717 if (name == layer->getName()) {
2718 layer->dumpFrameStats(result);
2724 void SurfaceFlinger::clearStatsLocked(const Vector<String16>& args, size_t& index,
2725 String8& /* result */)
2728 if (index < args.size()) {
2729 name = String8(args[index]);
2733 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
2734 const size_t count = currentLayers.size();
2735 for (size_t i=0 ; i<count ; i++) {
2736 const sp<Layer>& layer(currentLayers[i]);
2737 if (name.isEmpty() || (name == layer->getName())) {
2738 layer->clearFrameStats();
2742 mAnimFrameTracker.clearStats();
2745 // This should only be called from the main thread. Otherwise it would need
2746 // the lock and should use mCurrentState rather than mDrawingState.
2747 void SurfaceFlinger::logFrameStats() {
2748 const LayerVector& drawingLayers = mDrawingState.layersSortedByZ;
2749 const size_t count = drawingLayers.size();
2750 for (size_t i=0 ; i<count ; i++) {
2751 const sp<Layer>& layer(drawingLayers[i]);
2752 layer->logFrameStats();
2755 mAnimFrameTracker.logAndResetStats(String8("<win-anim>"));
2758 /*static*/ void SurfaceFlinger::appendSfConfigString(String8& result)
2760 static const char* config =
2762 #ifdef HAS_CONTEXT_PRIORITY
2763 " HAS_CONTEXT_PRIORITY"
2765 #ifdef NEVER_DEFAULT_TO_ASYNC_MODE
2766 " NEVER_DEFAULT_TO_ASYNC_MODE"
2768 #ifdef TARGET_DISABLE_TRIPLE_BUFFERING
2769 " TARGET_DISABLE_TRIPLE_BUFFERING"
2772 result.append(config);
2775 void SurfaceFlinger::dumpStaticScreenStats(String8& result) const
2777 result.appendFormat("Static screen stats:\n");
2778 for (size_t b = 0; b < NUM_BUCKETS - 1; ++b) {
2779 float bucketTimeSec = mFrameBuckets[b] / 1e9;
2780 float percent = 100.0f *
2781 static_cast<float>(mFrameBuckets[b]) / mTotalTime;
2782 result.appendFormat(" < %zd frames: %.3f s (%.1f%%)\n",
2783 b + 1, bucketTimeSec, percent);
2785 float bucketTimeSec = mFrameBuckets[NUM_BUCKETS - 1] / 1e9;
2786 float percent = 100.0f *
2787 static_cast<float>(mFrameBuckets[NUM_BUCKETS - 1]) / mTotalTime;
2788 result.appendFormat(" %zd+ frames: %.3f s (%.1f%%)\n",
2789 NUM_BUCKETS - 1, bucketTimeSec, percent);
2792 void SurfaceFlinger::recordBufferingStats(const char* layerName,
2793 std::vector<OccupancyTracker::Segment>&& history) {
2794 Mutex::Autolock lock(mBufferingStatsMutex);
2795 auto& stats = mBufferingStats[layerName];
2796 for (const auto& segment : history) {
2797 if (!segment.usedThirdBuffer) {
2798 stats.twoBufferTime += segment.totalTime;
2800 if (segment.occupancyAverage < 1.0f) {
2801 stats.doubleBufferedTime += segment.totalTime;
2802 } else if (segment.occupancyAverage < 2.0f) {
2803 stats.tripleBufferedTime += segment.totalTime;
2805 ++stats.numSegments;
2806 stats.totalTime += segment.totalTime;
2810 void SurfaceFlinger::dumpBufferingStats(String8& result) const {
2811 result.append("Buffering stats:\n");
2812 result.append(" [Layer name] <Active time> <Two buffer> "
2813 "<Double buffered> <Triple buffered>\n");
2814 Mutex::Autolock lock(mBufferingStatsMutex);
2815 typedef std::tuple<std::string, float, float, float> BufferTuple;
2816 std::map<float, BufferTuple, std::greater<float>> sorted;
2817 for (const auto& statsPair : mBufferingStats) {
2818 const char* name = statsPair.first.c_str();
2819 const BufferingStats& stats = statsPair.second;
2820 if (stats.numSegments == 0) {
2823 float activeTime = ns2ms(stats.totalTime) / 1000.0f;
2824 float twoBufferRatio = static_cast<float>(stats.twoBufferTime) /
2826 float doubleBufferRatio = static_cast<float>(
2827 stats.doubleBufferedTime) / stats.totalTime;
2828 float tripleBufferRatio = static_cast<float>(
2829 stats.tripleBufferedTime) / stats.totalTime;
2830 sorted.insert({activeTime, {name, twoBufferRatio,
2831 doubleBufferRatio, tripleBufferRatio}});
2833 for (const auto& sortedPair : sorted) {
2834 float activeTime = sortedPair.first;
2835 const BufferTuple& values = sortedPair.second;
2836 result.appendFormat(" [%s] %.2f %.3f %.3f %.3f\n",
2837 std::get<0>(values).c_str(), activeTime,
2838 std::get<1>(values), std::get<2>(values),
2839 std::get<3>(values));
2841 result.append("\n");
2844 void SurfaceFlinger::dumpAllLocked(const Vector<String16>& args, size_t& index,
2845 String8& result) const
2847 bool colorize = false;
2848 if (index < args.size()
2849 && (args[index] == String16("--color"))) {
2854 Colorizer colorizer(colorize);
2856 // figure out if we're stuck somewhere
2857 const nsecs_t now = systemTime();
2858 const nsecs_t inSwapBuffers(mDebugInSwapBuffers);
2859 const nsecs_t inTransaction(mDebugInTransaction);
2860 nsecs_t inSwapBuffersDuration = (inSwapBuffers) ? now-inSwapBuffers : 0;
2861 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
2864 * Dump library configuration.
2867 colorizer.bold(result);
2868 result.append("Build configuration:");
2869 colorizer.reset(result);
2870 appendSfConfigString(result);
2871 appendUiConfigString(result);
2872 appendGuiConfigString(result);
2873 result.append("\n");
2875 colorizer.bold(result);
2876 result.append("Sync configuration: ");
2877 colorizer.reset(result);
2878 result.append(SyncFeatures::getInstance().toString());
2879 result.append("\n");
2881 colorizer.bold(result);
2882 result.append("DispSync configuration: ");
2883 colorizer.reset(result);
2884 result.appendFormat("app phase %" PRId64 " ns, sf phase %" PRId64 " ns, "
2885 "present offset %d ns (refresh %" PRId64 " ns)",
2886 vsyncPhaseOffsetNs, sfVsyncPhaseOffsetNs, PRESENT_TIME_OFFSET_FROM_VSYNC_NS,
2887 mHwc->getRefreshPeriod(HWC_DISPLAY_PRIMARY));
2888 result.append("\n");
2890 // Dump static screen stats
2891 result.append("\n");
2892 dumpStaticScreenStats(result);
2893 result.append("\n");
2895 dumpBufferingStats(result);
2898 * Dump the visible layer list
2900 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
2901 const size_t count = currentLayers.size();
2902 colorizer.bold(result);
2903 result.appendFormat("Visible layers (count = %zu)\n", count);
2904 colorizer.reset(result);
2905 for (size_t i=0 ; i<count ; i++) {
2906 const sp<Layer>& layer(currentLayers[i]);
2907 layer->dump(result, colorizer);
2911 * Dump Display state
2914 colorizer.bold(result);
2915 result.appendFormat("Displays (%zu entries)\n", mDisplays.size());
2916 colorizer.reset(result);
2917 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
2918 const sp<const DisplayDevice>& hw(mDisplays[dpy]);
2923 * Dump SurfaceFlinger global state
2926 colorizer.bold(result);
2927 result.append("SurfaceFlinger global state:\n");
2928 colorizer.reset(result);
2930 HWComposer& hwc(getHwComposer());
2931 sp<const DisplayDevice> hw(getDefaultDisplayDevice());
2933 colorizer.bold(result);
2934 result.appendFormat("EGL implementation : %s\n",
2935 eglQueryStringImplementationANDROID(mEGLDisplay, EGL_VERSION));
2936 colorizer.reset(result);
2937 result.appendFormat("%s\n",
2938 eglQueryStringImplementationANDROID(mEGLDisplay, EGL_EXTENSIONS));
2940 mRenderEngine->dump(result);
2942 hw->undefinedRegion.dump(result, "undefinedRegion");
2943 result.appendFormat(" orientation=%d, isDisplayOn=%d\n",
2944 hw->getOrientation(), hw->isDisplayOn());
2945 result.appendFormat(
2946 " last eglSwapBuffers() time: %f us\n"
2947 " last transaction time : %f us\n"
2948 " transaction-flags : %08x\n"
2949 " refresh-rate : %f fps\n"
2952 " gpu_to_cpu_unsupported : %d\n"
2954 mLastSwapBufferTime/1000.0,
2955 mLastTransactionTime/1000.0,
2957 1e9 / hwc.getRefreshPeriod(HWC_DISPLAY_PRIMARY),
2958 hwc.getDpiX(HWC_DISPLAY_PRIMARY),
2959 hwc.getDpiY(HWC_DISPLAY_PRIMARY),
2960 !mGpuToCpuSupported);
2962 result.appendFormat(" eglSwapBuffers time: %f us\n",
2963 inSwapBuffersDuration/1000.0);
2965 result.appendFormat(" transaction time: %f us\n",
2966 inTransactionDuration/1000.0);
2971 mEventThread->dump(result);
2974 * Dump HWComposer state
2976 colorizer.bold(result);
2977 result.append("h/w composer state:\n");
2978 colorizer.reset(result);
2979 result.appendFormat(" h/w composer %s and %s\n",
2980 hwc.initCheck()==NO_ERROR ? "present" : "not present",
2981 (mDebugDisableHWC || mDebugRegion || mDaltonize
2982 || mHasColorMatrix) ? "disabled" : "enabled");
2986 * Dump gralloc state
2988 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
2992 const Vector< sp<Layer> >&
2993 SurfaceFlinger::getLayerSortedByZForHwcDisplay(int id) {
2994 // Note: mStateLock is held here
2996 for (size_t i=0 ; i<mDisplays.size() ; i++) {
2997 if (mDisplays.valueAt(i)->getHwcDisplayId() == id) {
2998 dpy = mDisplays.keyAt(i);
3003 ALOGE("getLayerSortedByZForHwcDisplay: invalid hwc display id %d", id);
3004 // Just use the primary display so we have something to return
3005 dpy = getBuiltInDisplay(DisplayDevice::DISPLAY_PRIMARY);
3007 return getDisplayDevice(dpy)->getVisibleLayersSortedByZ();
3010 bool SurfaceFlinger::startDdmConnection()
3012 void* libddmconnection_dso =
3013 dlopen("libsurfaceflinger_ddmconnection.so", RTLD_NOW);
3014 if (!libddmconnection_dso) {
3017 void (*DdmConnection_start)(const char* name);
3018 DdmConnection_start =
3019 (decltype(DdmConnection_start))dlsym(libddmconnection_dso, "DdmConnection_start");
3020 if (!DdmConnection_start) {
3021 dlclose(libddmconnection_dso);
3024 (*DdmConnection_start)(getServiceName());
3028 status_t SurfaceFlinger::onTransact(
3029 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
3032 case CREATE_CONNECTION:
3033 case CREATE_DISPLAY:
3034 case SET_TRANSACTION_STATE:
3036 case CLEAR_ANIMATION_FRAME_STATS:
3037 case GET_ANIMATION_FRAME_STATS:
3038 case SET_POWER_MODE:
3039 case GET_HDR_CAPABILITIES:
3041 // codes that require permission check
3042 IPCThreadState* ipc = IPCThreadState::self();
3043 const int pid = ipc->getCallingPid();
3044 const int uid = ipc->getCallingUid();
3045 if ((uid != AID_GRAPHICS && uid != AID_SYSTEM) &&
3046 !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)) {
3047 ALOGE("Permission Denial: "
3048 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
3049 return PERMISSION_DENIED;
3053 case CAPTURE_SCREEN:
3055 // codes that require permission check
3056 IPCThreadState* ipc = IPCThreadState::self();
3057 const int pid = ipc->getCallingPid();
3058 const int uid = ipc->getCallingUid();
3059 if ((uid != AID_GRAPHICS) &&
3060 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
3061 ALOGE("Permission Denial: "
3062 "can't read framebuffer pid=%d, uid=%d", pid, uid);
3063 return PERMISSION_DENIED;
3069 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
3070 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
3071 CHECK_INTERFACE(ISurfaceComposer, data, reply);
3072 if (CC_UNLIKELY(!PermissionCache::checkCallingPermission(sHardwareTest))) {
3073 IPCThreadState* ipc = IPCThreadState::self();
3074 const int pid = ipc->getCallingPid();
3075 const int uid = ipc->getCallingUid();
3076 ALOGE("Permission Denial: "
3077 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
3078 return PERMISSION_DENIED;
3082 case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
3083 case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
3085 case 1002: // SHOW_UPDATES
3086 n = data.readInt32();
3087 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
3088 invalidateHwcGeometry();
3089 repaintEverything();
3091 case 1004:{ // repaint everything
3092 repaintEverything();
3095 case 1005:{ // force transaction
3096 setTransactionFlags(
3098 eDisplayTransactionNeeded|
3102 case 1006:{ // send empty update
3106 case 1008: // toggle use of hw composer
3107 n = data.readInt32();
3108 mDebugDisableHWC = n ? 1 : 0;
3109 invalidateHwcGeometry();
3110 repaintEverything();
3112 case 1009: // toggle use of transform hint
3113 n = data.readInt32();
3114 mDebugDisableTransformHint = n ? 1 : 0;
3115 invalidateHwcGeometry();
3116 repaintEverything();
3118 case 1010: // interrogate.
3119 reply->writeInt32(0);
3120 reply->writeInt32(0);
3121 reply->writeInt32(mDebugRegion);
3122 reply->writeInt32(0);
3123 reply->writeInt32(mDebugDisableHWC);
3126 Mutex::Autolock _l(mStateLock);
3127 sp<const DisplayDevice> hw(getDefaultDisplayDevice());
3128 reply->writeInt32(hw->getPageFlipCount());
3133 n = data.readInt32();
3136 mDaltonizer.setType(ColorBlindnessType::Protanomaly);
3139 mDaltonizer.setType(ColorBlindnessType::Deuteranomaly);
3142 mDaltonizer.setType(ColorBlindnessType::Tritanomaly);
3146 mDaltonizer.setMode(ColorBlindnessMode::Correction);
3148 mDaltonizer.setMode(ColorBlindnessMode::Simulation);
3151 invalidateHwcGeometry();
3152 repaintEverything();
3156 // apply a color matrix
3157 n = data.readInt32();
3158 mHasColorMatrix = n ? 1 : 0;
3160 // color matrix is sent as mat3 matrix followed by vec3
3161 // offset, then packed into a mat4 where the last row is
3162 // the offset and extra values are 0
3163 for (size_t i = 0 ; i < 4; i++) {
3164 for (size_t j = 0; j < 4; j++) {
3165 mColorMatrix[i][j] = data.readFloat();
3169 mColorMatrix = mat4();
3171 invalidateHwcGeometry();
3172 repaintEverything();
3175 // This is an experimental interface
3176 // Needs to be shifted to proper binder interface when we productize
3178 n = data.readInt32();
3179 mPrimaryDispSync.setRefreshSkipCount(n);
3183 n = data.readInt32();
3184 mForceFullDamage = static_cast<bool>(n);
3187 case 1018: { // Modify Choreographer's phase offset
3188 n = data.readInt32();
3189 mEventThread->setPhaseOffset(static_cast<nsecs_t>(n));
3192 case 1019: { // Modify SurfaceFlinger's phase offset
3193 n = data.readInt32();
3194 mSFEventThread->setPhaseOffset(static_cast<nsecs_t>(n));
3197 case 1021: { // Disable HWC virtual displays
3198 n = data.readInt32();
3199 mUseHwcVirtualDisplays = !n;
3207 void SurfaceFlinger::repaintEverything() {
3208 android_atomic_or(1, &mRepaintEverything);
3209 signalTransaction();
3212 // ---------------------------------------------------------------------------
3213 // Capture screen into an IGraphiBufferProducer
3214 // ---------------------------------------------------------------------------
3216 /* The code below is here to handle b/8734824
3218 * We create a IGraphicBufferProducer wrapper that forwards all calls
3219 * from the surfaceflinger thread to the calling binder thread, where they
3220 * are executed. This allows the calling thread in the calling process to be
3221 * reused and not depend on having "enough" binder threads to handle the
3224 class GraphicProducerWrapper : public BBinder, public MessageHandler {
3225 /* Parts of GraphicProducerWrapper are run on two different threads,
3226 * communicating by sending messages via Looper but also by shared member
3227 * data. Coherence maintenance is subtle and in places implicit (ugh).
3229 * Don't rely on Looper's sendMessage/handleMessage providing
3230 * release/acquire semantics for any data not actually in the Message.
3231 * Data going from surfaceflinger to binder threads needs to be
3232 * synchronized explicitly.
3234 * Barrier open/wait do provide release/acquire semantics. This provides
3235 * implicit synchronization for data coming back from binder to
3236 * surfaceflinger threads.
3239 sp<IGraphicBufferProducer> impl;
3255 * Called on surfaceflinger thread. This is called by our "fake"
3256 * BpGraphicBufferProducer. We package the data and reply Parcel and
3257 * forward them to the binder thread.
3259 virtual status_t transact(uint32_t code,
3260 const Parcel& data, Parcel* reply, uint32_t /* flags */) {
3263 this->reply = reply;
3265 // if we've exited, we run the message synchronously right here.
3266 // note (JH): as far as I can tell from looking at the code, this
3267 // never actually happens. if it does, i'm not sure if it happens
3268 // on the surfaceflinger or binder thread.
3269 handleMessage(Message(MSG_API_CALL));
3272 // Prevent stores to this->{code, data, reply} from being
3273 // reordered later than the construction of Message.
3274 atomic_thread_fence(memory_order_release);
3275 looper->sendMessage(this, Message(MSG_API_CALL));
3282 * here we run on the binder thread. All we've got to do is
3283 * call the real BpGraphicBufferProducer.
3285 virtual void handleMessage(const Message& message) {
3286 int what = message.what;
3287 // Prevent reads below from happening before the read from Message
3288 atomic_thread_fence(memory_order_acquire);
3289 if (what == MSG_API_CALL) {
3290 result = IInterface::asBinder(impl)->transact(code, data[0], reply);
3292 } else if (what == MSG_EXIT) {
3293 exitRequested = true;
3298 GraphicProducerWrapper(const sp<IGraphicBufferProducer>& impl)
3300 looper(new Looper(true)),
3303 exitRequested(false),
3310 status_t waitForResponse() {
3312 looper->pollOnce(-1);
3313 } while (!exitRequested);
3318 void exit(status_t result) {
3319 this->result = result;
3321 // Ensure this->result is visible to the binder thread before it
3322 // handles the message.
3323 atomic_thread_fence(memory_order_release);
3324 looper->sendMessage(this, Message(MSG_EXIT));
3329 status_t SurfaceFlinger::captureScreen(const sp<IBinder>& display,
3330 const sp<IGraphicBufferProducer>& producer,
3331 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
3332 uint32_t minLayerZ, uint32_t maxLayerZ,
3333 bool useIdentityTransform, ISurfaceComposer::Rotation rotation) {
3335 if (CC_UNLIKELY(display == 0))
3338 if (CC_UNLIKELY(producer == 0))
3341 // if we have secure windows on this display, never allow the screen capture
3342 // unless the producer interface is local (i.e.: we can take a screenshot for
3344 bool isLocalScreenshot = IInterface::asBinder(producer)->localBinder();
3346 // Convert to surfaceflinger's internal rotation type.
3347 Transform::orientation_flags rotationFlags;
3349 case ISurfaceComposer::eRotateNone:
3350 rotationFlags = Transform::ROT_0;
3352 case ISurfaceComposer::eRotate90:
3353 rotationFlags = Transform::ROT_90;
3355 case ISurfaceComposer::eRotate180:
3356 rotationFlags = Transform::ROT_180;
3358 case ISurfaceComposer::eRotate270:
3359 rotationFlags = Transform::ROT_270;
3362 rotationFlags = Transform::ROT_0;
3363 ALOGE("Invalid rotation passed to captureScreen(): %d\n", rotation);
3367 class MessageCaptureScreen : public MessageBase {
3368 SurfaceFlinger* flinger;
3369 sp<IBinder> display;
3370 sp<IGraphicBufferProducer> producer;
3372 uint32_t reqWidth, reqHeight;
3373 uint32_t minLayerZ,maxLayerZ;
3374 bool useIdentityTransform;
3375 Transform::orientation_flags rotation;
3377 bool isLocalScreenshot;
3379 MessageCaptureScreen(SurfaceFlinger* flinger,
3380 const sp<IBinder>& display,
3381 const sp<IGraphicBufferProducer>& producer,
3382 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
3383 uint32_t minLayerZ, uint32_t maxLayerZ,
3384 bool useIdentityTransform,
3385 Transform::orientation_flags rotation,
3386 bool isLocalScreenshot)
3387 : flinger(flinger), display(display), producer(producer),
3388 sourceCrop(sourceCrop), reqWidth(reqWidth), reqHeight(reqHeight),
3389 minLayerZ(minLayerZ), maxLayerZ(maxLayerZ),
3390 useIdentityTransform(useIdentityTransform),
3391 rotation(rotation), result(PERMISSION_DENIED),
3392 isLocalScreenshot(isLocalScreenshot)
3395 status_t getResult() const {
3398 virtual bool handler() {
3399 Mutex::Autolock _l(flinger->mStateLock);
3400 sp<const DisplayDevice> hw(flinger->getDisplayDevice(display));
3401 result = flinger->captureScreenImplLocked(hw, producer,
3402 sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ,
3403 useIdentityTransform, rotation, isLocalScreenshot);
3404 static_cast<GraphicProducerWrapper*>(IInterface::asBinder(producer).get())->exit(result);
3409 // this creates a "fake" BBinder which will serve as a "fake" remote
3410 // binder to receive the marshaled calls and forward them to the
3411 // real remote (a BpGraphicBufferProducer)
3412 sp<GraphicProducerWrapper> wrapper = new GraphicProducerWrapper(producer);
3414 // the asInterface() call below creates our "fake" BpGraphicBufferProducer
3415 // which does the marshaling work forwards to our "fake remote" above.
3416 sp<MessageBase> msg = new MessageCaptureScreen(this,
3417 display, IGraphicBufferProducer::asInterface( wrapper ),
3418 sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ,
3419 useIdentityTransform, rotationFlags, isLocalScreenshot);
3421 status_t res = postMessageAsync(msg);
3422 if (res == NO_ERROR) {
3423 res = wrapper->waitForResponse();
3429 void SurfaceFlinger::renderScreenImplLocked(
3430 const sp<const DisplayDevice>& hw,
3431 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
3432 uint32_t minLayerZ, uint32_t maxLayerZ,
3433 bool yswap, bool useIdentityTransform, Transform::orientation_flags rotation)
3436 RenderEngine& engine(getRenderEngine());
3438 // get screen geometry
3439 const int32_t hw_w = hw->getWidth();
3440 const int32_t hw_h = hw->getHeight();
3441 const bool filtering = static_cast<int32_t>(reqWidth) != hw_w ||
3442 static_cast<int32_t>(reqHeight) != hw_h;
3444 // if a default or invalid sourceCrop is passed in, set reasonable values
3445 if (sourceCrop.width() == 0 || sourceCrop.height() == 0 ||
3446 !sourceCrop.isValid()) {
3447 sourceCrop.setLeftTop(Point(0, 0));
3448 sourceCrop.setRightBottom(Point(hw_w, hw_h));
3451 // ensure that sourceCrop is inside screen
3452 if (sourceCrop.left < 0) {
3453 ALOGE("Invalid crop rect: l = %d (< 0)", sourceCrop.left);
3455 if (sourceCrop.right > hw_w) {
3456 ALOGE("Invalid crop rect: r = %d (> %d)", sourceCrop.right, hw_w);
3458 if (sourceCrop.top < 0) {
3459 ALOGE("Invalid crop rect: t = %d (< 0)", sourceCrop.top);
3461 if (sourceCrop.bottom > hw_h) {
3462 ALOGE("Invalid crop rect: b = %d (> %d)", sourceCrop.bottom, hw_h);
3465 // make sure to clear all GL error flags
3466 engine.checkErrors();
3468 // set-up our viewport
3469 engine.setViewportAndProjection(
3470 reqWidth, reqHeight, sourceCrop, hw_h, yswap, rotation);
3471 engine.disableTexturing();
3473 // redraw the screen entirely...
3474 engine.clearWithColor(0, 0, 0, 1);
3476 const LayerVector& layers( mDrawingState.layersSortedByZ );
3477 const size_t count = layers.size();
3478 for (size_t i=0 ; i<count ; ++i) {
3479 const sp<Layer>& layer(layers[i]);
3480 const Layer::State& state(layer->getDrawingState());
3481 if (state.layerStack == hw->getLayerStack()) {
3482 if (state.z >= minLayerZ && state.z <= maxLayerZ) {
3483 if (layer->isVisible()) {
3484 if (filtering) layer->setFiltering(true);
3485 layer->draw(hw, useIdentityTransform);
3486 if (filtering) layer->setFiltering(false);
3492 // compositionComplete is needed for older driver
3493 hw->compositionComplete();
3494 hw->setViewportAndProjection();
3498 status_t SurfaceFlinger::captureScreenImplLocked(
3499 const sp<const DisplayDevice>& hw,
3500 const sp<IGraphicBufferProducer>& producer,
3501 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
3502 uint32_t minLayerZ, uint32_t maxLayerZ,
3503 bool useIdentityTransform, Transform::orientation_flags rotation,
3504 bool isLocalScreenshot)
3508 // get screen geometry
3509 uint32_t hw_w = hw->getWidth();
3510 uint32_t hw_h = hw->getHeight();
3512 if (rotation & Transform::ROT_90) {
3513 std::swap(hw_w, hw_h);
3516 if ((reqWidth > hw_w) || (reqHeight > hw_h)) {
3517 ALOGE("size mismatch (%d, %d) > (%d, %d)",
3518 reqWidth, reqHeight, hw_w, hw_h);
3522 reqWidth = (!reqWidth) ? hw_w : reqWidth;
3523 reqHeight = (!reqHeight) ? hw_h : reqHeight;
3525 bool secureLayerIsVisible = false;
3526 const LayerVector& layers(mDrawingState.layersSortedByZ);
3527 const size_t count = layers.size();
3528 for (size_t i = 0 ; i < count ; ++i) {
3529 const sp<Layer>& layer(layers[i]);
3530 const Layer::State& state(layer->getDrawingState());
3531 if (state.layerStack == hw->getLayerStack() && state.z >= minLayerZ &&
3532 state.z <= maxLayerZ && layer->isVisible() &&
3533 layer->isSecure()) {
3534 secureLayerIsVisible = true;
3538 if (!isLocalScreenshot && secureLayerIsVisible) {
3539 ALOGW("FB is protected: PERMISSION_DENIED");
3540 return PERMISSION_DENIED;
3543 // create a surface (because we're a producer, and we need to
3544 // dequeue/queue a buffer)
3545 sp<Surface> sur = new Surface(producer, false);
3546 ANativeWindow* window = sur.get();
3548 status_t result = native_window_api_connect(window, NATIVE_WINDOW_API_EGL);
3549 if (result == NO_ERROR) {
3550 uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
3551 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
3554 err = native_window_set_buffers_dimensions(window, reqWidth, reqHeight);
3555 err |= native_window_set_scaling_mode(window, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
3556 err |= native_window_set_buffers_format(window, HAL_PIXEL_FORMAT_RGBA_8888);
3557 err |= native_window_set_usage(window, usage);
3559 if (err == NO_ERROR) {
3560 ANativeWindowBuffer* buffer;
3561 /* TODO: Once we have the sync framework everywhere this can use
3562 * server-side waits on the fence that dequeueBuffer returns.
3564 result = native_window_dequeue_buffer_and_wait(window, &buffer);
3565 if (result == NO_ERROR) {
3567 // create an EGLImage from the buffer so we can later
3568 // turn it into a texture
3569 EGLImageKHR image = eglCreateImageKHR(mEGLDisplay, EGL_NO_CONTEXT,
3570 EGL_NATIVE_BUFFER_ANDROID, buffer, NULL);
3571 if (image != EGL_NO_IMAGE_KHR) {
3572 // this binds the given EGLImage as a framebuffer for the
3573 // duration of this scope.
3574 RenderEngine::BindImageAsFramebuffer imageBond(getRenderEngine(), image);
3575 if (imageBond.getStatus() == NO_ERROR) {
3576 // this will in fact render into our dequeued buffer
3577 // via an FBO, which means we didn't have to create
3578 // an EGLSurface and therefore we're not
3579 // dependent on the context's EGLConfig.
3580 renderScreenImplLocked(
3581 hw, sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ, true,
3582 useIdentityTransform, rotation);
3584 // Attempt to create a sync khr object that can produce a sync point. If that
3585 // isn't available, create a non-dupable sync object in the fallback path and
3586 // wait on it directly.
3588 if (!DEBUG_SCREENSHOTS) {
3589 sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, NULL);
3590 // native fence fd will not be populated until flush() is done.
3591 getRenderEngine().flush();
3593 sync = EGL_NO_SYNC_KHR;
3595 if (sync != EGL_NO_SYNC_KHR) {
3597 syncFd = eglDupNativeFenceFDANDROID(mEGLDisplay, sync);
3598 if (syncFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
3599 ALOGW("captureScreen: failed to dup sync khr object");
3602 eglDestroySyncKHR(mEGLDisplay, sync);
3605 sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, NULL);
3606 if (sync != EGL_NO_SYNC_KHR) {
3607 EGLint result = eglClientWaitSyncKHR(mEGLDisplay, sync,
3608 EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, 2000000000 /*2 sec*/);
3609 EGLint eglErr = eglGetError();
3610 if (result == EGL_TIMEOUT_EXPIRED_KHR) {
3611 ALOGW("captureScreen: fence wait timed out");
3613 ALOGW_IF(eglErr != EGL_SUCCESS,
3614 "captureScreen: error waiting on EGL fence: %#x", eglErr);
3616 eglDestroySyncKHR(mEGLDisplay, sync);
3618 ALOGW("captureScreen: error creating EGL fence: %#x", eglGetError());
3621 if (DEBUG_SCREENSHOTS) {
3622 uint32_t* pixels = new uint32_t[reqWidth*reqHeight];
3623 getRenderEngine().readPixels(0, 0, reqWidth, reqHeight, pixels);
3624 checkScreenshot(reqWidth, reqHeight, reqWidth, pixels,
3625 hw, minLayerZ, maxLayerZ);
3630 ALOGE("got GL_FRAMEBUFFER_COMPLETE_OES error while taking screenshot");
3631 result = INVALID_OPERATION;
3632 window->cancelBuffer(window, buffer, syncFd);
3635 // destroy our image
3636 eglDestroyImageKHR(mEGLDisplay, image);
3641 // queueBuffer takes ownership of syncFd
3642 result = window->queueBuffer(window, buffer, syncFd);
3648 native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
3654 bool SurfaceFlinger::getFrameTimestamps(const Layer& layer,
3655 uint64_t frameNumber, FrameTimestamps* outTimestamps) {
3656 return mFenceTracker.getFrameTimestamps(layer, frameNumber, outTimestamps);
3659 void SurfaceFlinger::checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
3660 const sp<const DisplayDevice>& hw, uint32_t minLayerZ, uint32_t maxLayerZ) {
3661 if (DEBUG_SCREENSHOTS) {
3662 for (size_t y=0 ; y<h ; y++) {
3663 uint32_t const * p = (uint32_t const *)vaddr + y*s;
3664 for (size_t x=0 ; x<w ; x++) {
3665 if (p[x] != 0xFF000000) return;
3668 ALOGE("*** we just took a black screenshot ***\n"
3669 "requested minz=%d, maxz=%d, layerStack=%d",
3670 minLayerZ, maxLayerZ, hw->getLayerStack());
3671 const LayerVector& layers( mDrawingState.layersSortedByZ );
3672 const size_t count = layers.size();
3673 for (size_t i=0 ; i<count ; ++i) {
3674 const sp<Layer>& layer(layers[i]);
3675 const Layer::State& state(layer->getDrawingState());
3676 const bool visible = (state.layerStack == hw->getLayerStack())
3677 && (state.z >= minLayerZ && state.z <= maxLayerZ)
3678 && (layer->isVisible());
3679 ALOGE("%c index=%zu, name=%s, layerStack=%d, z=%d, visible=%d, flags=%x, alpha=%x",
3680 visible ? '+' : '-',
3681 i, layer->getName().string(), state.layerStack, state.z,
3682 layer->isVisible(), state.flags, state.alpha);
3687 // ---------------------------------------------------------------------------
3689 SurfaceFlinger::LayerVector::LayerVector() {
3692 SurfaceFlinger::LayerVector::LayerVector(const LayerVector& rhs)
3693 : SortedVector<sp<Layer> >(rhs) {
3696 int SurfaceFlinger::LayerVector::do_compare(const void* lhs,
3697 const void* rhs) const
3699 // sort layers per layer-stack, then by z-order and finally by sequence
3700 const sp<Layer>& l(*reinterpret_cast<const sp<Layer>*>(lhs));
3701 const sp<Layer>& r(*reinterpret_cast<const sp<Layer>*>(rhs));
3703 uint32_t ls = l->getCurrentState().layerStack;
3704 uint32_t rs = r->getCurrentState().layerStack;
3708 uint32_t lz = l->getCurrentState().z;
3709 uint32_t rz = r->getCurrentState().z;
3713 return l->sequence - r->sequence;
3716 // ---------------------------------------------------------------------------
3718 SurfaceFlinger::DisplayDeviceState::DisplayDeviceState()
3719 : type(DisplayDevice::DISPLAY_ID_INVALID),
3720 layerStack(DisplayDevice::NO_LAYER_STACK),
3727 SurfaceFlinger::DisplayDeviceState::DisplayDeviceState(
3728 DisplayDevice::DisplayType type, bool isSecure)
3730 layerStack(DisplayDevice::NO_LAYER_STACK),
3734 isSecure(isSecure) {
3735 viewport.makeInvalid();
3736 frame.makeInvalid();
3739 // ---------------------------------------------------------------------------
3741 }; // namespace android
3744 #if defined(__gl_h_)
3745 #error "don't include gl/gl.h in this file"
3748 #if defined(__gl2_h_)
3749 #error "don't include gl2/gl2.h in this file"