SurfaceFlinger.cpp revision a02e9484be6894f8a4db7049d432f534a4e0a676 
1/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define ATRACE_TAG ATRACE_TAG_GRAPHICS
18
19#include <stdint.h>
20#include <sys/types.h>
21#include <errno.h>
22#include <math.h>
23#include <dlfcn.h>
24#include <inttypes.h>
25#include <stdatomic.h>
26
27#include <EGL/egl.h>
28
29#include <cutils/log.h>
30#include <cutils/properties.h>
31
32#include <binder/IPCThreadState.h>
33#include <binder/IServiceManager.h>
34#include <binder/MemoryHeapBase.h>
35#include <binder/PermissionCache.h>
36
37#include <ui/DisplayInfo.h>
38
39#include <gui/BitTube.h>
40#include <gui/BufferQueue.h>
41#include <gui/GuiConfig.h>
42#include <gui/IDisplayEventConnection.h>
43#include <gui/Surface.h>
44#include <gui/GraphicBufferAlloc.h>
45
46#include <ui/GraphicBufferAllocator.h>
47#include <ui/PixelFormat.h>
48#include <ui/UiConfig.h>
49
50#include <utils/misc.h>
51#include <utils/String8.h>
52#include <utils/String16.h>
53#include <utils/StopWatch.h>
54#include <utils/Trace.h>
55
56#include <private/android_filesystem_config.h>
57#include <private/gui/SyncFeatures.h>
58
59#include "Client.h"
60#include "clz.h"
61#include "Colorizer.h"
62#include "DdmConnection.h"
63#include "DisplayDevice.h"
64#include "DispSync.h"
65#include "EventControlThread.h"
66#include "EventThread.h"
67#include "Layer.h"
68#include "LayerDim.h"
69#include "SurfaceFlinger.h"
70
71#include "DisplayHardware/FramebufferSurface.h"
72#include "DisplayHardware/HWComposer.h"
73#include "DisplayHardware/VirtualDisplaySurface.h"
74
75#include "Effects/Daltonizer.h"
76
77#include "RenderEngine/RenderEngine.h"
78#include <cutils/compiler.h>
79
80#define DISPLAY_COUNT       1
81
82/*
83 * DEBUG_SCREENSHOTS: set to true to check that screenshots are not all
84 * black pixels.
85 */
86#define DEBUG_SCREENSHOTS   false
87
88EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name);
89
90namespace android {
91
92// This is the phase offset in nanoseconds of the software vsync event
93// relative to the vsync event reported by HWComposer.  The software vsync
94// event is when SurfaceFlinger and Choreographer-based applications run each
95// frame.
96//
97// This phase offset allows adjustment of the minimum latency from application
98// wake-up (by Choregographer) time to the time at which the resulting window
99// image is displayed.  This value may be either positive (after the HW vsync)
100// or negative (before the HW vsync).  Setting it to 0 will result in a
101// minimum latency of two vsync periods because the app and SurfaceFlinger
102// will run just after the HW vsync.  Setting it to a positive number will
103// result in the minimum latency being:
104//
105//     (2 * VSYNC_PERIOD - (vsyncPhaseOffsetNs % VSYNC_PERIOD))
106//
107// Note that reducing this latency makes it more likely for the applications
108// to not have their window content image ready in time.  When this happens
109// the latency will end up being an additional vsync period, and animations
110// will hiccup.  Therefore, this latency should be tuned somewhat
111// conservatively (or at least with awareness of the trade-off being made).
112static const int64_t vsyncPhaseOffsetNs = VSYNC_EVENT_PHASE_OFFSET_NS;
113
114// This is the phase offset at which SurfaceFlinger's composition runs.
115static const int64_t sfVsyncPhaseOffsetNs = SF_VSYNC_EVENT_PHASE_OFFSET_NS;
116
117// ---------------------------------------------------------------------------
118
119const String16 sHardwareTest("android.permission.HARDWARE_TEST");
120const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER");
121const String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER");
122const String16 sDump("android.permission.DUMP");
123
124// ---------------------------------------------------------------------------
125
126SurfaceFlinger::SurfaceFlinger()
127    :   BnSurfaceComposer(),
128        mTransactionFlags(0),
129        mTransactionPending(false),
130        mAnimTransactionPending(false),
131        mLayersRemoved(false),
132        mRepaintEverything(0),
133        mRenderEngine(NULL),
134        mBootTime(systemTime()),
135        mVisibleRegionsDirty(false),
136        mHwWorkListDirty(false),
137        mAnimCompositionPending(false),
138        mDebugRegion(0),
139        mDebugDDMS(0),
140        mDebugDisableHWC(0),
141        mDebugDisableTransformHint(0),
142        mDebugInSwapBuffers(0),
143        mLastSwapBufferTime(0),
144        mDebugInTransaction(0),
145        mLastTransactionTime(0),
146        mBootFinished(false),
147        mPrimaryHWVsyncEnabled(false),
148        mHWVsyncAvailable(false),
149        mDaltonize(false),
150        mHasColorMatrix(false)
151{
152    ALOGI("SurfaceFlinger is starting");
153
154    // debugging stuff...
155    char value[PROPERTY_VALUE_MAX];
156
157    property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");
158    mGpuToCpuSupported = !atoi(value);
159
160    property_get("debug.sf.showupdates", value, "0");
161    mDebugRegion = atoi(value);
162
163    property_get("debug.sf.ddms", value, "0");
164    mDebugDDMS = atoi(value);
165    if (mDebugDDMS) {
166        if (!startDdmConnection()) {
167            // start failed, and DDMS debugging not enabled
168            mDebugDDMS = 0;
169        }
170    }
171    ALOGI_IF(mDebugRegion, "showupdates enabled");
172    ALOGI_IF(mDebugDDMS, "DDMS debugging enabled");
173}
174
175void SurfaceFlinger::onFirstRef()
176{
177    mEventQueue.init(this);
178}
179
180SurfaceFlinger::~SurfaceFlinger()
181{
182    EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
183    eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
184    eglTerminate(display);
185}
186
187void SurfaceFlinger::binderDied(const wp<IBinder>& /* who */)
188{
189    // the window manager died on us. prepare its eulogy.
190
191    // restore initial conditions (default device unblank, etc)
192    initializeDisplays();
193
194    // restart the boot-animation
195    startBootAnim();
196}
197
198sp<ISurfaceComposerClient> SurfaceFlinger::createConnection()
199{
200    sp<ISurfaceComposerClient> bclient;
201    sp<Client> client(new Client(this));
202    status_t err = client->initCheck();
203    if (err == NO_ERROR) {
204        bclient = client;
205    }
206    return bclient;
207}
208
209sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName,
210        bool secure)
211{
212    class DisplayToken : public BBinder {
213        sp<SurfaceFlinger> flinger;
214        virtual ~DisplayToken() {
215             // no more references, this display must be terminated
216             Mutex::Autolock _l(flinger->mStateLock);
217             flinger->mCurrentState.displays.removeItem(this);
218             flinger->setTransactionFlags(eDisplayTransactionNeeded);
219         }
220     public:
221        DisplayToken(const sp<SurfaceFlinger>& flinger)
222            : flinger(flinger) {
223        }
224    };
225
226    sp<BBinder> token = new DisplayToken(this);
227
228    Mutex::Autolock _l(mStateLock);
229    DisplayDeviceState info(DisplayDevice::DISPLAY_VIRTUAL);
230    info.displayName = displayName;
231    info.isSecure = secure;
232    mCurrentState.displays.add(token, info);
233
234    return token;
235}
236
237void SurfaceFlinger::destroyDisplay(const sp<IBinder>& display) {
238    Mutex::Autolock _l(mStateLock);
239
240    ssize_t idx = mCurrentState.displays.indexOfKey(display);
241    if (idx < 0) {
242        ALOGW("destroyDisplay: invalid display token");
243        return;
244    }
245
246    const DisplayDeviceState& info(mCurrentState.displays.valueAt(idx));
247    if (!info.isVirtualDisplay()) {
248        ALOGE("destroyDisplay called for non-virtual display");
249        return;
250    }
251
252    mCurrentState.displays.removeItemsAt(idx);
253    setTransactionFlags(eDisplayTransactionNeeded);
254}
255
256void SurfaceFlinger::createBuiltinDisplayLocked(DisplayDevice::DisplayType type) {
257    ALOGW_IF(mBuiltinDisplays[type],
258            "Overwriting display token for display type %d", type);
259    mBuiltinDisplays[type] = new BBinder();
260    DisplayDeviceState info(type);
261    // All non-virtual displays are currently considered secure.
262    info.isSecure = true;
263    mCurrentState.displays.add(mBuiltinDisplays[type], info);
264}
265
266sp<IBinder> SurfaceFlinger::getBuiltInDisplay(int32_t id) {
267    if (uint32_t(id) >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
268        ALOGE("getDefaultDisplay: id=%d is not a valid default display id", id);
269        return NULL;
270    }
271    return mBuiltinDisplays[id];
272}
273
274sp<IGraphicBufferAlloc> SurfaceFlinger::createGraphicBufferAlloc()
275{
276    sp<GraphicBufferAlloc> gba(new GraphicBufferAlloc());
277    return gba;
278}
279
280void SurfaceFlinger::bootFinished()
281{
282    const nsecs_t now = systemTime();
283    const nsecs_t duration = now - mBootTime;
284    ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
285    mBootFinished = true;
286
287    // wait patiently for the window manager death
288    const String16 name("window");
289    sp<IBinder> window(defaultServiceManager()->getService(name));
290    if (window != 0) {
291        window->linkToDeath(static_cast<IBinder::DeathRecipient*>(this));
292    }
293
294    // stop boot animation
295    // formerly we would just kill the process, but we now ask it to exit so it
296    // can choose where to stop the animation.
297    property_set("service.bootanim.exit", "1");
298}
299
300void SurfaceFlinger::deleteTextureAsync(uint32_t texture) {
301    class MessageDestroyGLTexture : public MessageBase {
302        RenderEngine& engine;
303        uint32_t texture;
304    public:
305        MessageDestroyGLTexture(RenderEngine& engine, uint32_t texture)
306            : engine(engine), texture(texture) {
307        }
308        virtual bool handler() {
309            engine.deleteTextures(1, &texture);
310            return true;
311        }
312    };
313    postMessageAsync(new MessageDestroyGLTexture(getRenderEngine(), texture));
314}
315
316class DispSyncSource : public VSyncSource, private DispSync::Callback {
317public:
318    DispSyncSource(DispSync* dispSync, nsecs_t phaseOffset, bool traceVsync,
319        const char* label) :
320            mValue(0),
321            mPhaseOffset(phaseOffset),
322            mTraceVsync(traceVsync),
323            mVsyncOnLabel(String8::format("VsyncOn-%s", label)),
324            mVsyncEventLabel(String8::format("VSYNC-%s", label)),
325            mDispSync(dispSync) {}
326
327    virtual ~DispSyncSource() {}
328
329    virtual void setVSyncEnabled(bool enable) {
330        // Do NOT lock the mutex here so as to avoid any mutex ordering issues
331        // with locking it in the onDispSyncEvent callback.
332        if (enable) {
333            status_t err = mDispSync->addEventListener(mPhaseOffset,
334                    static_cast<DispSync::Callback*>(this));
335            if (err != NO_ERROR) {
336                ALOGE("error registering vsync callback: %s (%d)",
337                        strerror(-err), err);
338            }
339            //ATRACE_INT(mVsyncOnLabel.string(), 1);
340        } else {
341            status_t err = mDispSync->removeEventListener(
342                    static_cast<DispSync::Callback*>(this));
343            if (err != NO_ERROR) {
344                ALOGE("error unregistering vsync callback: %s (%d)",
345                        strerror(-err), err);
346            }
347            //ATRACE_INT(mVsyncOnLabel.string(), 0);
348        }
349    }
350
351    virtual void setCallback(const sp<VSyncSource::Callback>& callback) {
352        Mutex::Autolock lock(mMutex);
353        mCallback = callback;
354    }
355
356private:
357    virtual void onDispSyncEvent(nsecs_t when) {
358        sp<VSyncSource::Callback> callback;
359        {
360            Mutex::Autolock lock(mMutex);
361            callback = mCallback;
362
363            if (mTraceVsync) {
364                mValue = (mValue + 1) % 2;
365                ATRACE_INT(mVsyncEventLabel.string(), mValue);
366            }
367        }
368
369        if (callback != NULL) {
370            callback->onVSyncEvent(when);
371        }
372    }
373
374    int mValue;
375
376    const nsecs_t mPhaseOffset;
377    const bool mTraceVsync;
378    const String8 mVsyncOnLabel;
379    const String8 mVsyncEventLabel;
380
381    DispSync* mDispSync;
382    sp<VSyncSource::Callback> mCallback;
383    Mutex mMutex;
384};
385
386void SurfaceFlinger::init() {
387    ALOGI(  "SurfaceFlinger's main thread ready to run. "
388            "Initializing graphics H/W...");
389
390    status_t err;
391    Mutex::Autolock _l(mStateLock);
392
393    // initialize EGL for the default display
394    mEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
395    eglInitialize(mEGLDisplay, NULL, NULL);
396
397    // Initialize the H/W composer object.  There may or may not be an
398    // actual hardware composer underneath.
399    mHwc = new HWComposer(this,
400            *static_cast<HWComposer::EventHandler *>(this));
401
402    // get a RenderEngine for the given display / config (can't fail)
403    mRenderEngine = RenderEngine::create(mEGLDisplay, mHwc->getVisualID());
404
405    // retrieve the EGL context that was selected/created
406    mEGLContext = mRenderEngine->getEGLContext();
407
408    LOG_ALWAYS_FATAL_IF(mEGLContext == EGL_NO_CONTEXT,
409            "couldn't create EGLContext");
410
411    // initialize our non-virtual displays
412    for (size_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {
413        DisplayDevice::DisplayType type((DisplayDevice::DisplayType)i);
414        // set-up the displays that are already connected
415        if (mHwc->isConnected(i) || type==DisplayDevice::DISPLAY_PRIMARY) {
416            // All non-virtual displays are currently considered secure.
417            bool isSecure = true;
418            createBuiltinDisplayLocked(type);
419            wp<IBinder> token = mBuiltinDisplays[i];
420
421            sp<IGraphicBufferProducer> producer;
422            sp<IGraphicBufferConsumer> consumer;
423            BufferQueue::createBufferQueue(&producer, &consumer,
424                    new GraphicBufferAlloc());
425
426            sp<FramebufferSurface> fbs = new FramebufferSurface(*mHwc, i,
427                    consumer);
428            int32_t hwcId = allocateHwcDisplayId(type);
429            sp<DisplayDevice> hw = new DisplayDevice(this,
430                    type, hwcId, mHwc->getFormat(hwcId), isSecure, token,
431                    fbs, producer,
432                    mRenderEngine->getEGLConfig());
433            if (i > DisplayDevice::DISPLAY_PRIMARY) {
434                // FIXME: currently we don't get blank/unblank requests
435                // for displays other than the main display, so we always
436                // assume a connected display is unblanked.
437                ALOGD("marking display %zu as acquired/unblanked", i);
438                hw->setPowerMode(HWC_POWER_MODE_NORMAL);
439            }
440            mDisplays.add(token, hw);
441        }
442    }
443
444    // make the GLContext current so that we can create textures when creating Layers
445    // (which may happens before we render something)
446    getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
447
448    // start the EventThread
449    sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,
450            vsyncPhaseOffsetNs, true, "app");
451    mEventThread = new EventThread(vsyncSrc);
452    sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,
453            sfVsyncPhaseOffsetNs, true, "sf");
454    mSFEventThread = new EventThread(sfVsyncSrc);
455    mEventQueue.setEventThread(mSFEventThread);
456
457    mEventControlThread = new EventControlThread(this);
458    mEventControlThread->run("EventControl", PRIORITY_URGENT_DISPLAY);
459
460    // set a fake vsync period if there is no HWComposer
461    if (mHwc->initCheck() != NO_ERROR) {
462        mPrimaryDispSync.setPeriod(16666667);
463    }
464
465    // initialize our drawing state
466    mDrawingState = mCurrentState;
467
468    // set initial conditions (e.g. unblank default device)
469    initializeDisplays();
470
471    // start boot animation
472    startBootAnim();
473}
474
475int32_t SurfaceFlinger::allocateHwcDisplayId(DisplayDevice::DisplayType type) {
476    return (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) ?
477            type : mHwc->allocateDisplayId();
478}
479
480void SurfaceFlinger::startBootAnim() {
481    // start boot animation
482    property_set("service.bootanim.exit", "0");
483    property_set("ctl.start", "bootanim");
484}
485
486size_t SurfaceFlinger::getMaxTextureSize() const {
487    return mRenderEngine->getMaxTextureSize();
488}
489
490size_t SurfaceFlinger::getMaxViewportDims() const {
491    return mRenderEngine->getMaxViewportDims();
492}
493
494// ----------------------------------------------------------------------------
495
496bool SurfaceFlinger::authenticateSurfaceTexture(
497        const sp<IGraphicBufferProducer>& bufferProducer) const {
498    Mutex::Autolock _l(mStateLock);
499    sp<IBinder> surfaceTextureBinder(bufferProducer->asBinder());
500    return mGraphicBufferProducerList.indexOf(surfaceTextureBinder) >= 0;
501}
502
503status_t SurfaceFlinger::getDisplayConfigs(const sp<IBinder>& display,
504        Vector<DisplayInfo>* configs) {
505    if (configs == NULL) {
506        return BAD_VALUE;
507    }
508
509    int32_t type = NAME_NOT_FOUND;
510    for (int i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {
511        if (display == mBuiltinDisplays[i]) {
512            type = i;
513            break;
514        }
515    }
516
517    if (type < 0) {
518        return type;
519    }
520
521    // TODO: Not sure if display density should handled by SF any longer
522    class Density {
523        static int getDensityFromProperty(char const* propName) {
524            char property[PROPERTY_VALUE_MAX];
525            int density = 0;
526            if (property_get(propName, property, NULL) > 0) {
527                density = atoi(property);
528            }
529            return density;
530        }
531    public:
532        static int getEmuDensity() {
533            return getDensityFromProperty("qemu.sf.lcd_density"); }
534        static int getBuildDensity()  {
535            return getDensityFromProperty("ro.sf.lcd_density"); }
536    };
537
538    configs->clear();
539
540    const Vector<HWComposer::DisplayConfig>& hwConfigs =
541            getHwComposer().getConfigs(type);
542    for (size_t c = 0; c < hwConfigs.size(); ++c) {
543        const HWComposer::DisplayConfig& hwConfig = hwConfigs[c];
544        DisplayInfo info = DisplayInfo();
545
546        float xdpi = hwConfig.xdpi;
547        float ydpi = hwConfig.ydpi;
548
549        if (type == DisplayDevice::DISPLAY_PRIMARY) {
550            // The density of the device is provided by a build property
551            float density = Density::getBuildDensity() / 160.0f;
552            if (density == 0) {
553                // the build doesn't provide a density -- this is wrong!
554                // use xdpi instead
555                ALOGE("ro.sf.lcd_density must be defined as a build property");
556                density = xdpi / 160.0f;
557            }
558            if (Density::getEmuDensity()) {
559                // if "qemu.sf.lcd_density" is specified, it overrides everything
560                xdpi = ydpi = density = Density::getEmuDensity();
561                density /= 160.0f;
562            }
563            info.density = density;
564
565            // TODO: this needs to go away (currently needed only by webkit)
566            sp<const DisplayDevice> hw(getDefaultDisplayDevice());
567            info.orientation = hw->getOrientation();
568        } else {
569            // TODO: where should this value come from?
570            static const int TV_DENSITY = 213;
571            info.density = TV_DENSITY / 160.0f;
572            info.orientation = 0;
573        }
574
575        info.w = hwConfig.width;
576        info.h = hwConfig.height;
577        info.xdpi = xdpi;
578        info.ydpi = ydpi;
579        info.fps = float(1e9 / hwConfig.refresh);
580        info.appVsyncOffset = VSYNC_EVENT_PHASE_OFFSET_NS;
581
582        // This is how far in advance a buffer must be queued for
583        // presentation at a given time.  If you want a buffer to appear
584        // on the screen at time N, you must submit the buffer before
585        // (N - presentationDeadline).
586        //
587        // Normally it's one full refresh period (to give SF a chance to
588        // latch the buffer), but this can be reduced by configuring a
589        // DispSync offset.  Any additional delays introduced by the hardware
590        // composer or panel must be accounted for here.
591        //
592        // We add an additional 1ms to allow for processing time and
593        // differences between the ideal and actual refresh rate.
594        info.presentationDeadline =
595                hwConfig.refresh - SF_VSYNC_EVENT_PHASE_OFFSET_NS + 1000000;
596
597        // All non-virtual displays are currently considered secure.
598        info.secure = true;
599
600        configs->push_back(info);
601    }
602
603    return NO_ERROR;
604}
605
606int SurfaceFlinger::getActiveConfig(const sp<IBinder>& display) {
607    return getDisplayDevice(display)->getActiveConfig();
608}
609
610void SurfaceFlinger::setActiveConfigInternal(const sp<DisplayDevice>& hw, int mode) {
611    ALOGD("Set active config mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(),
612          this);
613    int32_t type = hw->getDisplayType();
614    int currentMode = hw->getActiveConfig();
615
616    if (mode == currentMode) {
617        ALOGD("Screen type=%d is already mode=%d", hw->getDisplayType(), mode);
618        return;
619    }
620
621    if (type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
622        ALOGW("Trying to set config for virtual display");
623        return;
624    }
625
626    hw->setActiveConfig(mode);
627    getHwComposer().setActiveConfig(type, mode);
628}
629
630status_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& display, int mode) {
631    class MessageSetActiveConfig: public MessageBase {
632        SurfaceFlinger& mFlinger;
633        sp<IBinder> mDisplay;
634        int mMode;
635    public:
636        MessageSetActiveConfig(SurfaceFlinger& flinger, const sp<IBinder>& disp,
637                               int mode) :
638            mFlinger(flinger), mDisplay(disp) { mMode = mode; }
639        virtual bool handler() {
640            Vector<DisplayInfo> configs;
641            mFlinger.getDisplayConfigs(mDisplay, &configs);
642            if(mMode < 0 || mMode >= configs.size()) {
643                ALOGE("Attempt to set active config = %d for display with %zu configs",
644                        mMode, configs.size());
645            }
646            sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
647            if (hw == NULL) {
648                ALOGE("Attempt to set active config = %d for null display %p",
649                        mMode, mDisplay.get());
650            } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) {
651                ALOGW("Attempt to set active config = %d for virtual display",
652                        mMode);
653            } else {
654                mFlinger.setActiveConfigInternal(hw, mMode);
655            }
656            return true;
657        }
658    };
659    sp<MessageBase> msg = new MessageSetActiveConfig(*this, display, mode);
660    postMessageSync(msg);
661    return NO_ERROR;
662}
663
664status_t SurfaceFlinger::clearAnimationFrameStats() {
665    Mutex::Autolock _l(mStateLock);
666    mAnimFrameTracker.clearStats();
667    return NO_ERROR;
668}
669
670status_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const {
671    Mutex::Autolock _l(mStateLock);
672    mAnimFrameTracker.getStats(outStats);
673    return NO_ERROR;
674}
675
676// ----------------------------------------------------------------------------
677
678sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection() {
679    return mEventThread->createEventConnection();
680}
681
682// ----------------------------------------------------------------------------
683
684void SurfaceFlinger::waitForEvent() {
685    mEventQueue.waitMessage();
686}
687
688void SurfaceFlinger::signalTransaction() {
689    mEventQueue.invalidate();
690}
691
692void SurfaceFlinger::signalLayerUpdate() {
693    mEventQueue.invalidate();
694}
695
696void SurfaceFlinger::signalRefresh() {
697    mEventQueue.refresh();
698}
699
700status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,
701        nsecs_t reltime, uint32_t /* flags */) {
702    return mEventQueue.postMessage(msg, reltime);
703}
704
705status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
706        nsecs_t reltime, uint32_t /* flags */) {
707    status_t res = mEventQueue.postMessage(msg, reltime);
708    if (res == NO_ERROR) {
709        msg->wait();
710    }
711    return res;
712}
713
714void SurfaceFlinger::run() {
715    do {
716        waitForEvent();
717    } while (true);
718}
719
720void SurfaceFlinger::enableHardwareVsync() {
721    Mutex::Autolock _l(mHWVsyncLock);
722    if (!mPrimaryHWVsyncEnabled && mHWVsyncAvailable) {
723        mPrimaryDispSync.beginResync();
724        //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true);
725        mEventControlThread->setVsyncEnabled(true);
726        mPrimaryHWVsyncEnabled = true;
727    }
728}
729
730void SurfaceFlinger::resyncToHardwareVsync(bool makeAvailable) {
731    Mutex::Autolock _l(mHWVsyncLock);
732
733    if (makeAvailable) {
734        mHWVsyncAvailable = true;
735    } else if (!mHWVsyncAvailable) {
736        ALOGE("resyncToHardwareVsync called when HW vsync unavailable");
737        return;
738    }
739
740    const nsecs_t period =
741            getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
742
743    mPrimaryDispSync.reset();
744    mPrimaryDispSync.setPeriod(period);
745
746    if (!mPrimaryHWVsyncEnabled) {
747        mPrimaryDispSync.beginResync();
748        //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true);
749        mEventControlThread->setVsyncEnabled(true);
750        mPrimaryHWVsyncEnabled = true;
751    }
752}
753
754void SurfaceFlinger::disableHardwareVsync(bool makeUnavailable) {
755    Mutex::Autolock _l(mHWVsyncLock);
756    if (mPrimaryHWVsyncEnabled) {
757        //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, false);
758        mEventControlThread->setVsyncEnabled(false);
759        mPrimaryDispSync.endResync();
760        mPrimaryHWVsyncEnabled = false;
761    }
762    if (makeUnavailable) {
763        mHWVsyncAvailable = false;
764    }
765}
766
767void SurfaceFlinger::onVSyncReceived(int type, nsecs_t timestamp) {
768    bool needsHwVsync = false;
769
770    { // Scope for the lock
771        Mutex::Autolock _l(mHWVsyncLock);
772        if (type == 0 && mPrimaryHWVsyncEnabled) {
773            needsHwVsync = mPrimaryDispSync.addResyncSample(timestamp);
774        }
775    }
776
777    if (needsHwVsync) {
778        enableHardwareVsync();
779    } else {
780        disableHardwareVsync(false);
781    }
782}
783
784void SurfaceFlinger::onHotplugReceived(int type, bool connected) {
785    if (mEventThread == NULL) {
786        // This is a temporary workaround for b/7145521.  A non-null pointer
787        // does not mean EventThread has finished initializing, so this
788        // is not a correct fix.
789        ALOGW("WARNING: EventThread not started, ignoring hotplug");
790        return;
791    }
792
793    if (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
794        Mutex::Autolock _l(mStateLock);
795        if (connected) {
796            createBuiltinDisplayLocked((DisplayDevice::DisplayType)type);
797        } else {
798            mCurrentState.displays.removeItem(mBuiltinDisplays[type]);
799            mBuiltinDisplays[type].clear();
800        }
801        setTransactionFlags(eDisplayTransactionNeeded);
802
803        // Defer EventThread notification until SF has updated mDisplays.
804    }
805}
806
807void SurfaceFlinger::eventControl(int disp, int event, int enabled) {
808    ATRACE_CALL();
809    getHwComposer().eventControl(disp, event, enabled);
810}
811
812void SurfaceFlinger::onMessageReceived(int32_t what) {
813    ATRACE_CALL();
814    switch (what) {
815    case MessageQueue::TRANSACTION:
816        handleMessageTransaction();
817        break;
818    case MessageQueue::INVALIDATE:
819        handleMessageTransaction();
820        handleMessageInvalidate();
821        signalRefresh();
822        break;
823    case MessageQueue::REFRESH:
824        handleMessageRefresh();
825        break;
826    }
827}
828
829void SurfaceFlinger::handleMessageTransaction() {
830    uint32_t transactionFlags = peekTransactionFlags(eTransactionMask);
831    if (transactionFlags) {
832        handleTransaction(transactionFlags);
833    }
834}
835
836void SurfaceFlinger::handleMessageInvalidate() {
837    ATRACE_CALL();
838    handlePageFlip();
839}
840
841void SurfaceFlinger::handleMessageRefresh() {
842    ATRACE_CALL();
843    preComposition();
844    rebuildLayerStacks();
845    setUpHWComposer();
846    doDebugFlashRegions();
847    doComposition();
848    postComposition();
849}
850
851void SurfaceFlinger::doDebugFlashRegions()
852{
853    // is debugging enabled
854    if (CC_LIKELY(!mDebugRegion))
855        return;
856
857    const bool repaintEverything = mRepaintEverything;
858    for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
859        const sp<DisplayDevice>& hw(mDisplays[dpy]);
860        if (hw->isDisplayOn()) {
861            // transform the dirty region into this screen's coordinate space
862            const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
863            if (!dirtyRegion.isEmpty()) {
864                // redraw the whole screen
865                doComposeSurfaces(hw, Region(hw->bounds()));
866
867                // and draw the dirty region
868                const int32_t height = hw->getHeight();
869                RenderEngine& engine(getRenderEngine());
870                engine.fillRegionWithColor(dirtyRegion, height, 1, 0, 1, 1);
871
872                hw->compositionComplete();
873                hw->swapBuffers(getHwComposer());
874            }
875        }
876    }
877
878    postFramebuffer();
879
880    if (mDebugRegion > 1) {
881        usleep(mDebugRegion * 1000);
882    }
883
884    HWComposer& hwc(getHwComposer());
885    if (hwc.initCheck() == NO_ERROR) {
886        status_t err = hwc.prepare();
887        ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
888    }
889}
890
891void SurfaceFlinger::preComposition()
892{
893    bool needExtraInvalidate = false;
894    const LayerVector& layers(mDrawingState.layersSortedByZ);
895    const size_t count = layers.size();
896    for (size_t i=0 ; i<count ; i++) {
897        if (layers[i]->onPreComposition()) {
898            needExtraInvalidate = true;
899        }
900    }
901    if (needExtraInvalidate) {
902        signalLayerUpdate();
903    }
904}
905
906void SurfaceFlinger::postComposition()
907{
908    const LayerVector& layers(mDrawingState.layersSortedByZ);
909    const size_t count = layers.size();
910    for (size_t i=0 ; i<count ; i++) {
911        layers[i]->onPostComposition();
912    }
913
914    const HWComposer& hwc = getHwComposer();
915    sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY);
916
917    if (presentFence->isValid()) {
918        if (mPrimaryDispSync.addPresentFence(presentFence)) {
919            enableHardwareVsync();
920        } else {
921            disableHardwareVsync(false);
922        }
923    }
924
925    if (kIgnorePresentFences) {
926        const sp<const DisplayDevice> hw(getDefaultDisplayDevice());
927        if (hw->isDisplayOn()) {
928            enableHardwareVsync();
929        }
930    }
931
932    if (mAnimCompositionPending) {
933        mAnimCompositionPending = false;
934
935        if (presentFence->isValid()) {
936            mAnimFrameTracker.setActualPresentFence(presentFence);
937        } else {
938            // The HWC doesn't support present fences, so use the refresh
939            // timestamp instead.
940            nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY);
941            mAnimFrameTracker.setActualPresentTime(presentTime);
942        }
943        mAnimFrameTracker.advanceFrame();
944    }
945}
946
947void SurfaceFlinger::rebuildLayerStacks() {
948    // rebuild the visible layer list per screen
949    if (CC_UNLIKELY(mVisibleRegionsDirty)) {
950        ATRACE_CALL();
951        mVisibleRegionsDirty = false;
952        invalidateHwcGeometry();
953
954        const LayerVector& layers(mDrawingState.layersSortedByZ);
955        for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
956            Region opaqueRegion;
957            Region dirtyRegion;
958            Vector< sp<Layer> > layersSortedByZ;
959            const sp<DisplayDevice>& hw(mDisplays[dpy]);
960            const Transform& tr(hw->getTransform());
961            const Rect bounds(hw->getBounds());
962            if (hw->isDisplayOn()) {
963                SurfaceFlinger::computeVisibleRegions(layers,
964                        hw->getLayerStack(), dirtyRegion, opaqueRegion);
965
966                const size_t count = layers.size();
967                for (size_t i=0 ; i<count ; i++) {
968                    const sp<Layer>& layer(layers[i]);
969                    const Layer::State& s(layer->getDrawingState());
970                    if (s.layerStack == hw->getLayerStack()) {
971                        Region drawRegion(tr.transform(
972                                layer->visibleNonTransparentRegion));
973                        drawRegion.andSelf(bounds);
974                        if (!drawRegion.isEmpty()) {
975                            layersSortedByZ.add(layer);
976                        }
977                    }
978                }
979            }
980            hw->setVisibleLayersSortedByZ(layersSortedByZ);
981            hw->undefinedRegion.set(bounds);
982            hw->undefinedRegion.subtractSelf(tr.transform(opaqueRegion));
983            hw->dirtyRegion.orSelf(dirtyRegion);
984        }
985    }
986}
987
988void SurfaceFlinger::setUpHWComposer() {
989    for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
990        bool mustRecompose =
991                !(mDisplays[dpy]->getDirtyRegion(false).isEmpty());
992        mDisplays[dpy]->beginFrame(mustRecompose);
993    }
994
995    HWComposer& hwc(getHwComposer());
996    if (hwc.initCheck() == NO_ERROR) {
997        // build the h/w work list
998        if (CC_UNLIKELY(mHwWorkListDirty)) {
999            mHwWorkListDirty = false;
1000            for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1001                sp<const DisplayDevice> hw(mDisplays[dpy]);
1002                const int32_t id = hw->getHwcDisplayId();
1003                if (id >= 0) {
1004                    const Vector< sp<Layer> >& currentLayers(
1005                        hw->getVisibleLayersSortedByZ());
1006                    const size_t count = currentLayers.size();
1007                    if (hwc.createWorkList(id, count) == NO_ERROR) {
1008                        HWComposer::LayerListIterator cur = hwc.begin(id);
1009                        const HWComposer::LayerListIterator end = hwc.end(id);
1010                        for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1011                            const sp<Layer>& layer(currentLayers[i]);
1012                            layer->setGeometry(hw, *cur);
1013                            if (mDebugDisableHWC || mDebugRegion || mDaltonize || mHasColorMatrix) {
1014                                cur->setSkip(true);
1015                            }
1016                        }
1017                    }
1018                }
1019            }
1020        }
1021
1022        // set the per-frame data
1023        for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1024            sp<const DisplayDevice> hw(mDisplays[dpy]);
1025            const int32_t id = hw->getHwcDisplayId();
1026            if (id >= 0) {
1027                const Vector< sp<Layer> >& currentLayers(
1028                    hw->getVisibleLayersSortedByZ());
1029                const size_t count = currentLayers.size();
1030                HWComposer::LayerListIterator cur = hwc.begin(id);
1031                const HWComposer::LayerListIterator end = hwc.end(id);
1032                for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1033                    /*
1034                     * update the per-frame h/w composer data for each layer
1035                     * and build the transparent region of the FB
1036                     */
1037                    const sp<Layer>& layer(currentLayers[i]);
1038                    layer->setPerFrameData(hw, *cur);
1039                }
1040            }
1041        }
1042
1043        // If possible, attempt to use the cursor overlay on each display.
1044        for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1045            sp<const DisplayDevice> hw(mDisplays[dpy]);
1046            const int32_t id = hw->getHwcDisplayId();
1047            if (id >= 0) {
1048                const Vector< sp<Layer> >& currentLayers(
1049                    hw->getVisibleLayersSortedByZ());
1050                const size_t count = currentLayers.size();
1051                HWComposer::LayerListIterator cur = hwc.begin(id);
1052                const HWComposer::LayerListIterator end = hwc.end(id);
1053                for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1054                    const sp<Layer>& layer(currentLayers[i]);
1055                    if (layer->isPotentialCursor()) {
1056                        cur->setIsCursorLayerHint();
1057                        break;
1058                    }
1059                }
1060            }
1061        }
1062
1063        status_t err = hwc.prepare();
1064        ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
1065
1066        for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1067            sp<const DisplayDevice> hw(mDisplays[dpy]);
1068            hw->prepareFrame(hwc);
1069        }
1070    }
1071}
1072
1073void SurfaceFlinger::doComposition() {
1074    ATRACE_CALL();
1075    const bool repaintEverything = android_atomic_and(0, &mRepaintEverything);
1076    for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1077        const sp<DisplayDevice>& hw(mDisplays[dpy]);
1078        if (hw->isDisplayOn()) {
1079            // transform the dirty region into this screen's coordinate space
1080            const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
1081
1082            // repaint the framebuffer (if needed)
1083            doDisplayComposition(hw, dirtyRegion);
1084
1085            hw->dirtyRegion.clear();
1086            hw->flip(hw->swapRegion);
1087            hw->swapRegion.clear();
1088        }
1089        // inform the h/w that we're done compositing
1090        hw->compositionComplete();
1091    }
1092    postFramebuffer();
1093}
1094
1095void SurfaceFlinger::postFramebuffer()
1096{
1097    ATRACE_CALL();
1098
1099    const nsecs_t now = systemTime();
1100    mDebugInSwapBuffers = now;
1101
1102    HWComposer& hwc(getHwComposer());
1103    if (hwc.initCheck() == NO_ERROR) {
1104        if (!hwc.supportsFramebufferTarget()) {
1105            // EGL spec says:
1106            //   "surface must be bound to the calling thread's current context,
1107            //    for the current rendering API."
1108            getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
1109        }
1110        hwc.commit();
1111    }
1112
1113    // make the default display current because the VirtualDisplayDevice code cannot
1114    // deal with dequeueBuffer() being called outside of the composition loop; however
1115    // the code below can call glFlush() which is allowed (and does in some case) call
1116    // dequeueBuffer().
1117    getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
1118
1119    for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1120        sp<const DisplayDevice> hw(mDisplays[dpy]);
1121        const Vector< sp<Layer> >& currentLayers(hw->getVisibleLayersSortedByZ());
1122        hw->onSwapBuffersCompleted(hwc);
1123        const size_t count = currentLayers.size();
1124        int32_t id = hw->getHwcDisplayId();
1125        if (id >=0 && hwc.initCheck() == NO_ERROR) {
1126            HWComposer::LayerListIterator cur = hwc.begin(id);
1127            const HWComposer::LayerListIterator end = hwc.end(id);
1128            for (size_t i = 0; cur != end && i < count; ++i, ++cur) {
1129                currentLayers[i]->onLayerDisplayed(hw, &*cur);
1130            }
1131        } else {
1132            for (size_t i = 0; i < count; i++) {
1133                currentLayers[i]->onLayerDisplayed(hw, NULL);
1134            }
1135        }
1136    }
1137
1138    mLastSwapBufferTime = systemTime() - now;
1139    mDebugInSwapBuffers = 0;
1140
1141    uint32_t flipCount = getDefaultDisplayDevice()->getPageFlipCount();
1142    if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
1143        logFrameStats();
1144    }
1145}
1146
1147void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
1148{
1149    ATRACE_CALL();
1150
1151    // here we keep a copy of the drawing state (that is the state that's
1152    // going to be overwritten by handleTransactionLocked()) outside of
1153    // mStateLock so that the side-effects of the State assignment
1154    // don't happen with mStateLock held (which can cause deadlocks).
1155    State drawingState(mDrawingState);
1156
1157    Mutex::Autolock _l(mStateLock);
1158    const nsecs_t now = systemTime();
1159    mDebugInTransaction = now;
1160
1161    // Here we're guaranteed that some transaction flags are set
1162    // so we can call handleTransactionLocked() unconditionally.
1163    // We call getTransactionFlags(), which will also clear the flags,
1164    // with mStateLock held to guarantee that mCurrentState won't change
1165    // until the transaction is committed.
1166
1167    transactionFlags = getTransactionFlags(eTransactionMask);
1168    handleTransactionLocked(transactionFlags);
1169
1170    mLastTransactionTime = systemTime() - now;
1171    mDebugInTransaction = 0;
1172    invalidateHwcGeometry();
1173    // here the transaction has been committed
1174}
1175
1176void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
1177{
1178    const LayerVector& currentLayers(mCurrentState.layersSortedByZ);
1179    const size_t count = currentLayers.size();
1180
1181    /*
1182     * Traversal of the children
1183     * (perform the transaction for each of them if needed)
1184     */
1185
1186    if (transactionFlags & eTraversalNeeded) {
1187        for (size_t i=0 ; i<count ; i++) {
1188            const sp<Layer>& layer(currentLayers[i]);
1189            uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
1190            if (!trFlags) continue;
1191
1192            const uint32_t flags = layer->doTransaction(0);
1193            if (flags & Layer::eVisibleRegion)
1194                mVisibleRegionsDirty = true;
1195        }
1196    }
1197
1198    /*
1199     * Perform display own transactions if needed
1200     */
1201
1202    if (transactionFlags & eDisplayTransactionNeeded) {
1203        // here we take advantage of Vector's copy-on-write semantics to
1204        // improve performance by skipping the transaction entirely when
1205        // know that the lists are identical
1206        const KeyedVector<  wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
1207        const KeyedVector<  wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
1208        if (!curr.isIdenticalTo(draw)) {
1209            mVisibleRegionsDirty = true;
1210            const size_t cc = curr.size();
1211                  size_t dc = draw.size();
1212
1213            // find the displays that were removed
1214            // (ie: in drawing state but not in current state)
1215            // also handle displays that changed
1216            // (ie: displays that are in both lists)
1217            for (size_t i=0 ; i<dc ; i++) {
1218                const ssize_t j = curr.indexOfKey(draw.keyAt(i));
1219                if (j < 0) {
1220                    // in drawing state but not in current state
1221                    if (!draw[i].isMainDisplay()) {
1222                        // Call makeCurrent() on the primary display so we can
1223                        // be sure that nothing associated with this display
1224                        // is current.
1225                        const sp<const DisplayDevice> defaultDisplay(getDefaultDisplayDevice());
1226                        defaultDisplay->makeCurrent(mEGLDisplay, mEGLContext);
1227                        sp<DisplayDevice> hw(getDisplayDevice(draw.keyAt(i)));
1228                        if (hw != NULL)
1229                            hw->disconnect(getHwComposer());
1230                        if (draw[i].type < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES)
1231                            mEventThread->onHotplugReceived(draw[i].type, false);
1232                        mDisplays.removeItem(draw.keyAt(i));
1233                    } else {
1234                        ALOGW("trying to remove the main display");
1235                    }
1236                } else {
1237                    // this display is in both lists. see if something changed.
1238                    const DisplayDeviceState& state(curr[j]);
1239                    const wp<IBinder>& display(curr.keyAt(j));
1240                    if (state.surface->asBinder() != draw[i].surface->asBinder()) {
1241                        // changing the surface is like destroying and
1242                        // recreating the DisplayDevice, so we just remove it
1243                        // from the drawing state, so that it get re-added
1244                        // below.
1245                        sp<DisplayDevice> hw(getDisplayDevice(display));
1246                        if (hw != NULL)
1247                            hw->disconnect(getHwComposer());
1248                        mDisplays.removeItem(display);
1249                        mDrawingState.displays.removeItemsAt(i);
1250                        dc--; i--;
1251                        // at this point we must loop to the next item
1252                        continue;
1253                    }
1254
1255                    const sp<DisplayDevice> disp(getDisplayDevice(display));
1256                    if (disp != NULL) {
1257                        if (state.layerStack != draw[i].layerStack) {
1258                            disp->setLayerStack(state.layerStack);
1259                        }
1260                        if ((state.orientation != draw[i].orientation)
1261                                || (state.viewport != draw[i].viewport)
1262                                || (state.frame != draw[i].frame))
1263                        {
1264                            disp->setProjection(state.orientation,
1265                                    state.viewport, state.frame);
1266                        }
1267                        if (state.width != draw[i].width || state.height != draw[i].height) {
1268                            disp->setDisplaySize(state.width, state.height);
1269                        }
1270                    }
1271                }
1272            }
1273
1274            // find displays that were added
1275            // (ie: in current state but not in drawing state)
1276            for (size_t i=0 ; i<cc ; i++) {
1277                if (draw.indexOfKey(curr.keyAt(i)) < 0) {
1278                    const DisplayDeviceState& state(curr[i]);
1279
1280                    sp<DisplaySurface> dispSurface;
1281                    sp<IGraphicBufferProducer> producer;
1282                    sp<IGraphicBufferProducer> bqProducer;
1283                    sp<IGraphicBufferConsumer> bqConsumer;
1284                    BufferQueue::createBufferQueue(&bqProducer, &bqConsumer,
1285                            new GraphicBufferAlloc());
1286
1287                    int32_t hwcDisplayId = -1;
1288                    if (state.isVirtualDisplay()) {
1289                        // Virtual displays without a surface are dormant:
1290                        // they have external state (layer stack, projection,
1291                        // etc.) but no internal state (i.e. a DisplayDevice).
1292                        if (state.surface != NULL) {
1293
1294                            hwcDisplayId = allocateHwcDisplayId(state.type);
1295                            sp<VirtualDisplaySurface> vds = new VirtualDisplaySurface(
1296                                    *mHwc, hwcDisplayId, state.surface,
1297                                    bqProducer, bqConsumer, state.displayName);
1298
1299                            dispSurface = vds;
1300                            producer = vds;
1301                        }
1302                    } else {
1303                        ALOGE_IF(state.surface!=NULL,
1304                                "adding a supported display, but rendering "
1305                                "surface is provided (%p), ignoring it",
1306                                state.surface.get());
1307                        hwcDisplayId = allocateHwcDisplayId(state.type);
1308                        // for supported (by hwc) displays we provide our
1309                        // own rendering surface
1310                        dispSurface = new FramebufferSurface(*mHwc, state.type,
1311                                bqConsumer);
1312                        producer = bqProducer;
1313                    }
1314
1315                    const wp<IBinder>& display(curr.keyAt(i));
1316                    if (dispSurface != NULL) {
1317                        sp<DisplayDevice> hw = new DisplayDevice(this,
1318                                state.type, hwcDisplayId,
1319                                mHwc->getFormat(hwcDisplayId), state.isSecure,
1320                                display, dispSurface, producer,
1321                                mRenderEngine->getEGLConfig());
1322                        hw->setLayerStack(state.layerStack);
1323                        hw->setProjection(state.orientation,
1324                                state.viewport, state.frame);
1325                        hw->setDisplayName(state.displayName);
1326                        mDisplays.add(display, hw);
1327                        if (state.isVirtualDisplay()) {
1328                            if (hwcDisplayId >= 0) {
1329                                mHwc->setVirtualDisplayProperties(hwcDisplayId,
1330                                        hw->getWidth(), hw->getHeight(),
1331                                        hw->getFormat());
1332                            }
1333                        } else {
1334                            mEventThread->onHotplugReceived(state.type, true);
1335                        }
1336                    }
1337                }
1338            }
1339        }
1340    }
1341
1342    if (transactionFlags & (eTraversalNeeded|eDisplayTransactionNeeded)) {
1343        // The transform hint might have changed for some layers
1344        // (either because a display has changed, or because a layer
1345        // as changed).
1346        //
1347        // Walk through all the layers in currentLayers,
1348        // and update their transform hint.
1349        //
1350        // If a layer is visible only on a single display, then that
1351        // display is used to calculate the hint, otherwise we use the
1352        // default display.
1353        //
1354        // NOTE: we do this here, rather than in rebuildLayerStacks() so that
1355        // the hint is set before we acquire a buffer from the surface texture.
1356        //
1357        // NOTE: layer transactions have taken place already, so we use their
1358        // drawing state. However, SurfaceFlinger's own transaction has not
1359        // happened yet, so we must use the current state layer list
1360        // (soon to become the drawing state list).
1361        //
1362        sp<const DisplayDevice> disp;
1363        uint32_t currentlayerStack = 0;
1364        for (size_t i=0; i<count; i++) {
1365            // NOTE: we rely on the fact that layers are sorted by
1366            // layerStack first (so we don't have to traverse the list
1367            // of displays for every layer).
1368            const sp<Layer>& layer(currentLayers[i]);
1369            uint32_t layerStack = layer->getDrawingState().layerStack;
1370            if (i==0 || currentlayerStack != layerStack) {
1371                currentlayerStack = layerStack;
1372                // figure out if this layerstack is mirrored
1373                // (more than one display) if so, pick the default display,
1374                // if not, pick the only display it's on.
1375                disp.clear();
1376                for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1377                    sp<const DisplayDevice> hw(mDisplays[dpy]);
1378                    if (hw->getLayerStack() == currentlayerStack) {
1379                        if (disp == NULL) {
1380                            disp = hw;
1381                        } else {
1382                            disp = NULL;
1383                            break;
1384                        }
1385                    }
1386                }
1387            }
1388            if (disp == NULL) {
1389                // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
1390                // redraw after transform hint changes. See bug 8508397.
1391
1392                // could be null when this layer is using a layerStack
1393                // that is not visible on any display. Also can occur at
1394                // screen off/on times.
1395                disp = getDefaultDisplayDevice();
1396            }
1397            layer->updateTransformHint(disp);
1398        }
1399    }
1400
1401
1402    /*
1403     * Perform our own transaction if needed
1404     */
1405
1406    const LayerVector& layers(mDrawingState.layersSortedByZ);
1407    if (currentLayers.size() > layers.size()) {
1408        // layers have been added
1409        mVisibleRegionsDirty = true;
1410    }
1411
1412    // some layers might have been removed, so
1413    // we need to update the regions they're exposing.
1414    if (mLayersRemoved) {
1415        mLayersRemoved = false;
1416        mVisibleRegionsDirty = true;
1417        const size_t count = layers.size();
1418        for (size_t i=0 ; i<count ; i++) {
1419            const sp<Layer>& layer(layers[i]);
1420            if (currentLayers.indexOf(layer) < 0) {
1421                // this layer is not visible anymore
1422                // TODO: we could traverse the tree from front to back and
1423                //       compute the actual visible region
1424                // TODO: we could cache the transformed region
1425                const Layer::State& s(layer->getDrawingState());
1426                Region visibleReg = s.transform.transform(
1427                        Region(Rect(s.active.w, s.active.h)));
1428                invalidateLayerStack(s.layerStack, visibleReg);
1429            }
1430        }
1431    }
1432
1433    commitTransaction();
1434
1435    updateCursorAsync();
1436}
1437
1438void SurfaceFlinger::updateCursorAsync()
1439{
1440    HWComposer& hwc(getHwComposer());
1441    for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1442        sp<const DisplayDevice> hw(mDisplays[dpy]);
1443        const int32_t id = hw->getHwcDisplayId();
1444        if (id < 0) {
1445            continue;
1446        }
1447        const Vector< sp<Layer> >& currentLayers(
1448            hw->getVisibleLayersSortedByZ());
1449        const size_t count = currentLayers.size();
1450        HWComposer::LayerListIterator cur = hwc.begin(id);
1451        const HWComposer::LayerListIterator end = hwc.end(id);
1452        for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1453            if (cur->getCompositionType() != HWC_CURSOR_OVERLAY) {
1454                continue;
1455            }
1456            const sp<Layer>& layer(currentLayers[i]);
1457            Rect cursorPos = layer->getPosition(hw);
1458            hwc.setCursorPositionAsync(id, cursorPos);
1459            break;
1460        }
1461    }
1462}
1463
1464void SurfaceFlinger::commitTransaction()
1465{
1466    if (!mLayersPendingRemoval.isEmpty()) {
1467        // Notify removed layers now that they can't be drawn from
1468        for (size_t i = 0; i < mLayersPendingRemoval.size(); i++) {
1469            mLayersPendingRemoval[i]->onRemoved();
1470        }
1471        mLayersPendingRemoval.clear();
1472    }
1473
1474    // If this transaction is part of a window animation then the next frame
1475    // we composite should be considered an animation as well.
1476    mAnimCompositionPending = mAnimTransactionPending;
1477
1478    mDrawingState = mCurrentState;
1479    mTransactionPending = false;
1480    mAnimTransactionPending = false;
1481    mTransactionCV.broadcast();
1482}
1483
1484void SurfaceFlinger::computeVisibleRegions(
1485        const LayerVector& currentLayers, uint32_t layerStack,
1486        Region& outDirtyRegion, Region& outOpaqueRegion)
1487{
1488    ATRACE_CALL();
1489
1490    Region aboveOpaqueLayers;
1491    Region aboveCoveredLayers;
1492    Region dirty;
1493
1494    outDirtyRegion.clear();
1495
1496    size_t i = currentLayers.size();
1497    while (i--) {
1498        const sp<Layer>& layer = currentLayers[i];
1499
1500        // start with the whole surface at its current location
1501        const Layer::State& s(layer->getDrawingState());
1502
1503        // only consider the layers on the given layer stack
1504        if (s.layerStack != layerStack)
1505            continue;
1506
1507        /*
1508         * opaqueRegion: area of a surface that is fully opaque.
1509         */
1510        Region opaqueRegion;
1511
1512        /*
1513         * visibleRegion: area of a surface that is visible on screen
1514         * and not fully transparent. This is essentially the layer's
1515         * footprint minus the opaque regions above it.
1516         * Areas covered by a translucent surface are considered visible.
1517         */
1518        Region visibleRegion;
1519
1520        /*
1521         * coveredRegion: area of a surface that is covered by all
1522         * visible regions above it (which includes the translucent areas).
1523         */
1524        Region coveredRegion;
1525
1526        /*
1527         * transparentRegion: area of a surface that is hinted to be completely
1528         * transparent. This is only used to tell when the layer has no visible
1529         * non-transparent regions and can be removed from the layer list. It
1530         * does not affect the visibleRegion of this layer or any layers
1531         * beneath it. The hint may not be correct if apps don't respect the
1532         * SurfaceView restrictions (which, sadly, some don't).
1533         */
1534        Region transparentRegion;
1535
1536
1537        // handle hidden surfaces by setting the visible region to empty
1538        if (CC_LIKELY(layer->isVisible())) {
1539            const bool translucent = !layer->isOpaque(s);
1540            Rect bounds(s.transform.transform(layer->computeBounds()));
1541            visibleRegion.set(bounds);
1542            if (!visibleRegion.isEmpty()) {
1543                // Remove the transparent area from the visible region
1544                if (translucent) {
1545                    const Transform tr(s.transform);
1546                    if (tr.transformed()) {
1547                        if (tr.preserveRects()) {
1548                            // transform the transparent region
1549                            transparentRegion = tr.transform(s.activeTransparentRegion);
1550                        } else {
1551                            // transformation too complex, can't do the
1552                            // transparent region optimization.
1553                            transparentRegion.clear();
1554                        }
1555                    } else {
1556                        transparentRegion = s.activeTransparentRegion;
1557                    }
1558                }
1559
1560                // compute the opaque region
1561                const int32_t layerOrientation = s.transform.getOrientation();
1562                if (s.alpha==255 && !translucent &&
1563                        ((layerOrientation & Transform::ROT_INVALID) == false)) {
1564                    // the opaque region is the layer's footprint
1565                    opaqueRegion = visibleRegion;
1566                }
1567            }
1568        }
1569
1570        // Clip the covered region to the visible region
1571        coveredRegion = aboveCoveredLayers.intersect(visibleRegion);
1572
1573        // Update aboveCoveredLayers for next (lower) layer
1574        aboveCoveredLayers.orSelf(visibleRegion);
1575
1576        // subtract the opaque region covered by the layers above us
1577        visibleRegion.subtractSelf(aboveOpaqueLayers);
1578
1579        // compute this layer's dirty region
1580        if (layer->contentDirty) {
1581            // we need to invalidate the whole region
1582            dirty = visibleRegion;
1583            // as well, as the old visible region
1584            dirty.orSelf(layer->visibleRegion);
1585            layer->contentDirty = false;
1586        } else {
1587            /* compute the exposed region:
1588             *   the exposed region consists of two components:
1589             *   1) what's VISIBLE now and was COVERED before
1590             *   2) what's EXPOSED now less what was EXPOSED before
1591             *
1592             * note that (1) is conservative, we start with the whole
1593             * visible region but only keep what used to be covered by
1594             * something -- which mean it may have been exposed.
1595             *
1596             * (2) handles areas that were not covered by anything but got
1597             * exposed because of a resize.
1598             */
1599            const Region newExposed = visibleRegion - coveredRegion;
1600            const Region oldVisibleRegion = layer->visibleRegion;
1601            const Region oldCoveredRegion = layer->coveredRegion;
1602            const Region oldExposed = oldVisibleRegion - oldCoveredRegion;
1603            dirty = (visibleRegion&oldCoveredRegion) | (newExposed-oldExposed);
1604        }
1605        dirty.subtractSelf(aboveOpaqueLayers);
1606
1607        // accumulate to the screen dirty region
1608        outDirtyRegion.orSelf(dirty);
1609
1610        // Update aboveOpaqueLayers for next (lower) layer
1611        aboveOpaqueLayers.orSelf(opaqueRegion);
1612
1613        // Store the visible region in screen space
1614        layer->setVisibleRegion(visibleRegion);
1615        layer->setCoveredRegion(coveredRegion);
1616        layer->setVisibleNonTransparentRegion(
1617                visibleRegion.subtract(transparentRegion));
1618    }
1619
1620    outOpaqueRegion = aboveOpaqueLayers;
1621}
1622
1623void SurfaceFlinger::invalidateLayerStack(uint32_t layerStack,
1624        const Region& dirty) {
1625    for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1626        const sp<DisplayDevice>& hw(mDisplays[dpy]);
1627        if (hw->getLayerStack() == layerStack) {
1628            hw->dirtyRegion.orSelf(dirty);
1629        }
1630    }
1631}
1632
1633void SurfaceFlinger::handlePageFlip()
1634{
1635    Region dirtyRegion;
1636
1637    bool visibleRegions = false;
1638    const LayerVector& layers(mDrawingState.layersSortedByZ);
1639
1640    // Store the set of layers that need updates. This set must not change as
1641    // buffers are being latched, as this could result in a deadlock.
1642    // Example: Two producers share the same command stream and:
1643    // 1.) Layer 0 is latched
1644    // 2.) Layer 0 gets a new frame
1645    // 2.) Layer 1 gets a new frame
1646    // 3.) Layer 1 is latched.
1647    // Display is now waiting on Layer 1's frame, which is behind layer 0's
1648    // second frame. But layer 0's second frame could be waiting on display.
1649    Vector<Layer*> layersWithQueuedFrames;
1650    for (size_t i = 0, count = layers.size(); i<count ; i++) {
1651        const sp<Layer>& layer(layers[i]);
1652        if (layer->hasQueuedFrame())
1653            layersWithQueuedFrames.push_back(layer.get());
1654    }
1655    for (size_t i = 0, count = layersWithQueuedFrames.size() ; i<count ; i++) {
1656        Layer* layer = layersWithQueuedFrames[i];
1657        const Region dirty(layer->latchBuffer(visibleRegions));
1658        const Layer::State& s(layer->getDrawingState());
1659        invalidateLayerStack(s.layerStack, dirty);
1660    }
1661
1662    mVisibleRegionsDirty |= visibleRegions;
1663}
1664
1665void SurfaceFlinger::invalidateHwcGeometry()
1666{
1667    mHwWorkListDirty = true;
1668}
1669
1670
1671void SurfaceFlinger::doDisplayComposition(const sp<const DisplayDevice>& hw,
1672        const Region& inDirtyRegion)
1673{
1674    // We only need to actually compose the display if:
1675    // 1) It is being handled by hardware composer, which may need this to
1676    //    keep its virtual display state machine in sync, or
1677    // 2) There is work to be done (the dirty region isn't empty)
1678    bool isHwcDisplay = hw->getHwcDisplayId() >= 0;
1679    if (!isHwcDisplay && inDirtyRegion.isEmpty()) {
1680        return;
1681    }
1682
1683    Region dirtyRegion(inDirtyRegion);
1684
1685    // compute the invalid region
1686    hw->swapRegion.orSelf(dirtyRegion);
1687
1688    uint32_t flags = hw->getFlags();
1689    if (flags & DisplayDevice::SWAP_RECTANGLE) {
1690        // we can redraw only what's dirty, but since SWAP_RECTANGLE only
1691        // takes a rectangle, we must make sure to update that whole
1692        // rectangle in that case
1693        dirtyRegion.set(hw->swapRegion.bounds());
1694    } else {
1695        if (flags & DisplayDevice::PARTIAL_UPDATES) {
1696            // We need to redraw the rectangle that will be updated
1697            // (pushed to the framebuffer).
1698            // This is needed because PARTIAL_UPDATES only takes one
1699            // rectangle instead of a region (see DisplayDevice::flip())
1700            dirtyRegion.set(hw->swapRegion.bounds());
1701        } else {
1702            // we need to redraw everything (the whole screen)
1703            dirtyRegion.set(hw->bounds());
1704            hw->swapRegion = dirtyRegion;
1705        }
1706    }
1707
1708    if (CC_LIKELY(!mDaltonize && !mHasColorMatrix)) {
1709        doComposeSurfaces(hw, dirtyRegion);
1710    } else {
1711        RenderEngine& engine(getRenderEngine());
1712        mat4 colorMatrix = mColorMatrix;
1713        if (mDaltonize) {
1714            colorMatrix = colorMatrix * mDaltonizer();
1715        }
1716        engine.beginGroup(colorMatrix);
1717        doComposeSurfaces(hw, dirtyRegion);
1718        engine.endGroup();
1719    }
1720
1721    // update the swap region and clear the dirty region
1722    hw->swapRegion.orSelf(dirtyRegion);
1723
1724    // swap buffers (presentation)
1725    hw->swapBuffers(getHwComposer());
1726}
1727
1728void SurfaceFlinger::doComposeSurfaces(const sp<const DisplayDevice>& hw, const Region& dirty)
1729{
1730    RenderEngine& engine(getRenderEngine());
1731    const int32_t id = hw->getHwcDisplayId();
1732    HWComposer& hwc(getHwComposer());
1733    HWComposer::LayerListIterator cur = hwc.begin(id);
1734    const HWComposer::LayerListIterator end = hwc.end(id);
1735
1736    bool hasGlesComposition = hwc.hasGlesComposition(id);
1737    if (hasGlesComposition) {
1738        if (!hw->makeCurrent(mEGLDisplay, mEGLContext)) {
1739            ALOGW("DisplayDevice::makeCurrent failed. Aborting surface composition for display %s",
1740                  hw->getDisplayName().string());
1741            return;
1742        }
1743
1744        // Never touch the framebuffer if we don't have any framebuffer layers
1745        const bool hasHwcComposition = hwc.hasHwcComposition(id);
1746        if (hasHwcComposition) {
1747            // when using overlays, we assume a fully transparent framebuffer
1748            // NOTE: we could reduce how much we need to clear, for instance
1749            // remove where there are opaque FB layers. however, on some
1750            // GPUs doing a "clean slate" clear might be more efficient.
1751            // We'll revisit later if needed.
1752            engine.clearWithColor(0, 0, 0, 0);
1753        } else {
1754            // we start with the whole screen area
1755            const Region bounds(hw->getBounds());
1756
1757            // we remove the scissor part
1758            // we're left with the letterbox region
1759            // (common case is that letterbox ends-up being empty)
1760            const Region letterbox(bounds.subtract(hw->getScissor()));
1761
1762            // compute the area to clear
1763            Region region(hw->undefinedRegion.merge(letterbox));
1764
1765            // but limit it to the dirty region
1766            region.andSelf(dirty);
1767
1768            // screen is already cleared here
1769            if (!region.isEmpty()) {
1770                // can happen with SurfaceView
1771                drawWormhole(hw, region);
1772            }
1773        }
1774
1775        if (hw->getDisplayType() != DisplayDevice::DISPLAY_PRIMARY) {
1776            // just to be on the safe side, we don't set the
1777            // scissor on the main display. It should never be needed
1778            // anyways (though in theory it could since the API allows it).
1779            const Rect& bounds(hw->getBounds());
1780            const Rect& scissor(hw->getScissor());
1781            if (scissor != bounds) {
1782                // scissor doesn't match the screen's dimensions, so we
1783                // need to clear everything outside of it and enable
1784                // the GL scissor so we don't draw anything where we shouldn't
1785
1786                // enable scissor for this frame
1787                const uint32_t height = hw->getHeight();
1788                engine.setScissor(scissor.left, height - scissor.bottom,
1789                        scissor.getWidth(), scissor.getHeight());
1790            }
1791        }
1792    }
1793
1794    /*
1795     * and then, render the layers targeted at the framebuffer
1796     */
1797
1798    const Vector< sp<Layer> >& layers(hw->getVisibleLayersSortedByZ());
1799    const size_t count = layers.size();
1800    const Transform& tr = hw->getTransform();
1801    if (cur != end) {
1802        // we're using h/w composer
1803        for (size_t i=0 ; i<count && cur!=end ; ++i, ++cur) {
1804            const sp<Layer>& layer(layers[i]);
1805            const Region clip(dirty.intersect(tr.transform(layer->visibleRegion)));
1806            if (!clip.isEmpty()) {
1807                switch (cur->getCompositionType()) {
1808                    case HWC_CURSOR_OVERLAY:
1809                    case HWC_OVERLAY: {
1810                        const Layer::State& state(layer->getDrawingState());
1811                        if ((cur->getHints() & HWC_HINT_CLEAR_FB)
1812                                && i
1813                                && layer->isOpaque(state) && (state.alpha == 0xFF)
1814                                && hasGlesComposition) {
1815                            // never clear the very first layer since we're
1816                            // guaranteed the FB is already cleared
1817                            layer->clearWithOpenGL(hw, clip);
1818                        }
1819                        break;
1820                    }
1821                    case HWC_FRAMEBUFFER: {
1822                        layer->draw(hw, clip);
1823                        break;
1824                    }
1825                    case HWC_FRAMEBUFFER_TARGET: {
1826                        // this should not happen as the iterator shouldn't
1827                        // let us get there.
1828                        ALOGW("HWC_FRAMEBUFFER_TARGET found in hwc list (index=%zu)", i);
1829                        break;
1830                    }
1831                }
1832            }
1833            layer->setAcquireFence(hw, *cur);
1834        }
1835    } else {
1836        // we're not using h/w composer
1837        for (size_t i=0 ; i<count ; ++i) {
1838            const sp<Layer>& layer(layers[i]);
1839            const Region clip(dirty.intersect(
1840                    tr.transform(layer->visibleRegion)));
1841            if (!clip.isEmpty()) {
1842                layer->draw(hw, clip);
1843            }
1844        }
1845    }
1846
1847    // disable scissor at the end of the frame
1848    engine.disableScissor();
1849}
1850
1851void SurfaceFlinger::drawWormhole(const sp<const DisplayDevice>& hw, const Region& region) const {
1852    const int32_t height = hw->getHeight();
1853    RenderEngine& engine(getRenderEngine());
1854    engine.fillRegionWithColor(region, height, 0, 0, 0, 0);
1855}
1856
1857void SurfaceFlinger::addClientLayer(const sp<Client>& client,
1858        const sp<IBinder>& handle,
1859        const sp<IGraphicBufferProducer>& gbc,
1860        const sp<Layer>& lbc)
1861{
1862    // attach this layer to the client
1863    client->attachLayer(handle, lbc);
1864
1865    // add this layer to the current state list
1866    Mutex::Autolock _l(mStateLock);
1867    mCurrentState.layersSortedByZ.add(lbc);
1868    mGraphicBufferProducerList.add(gbc->asBinder());
1869}
1870
1871status_t SurfaceFlinger::removeLayer(const sp<Layer>& layer) {
1872    Mutex::Autolock _l(mStateLock);
1873    ssize_t index = mCurrentState.layersSortedByZ.remove(layer);
1874    if (index >= 0) {
1875        mLayersPendingRemoval.push(layer);
1876        mLayersRemoved = true;
1877        setTransactionFlags(eTransactionNeeded);
1878        return NO_ERROR;
1879    }
1880    return status_t(index);
1881}
1882
1883uint32_t SurfaceFlinger::peekTransactionFlags(uint32_t /* flags */) {
1884    return android_atomic_release_load(&mTransactionFlags);
1885}
1886
1887uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) {
1888    return android_atomic_and(~flags, &mTransactionFlags) & flags;
1889}
1890
1891uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) {
1892    uint32_t old = android_atomic_or(flags, &mTransactionFlags);
1893    if ((old & flags)==0) { // wake the server up
1894        signalTransaction();
1895    }
1896    return old;
1897}
1898
1899void SurfaceFlinger::setTransactionState(
1900        const Vector<ComposerState>& state,
1901        const Vector<DisplayState>& displays,
1902        uint32_t flags)
1903{
1904    ATRACE_CALL();
1905    Mutex::Autolock _l(mStateLock);
1906    uint32_t transactionFlags = 0;
1907
1908    if (flags & eAnimation) {
1909        // For window updates that are part of an animation we must wait for
1910        // previous animation "frames" to be handled.
1911        while (mAnimTransactionPending) {
1912            status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
1913            if (CC_UNLIKELY(err != NO_ERROR)) {
1914                // just in case something goes wrong in SF, return to the
1915                // caller after a few seconds.
1916                ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out "
1917                        "waiting for previous animation frame");
1918                mAnimTransactionPending = false;
1919                break;
1920            }
1921        }
1922    }
1923
1924    size_t count = displays.size();
1925    for (size_t i=0 ; i<count ; i++) {
1926        const DisplayState& s(displays[i]);
1927        transactionFlags |= setDisplayStateLocked(s);
1928    }
1929
1930    count = state.size();
1931    for (size_t i=0 ; i<count ; i++) {
1932        const ComposerState& s(state[i]);
1933        // Here we need to check that the interface we're given is indeed
1934        // one of our own. A malicious client could give us a NULL
1935        // IInterface, or one of its own or even one of our own but a
1936        // different type. All these situations would cause us to crash.
1937        //
1938        // NOTE: it would be better to use RTTI as we could directly check
1939        // that we have a Client*. however, RTTI is disabled in Android.
1940        if (s.client != NULL) {
1941            sp<IBinder> binder = s.client->asBinder();
1942            if (binder != NULL) {
1943                String16 desc(binder->getInterfaceDescriptor());
1944                if (desc == ISurfaceComposerClient::descriptor) {
1945                    sp<Client> client( static_cast<Client *>(s.client.get()) );
1946                    transactionFlags |= setClientStateLocked(client, s.state);
1947                }
1948            }
1949        }
1950    }
1951
1952    if (transactionFlags) {
1953        // this triggers the transaction
1954        setTransactionFlags(transactionFlags);
1955
1956        // if this is a synchronous transaction, wait for it to take effect
1957        // before returning.
1958        if (flags & eSynchronous) {
1959            mTransactionPending = true;
1960        }
1961        if (flags & eAnimation) {
1962            mAnimTransactionPending = true;
1963        }
1964        while (mTransactionPending) {
1965            status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
1966            if (CC_UNLIKELY(err != NO_ERROR)) {
1967                // just in case something goes wrong in SF, return to the
1968                // called after a few seconds.
1969                ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");
1970                mTransactionPending = false;
1971                break;
1972            }
1973        }
1974    }
1975}
1976
1977uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s)
1978{
1979    ssize_t dpyIdx = mCurrentState.displays.indexOfKey(s.token);
1980    if (dpyIdx < 0)
1981        return 0;
1982
1983    uint32_t flags = 0;
1984    DisplayDeviceState& disp(mCurrentState.displays.editValueAt(dpyIdx));
1985    if (disp.isValid()) {
1986        const uint32_t what = s.what;
1987        if (what & DisplayState::eSurfaceChanged) {
1988            if (disp.surface->asBinder() != s.surface->asBinder()) {
1989                disp.surface = s.surface;
1990                flags |= eDisplayTransactionNeeded;
1991            }
1992        }
1993        if (what & DisplayState::eLayerStackChanged) {
1994            if (disp.layerStack != s.layerStack) {
1995                disp.layerStack = s.layerStack;
1996                flags |= eDisplayTransactionNeeded;
1997            }
1998        }
1999        if (what & DisplayState::eDisplayProjectionChanged) {
2000            if (disp.orientation != s.orientation) {
2001                disp.orientation = s.orientation;
2002                flags |= eDisplayTransactionNeeded;
2003            }
2004            if (disp.frame != s.frame) {
2005                disp.frame = s.frame;
2006                flags |= eDisplayTransactionNeeded;
2007            }
2008            if (disp.viewport != s.viewport) {
2009                disp.viewport = s.viewport;
2010                flags |= eDisplayTransactionNeeded;
2011            }
2012        }
2013        if (what & DisplayState::eDisplaySizeChanged) {
2014            if (disp.width != s.width) {
2015                disp.width = s.width;
2016                flags |= eDisplayTransactionNeeded;
2017            }
2018            if (disp.height != s.height) {
2019                disp.height = s.height;
2020                flags |= eDisplayTransactionNeeded;
2021            }
2022        }
2023    }
2024    return flags;
2025}
2026
2027uint32_t SurfaceFlinger::setClientStateLocked(
2028        const sp<Client>& client,
2029        const layer_state_t& s)
2030{
2031    uint32_t flags = 0;
2032    sp<Layer> layer(client->getLayerUser(s.surface));
2033    if (layer != 0) {
2034        const uint32_t what = s.what;
2035        if (what & layer_state_t::ePositionChanged) {
2036            if (layer->setPosition(s.x, s.y))
2037                flags |= eTraversalNeeded;
2038        }
2039        if (what & layer_state_t::eLayerChanged) {
2040            // NOTE: index needs to be calculated before we update the state
2041            ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
2042            if (layer->setLayer(s.z)) {
2043                mCurrentState.layersSortedByZ.removeAt(idx);
2044                mCurrentState.layersSortedByZ.add(layer);
2045                // we need traversal (state changed)
2046                // AND transaction (list changed)
2047                flags |= eTransactionNeeded|eTraversalNeeded;
2048            }
2049        }
2050        if (what & layer_state_t::eSizeChanged) {
2051            if (layer->setSize(s.w, s.h)) {
2052                flags |= eTraversalNeeded;
2053            }
2054        }
2055        if (what & layer_state_t::eAlphaChanged) {
2056            if (layer->setAlpha(uint8_t(255.0f*s.alpha+0.5f)))
2057                flags |= eTraversalNeeded;
2058        }
2059        if (what & layer_state_t::eMatrixChanged) {
2060            if (layer->setMatrix(s.matrix))
2061                flags |= eTraversalNeeded;
2062        }
2063        if (what & layer_state_t::eTransparentRegionChanged) {
2064            if (layer->setTransparentRegionHint(s.transparentRegion))
2065                flags |= eTraversalNeeded;
2066        }
2067        if ((what & layer_state_t::eVisibilityChanged) ||
2068                (what & layer_state_t::eOpacityChanged)) {
2069            // TODO: should we just use an eFlagsChanged for this?
2070            if (layer->setFlags(s.flags, s.mask))
2071                flags |= eTraversalNeeded;
2072        }
2073        if (what & layer_state_t::eCropChanged) {
2074            if (layer->setCrop(s.crop))
2075                flags |= eTraversalNeeded;
2076        }
2077        if (what & layer_state_t::eLayerStackChanged) {
2078            // NOTE: index needs to be calculated before we update the state
2079            ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
2080            if (layer->setLayerStack(s.layerStack)) {
2081                mCurrentState.layersSortedByZ.removeAt(idx);
2082                mCurrentState.layersSortedByZ.add(layer);
2083                // we need traversal (state changed)
2084                // AND transaction (list changed)
2085                flags |= eTransactionNeeded|eTraversalNeeded;
2086            }
2087        }
2088    }
2089    return flags;
2090}
2091
2092status_t SurfaceFlinger::createLayer(
2093        const String8& name,
2094        const sp<Client>& client,
2095        uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
2096        sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp)
2097{
2098    //ALOGD("createLayer for (%d x %d), name=%s", w, h, name.string());
2099    if (int32_t(w|h) < 0) {
2100        ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
2101                int(w), int(h));
2102        return BAD_VALUE;
2103    }
2104
2105    status_t result = NO_ERROR;
2106
2107    sp<Layer> layer;
2108
2109    switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
2110        case ISurfaceComposerClient::eFXSurfaceNormal:
2111            result = createNormalLayer(client,
2112                    name, w, h, flags, format,
2113                    handle, gbp, &layer);
2114            break;
2115        case ISurfaceComposerClient::eFXSurfaceDim:
2116            result = createDimLayer(client,
2117                    name, w, h, flags,
2118                    handle, gbp, &layer);
2119            break;
2120        default:
2121            result = BAD_VALUE;
2122            break;
2123    }
2124
2125    if (result == NO_ERROR) {
2126        addClientLayer(client, *handle, *gbp, layer);
2127        setTransactionFlags(eTransactionNeeded);
2128    }
2129    return result;
2130}
2131
2132status_t SurfaceFlinger::createNormalLayer(const sp<Client>& client,
2133        const String8& name, uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
2134        sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
2135{
2136    // initialize the surfaces
2137    switch (format) {
2138    case PIXEL_FORMAT_TRANSPARENT:
2139    case PIXEL_FORMAT_TRANSLUCENT:
2140        format = PIXEL_FORMAT_RGBA_8888;
2141        break;
2142    case PIXEL_FORMAT_OPAQUE:
2143        format = PIXEL_FORMAT_RGBX_8888;
2144        break;
2145    }
2146
2147    *outLayer = new Layer(this, client, name, w, h, flags);
2148    status_t err = (*outLayer)->setBuffers(w, h, format, flags);
2149    if (err == NO_ERROR) {
2150        *handle = (*outLayer)->getHandle();
2151        *gbp = (*outLayer)->getProducer();
2152    }
2153
2154    ALOGE_IF(err, "createNormalLayer() failed (%s)", strerror(-err));
2155    return err;
2156}
2157
2158status_t SurfaceFlinger::createDimLayer(const sp<Client>& client,
2159        const String8& name, uint32_t w, uint32_t h, uint32_t flags,
2160        sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
2161{
2162    *outLayer = new LayerDim(this, client, name, w, h, flags);
2163    *handle = (*outLayer)->getHandle();
2164    *gbp = (*outLayer)->getProducer();
2165    return NO_ERROR;
2166}
2167
2168status_t SurfaceFlinger::onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle)
2169{
2170    // called by the window manager when it wants to remove a Layer
2171    status_t err = NO_ERROR;
2172    sp<Layer> l(client->getLayerUser(handle));
2173    if (l != NULL) {
2174        err = removeLayer(l);
2175        ALOGE_IF(err<0 && err != NAME_NOT_FOUND,
2176                "error removing layer=%p (%s)", l.get(), strerror(-err));
2177    }
2178    return err;
2179}
2180
2181status_t SurfaceFlinger::onLayerDestroyed(const wp<Layer>& layer)
2182{
2183    // called by ~LayerCleaner() when all references to the IBinder (handle)
2184    // are gone
2185    status_t err = NO_ERROR;
2186    sp<Layer> l(layer.promote());
2187    if (l != NULL) {
2188        err = removeLayer(l);
2189        ALOGE_IF(err<0 && err != NAME_NOT_FOUND,
2190                "error removing layer=%p (%s)", l.get(), strerror(-err));
2191    }
2192    return err;
2193}
2194
2195// ---------------------------------------------------------------------------
2196
2197void SurfaceFlinger::onInitializeDisplays() {
2198    // reset screen orientation and use primary layer stack
2199    Vector<ComposerState> state;
2200    Vector<DisplayState> displays;
2201    DisplayState d;
2202    d.what = DisplayState::eDisplayProjectionChanged |
2203             DisplayState::eLayerStackChanged;
2204    d.token = mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY];
2205    d.layerStack = 0;
2206    d.orientation = DisplayState::eOrientationDefault;
2207    d.frame.makeInvalid();
2208    d.viewport.makeInvalid();
2209    d.width = 0;
2210    d.height = 0;
2211    displays.add(d);
2212    setTransactionState(state, displays, 0);
2213    setPowerModeInternal(getDisplayDevice(d.token), HWC_POWER_MODE_NORMAL);
2214
2215    const nsecs_t period =
2216            getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
2217    mAnimFrameTracker.setDisplayRefreshPeriod(period);
2218}
2219
2220void SurfaceFlinger::initializeDisplays() {
2221    class MessageScreenInitialized : public MessageBase {
2222        SurfaceFlinger* flinger;
2223    public:
2224        MessageScreenInitialized(SurfaceFlinger* flinger) : flinger(flinger) { }
2225        virtual bool handler() {
2226            flinger->onInitializeDisplays();
2227            return true;
2228        }
2229    };
2230    sp<MessageBase> msg = new MessageScreenInitialized(this);
2231    postMessageAsync(msg);  // we may be called from main thread, use async message
2232}
2233
2234void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& hw,
2235        int mode) {
2236    ALOGD("Set power mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(),
2237            this);
2238    int32_t type = hw->getDisplayType();
2239    int currentMode = hw->getPowerMode();
2240
2241    if (mode == currentMode) {
2242        ALOGD("Screen type=%d is already mode=%d", hw->getDisplayType(), mode);
2243        return;
2244    }
2245
2246    hw->setPowerMode(mode);
2247    if (type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
2248        ALOGW("Trying to set power mode for virtual display");
2249        return;
2250    }
2251
2252    if (currentMode == HWC_POWER_MODE_OFF) {
2253        getHwComposer().setPowerMode(type, mode);
2254        if (type == DisplayDevice::DISPLAY_PRIMARY) {
2255            // FIXME: eventthread only knows about the main display right now
2256            mEventThread->onScreenAcquired();
2257            resyncToHardwareVsync(true);
2258        }
2259
2260        mVisibleRegionsDirty = true;
2261        repaintEverything();
2262    } else if (mode == HWC_POWER_MODE_OFF) {
2263        if (type == DisplayDevice::DISPLAY_PRIMARY) {
2264            disableHardwareVsync(true); // also cancels any in-progress resync
2265
2266            // FIXME: eventthread only knows about the main display right now
2267            mEventThread->onScreenReleased();
2268        }
2269
2270        getHwComposer().setPowerMode(type, mode);
2271        mVisibleRegionsDirty = true;
2272        // from this point on, SF will stop drawing on this display
2273    } else {
2274        getHwComposer().setPowerMode(type, mode);
2275    }
2276}
2277
2278void SurfaceFlinger::setPowerMode(const sp<IBinder>& display, int mode) {
2279    class MessageSetPowerMode: public MessageBase {
2280        SurfaceFlinger& mFlinger;
2281        sp<IBinder> mDisplay;
2282        int mMode;
2283    public:
2284        MessageSetPowerMode(SurfaceFlinger& flinger,
2285                const sp<IBinder>& disp, int mode) : mFlinger(flinger),
2286                    mDisplay(disp) { mMode = mode; }
2287        virtual bool handler() {
2288            sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
2289            if (hw == NULL) {
2290                ALOGE("Attempt to set power mode = %d for null display %p",
2291                        mMode, mDisplay.get());
2292            } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) {
2293                ALOGW("Attempt to set power mode = %d for virtual display",
2294                        mMode);
2295            } else {
2296                mFlinger.setPowerModeInternal(hw, mMode);
2297            }
2298            return true;
2299        }
2300    };
2301    sp<MessageBase> msg = new MessageSetPowerMode(*this, display, mode);
2302    postMessageSync(msg);
2303}
2304
2305// ---------------------------------------------------------------------------
2306
2307status_t SurfaceFlinger::dump(int fd, const Vector<String16>& args)
2308{
2309    String8 result;
2310
2311    IPCThreadState* ipc = IPCThreadState::self();
2312    const int pid = ipc->getCallingPid();
2313    const int uid = ipc->getCallingUid();
2314    if ((uid != AID_SHELL) &&
2315            !PermissionCache::checkPermission(sDump, pid, uid)) {
2316        result.appendFormat("Permission Denial: "
2317                "can't dump SurfaceFlinger from pid=%d, uid=%d\n", pid, uid);
2318    } else {
2319        // Try to get the main lock, but don't insist if we can't
2320        // (this would indicate SF is stuck, but we want to be able to
2321        // print something in dumpsys).
2322        int retry = 3;
2323        while (mStateLock.tryLock()<0 && --retry>=0) {
2324            usleep(1000000);
2325        }
2326        const bool locked(retry >= 0);
2327        if (!locked) {
2328            result.append(
2329                    "SurfaceFlinger appears to be unresponsive, "
2330                    "dumping anyways (no locks held)\n");
2331        }
2332
2333        bool dumpAll = true;
2334        size_t index = 0;
2335        size_t numArgs = args.size();
2336        if (numArgs) {
2337            if ((index < numArgs) &&
2338                    (args[index] == String16("--list"))) {
2339                index++;
2340                listLayersLocked(args, index, result);
2341                dumpAll = false;
2342            }
2343
2344            if ((index < numArgs) &&
2345                    (args[index] == String16("--latency"))) {
2346                index++;
2347                dumpStatsLocked(args, index, result);
2348                dumpAll = false;
2349            }
2350
2351            if ((index < numArgs) &&
2352                    (args[index] == String16("--latency-clear"))) {
2353                index++;
2354                clearStatsLocked(args, index, result);
2355                dumpAll = false;
2356            }
2357
2358            if ((index < numArgs) &&
2359                    (args[index] == String16("--dispsync"))) {
2360                index++;
2361                mPrimaryDispSync.dump(result);
2362                dumpAll = false;
2363            }
2364        }
2365
2366        if (dumpAll) {
2367            dumpAllLocked(args, index, result);
2368        }
2369
2370        if (locked) {
2371            mStateLock.unlock();
2372        }
2373    }
2374    write(fd, result.string(), result.size());
2375    return NO_ERROR;
2376}
2377
2378void SurfaceFlinger::listLayersLocked(const Vector<String16>& /* args */,
2379        size_t& /* index */, String8& result) const
2380{
2381    const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
2382    const size_t count = currentLayers.size();
2383    for (size_t i=0 ; i<count ; i++) {
2384        const sp<Layer>& layer(currentLayers[i]);
2385        result.appendFormat("%s\n", layer->getName().string());
2386    }
2387}
2388
2389void SurfaceFlinger::dumpStatsLocked(const Vector<String16>& args, size_t& index,
2390        String8& result) const
2391{
2392    String8 name;
2393    if (index < args.size()) {
2394        name = String8(args[index]);
2395        index++;
2396    }
2397
2398    const nsecs_t period =
2399            getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
2400    result.appendFormat("%" PRId64 "\n", period);
2401
2402    if (name.isEmpty()) {
2403        mAnimFrameTracker.dumpStats(result);
2404    } else {
2405        const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
2406        const size_t count = currentLayers.size();
2407        for (size_t i=0 ; i<count ; i++) {
2408            const sp<Layer>& layer(currentLayers[i]);
2409            if (name == layer->getName()) {
2410                layer->dumpFrameStats(result);
2411            }
2412        }
2413    }
2414}
2415
2416void SurfaceFlinger::clearStatsLocked(const Vector<String16>& args, size_t& index,
2417        String8& /* result */)
2418{
2419    String8 name;
2420    if (index < args.size()) {
2421        name = String8(args[index]);
2422        index++;
2423    }
2424
2425    const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
2426    const size_t count = currentLayers.size();
2427    for (size_t i=0 ; i<count ; i++) {
2428        const sp<Layer>& layer(currentLayers[i]);
2429        if (name.isEmpty() || (name == layer->getName())) {
2430            layer->clearFrameStats();
2431        }
2432    }
2433
2434    mAnimFrameTracker.clearStats();
2435}
2436
2437// This should only be called from the main thread.  Otherwise it would need
2438// the lock and should use mCurrentState rather than mDrawingState.
2439void SurfaceFlinger::logFrameStats() {
2440    const LayerVector& drawingLayers = mDrawingState.layersSortedByZ;
2441    const size_t count = drawingLayers.size();
2442    for (size_t i=0 ; i<count ; i++) {
2443        const sp<Layer>& layer(drawingLayers[i]);
2444        layer->logFrameStats();
2445    }
2446
2447    mAnimFrameTracker.logAndResetStats(String8("<win-anim>"));
2448}
2449
2450/*static*/ void SurfaceFlinger::appendSfConfigString(String8& result)
2451{
2452    static const char* config =
2453            " [sf"
2454#ifdef HAS_CONTEXT_PRIORITY
2455            " HAS_CONTEXT_PRIORITY"
2456#endif
2457#ifdef NEVER_DEFAULT_TO_ASYNC_MODE
2458            " NEVER_DEFAULT_TO_ASYNC_MODE"
2459#endif
2460#ifdef TARGET_DISABLE_TRIPLE_BUFFERING
2461            " TARGET_DISABLE_TRIPLE_BUFFERING"
2462#endif
2463            "]";
2464    result.append(config);
2465}
2466
2467void SurfaceFlinger::dumpAllLocked(const Vector<String16>& args, size_t& index,
2468        String8& result) const
2469{
2470    bool colorize = false;
2471    if (index < args.size()
2472            && (args[index] == String16("--color"))) {
2473        colorize = true;
2474        index++;
2475    }
2476
2477    Colorizer colorizer(colorize);
2478
2479    // figure out if we're stuck somewhere
2480    const nsecs_t now = systemTime();
2481    const nsecs_t inSwapBuffers(mDebugInSwapBuffers);
2482    const nsecs_t inTransaction(mDebugInTransaction);
2483    nsecs_t inSwapBuffersDuration = (inSwapBuffers) ? now-inSwapBuffers : 0;
2484    nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
2485
2486    /*
2487     * Dump library configuration.
2488     */
2489
2490    colorizer.bold(result);
2491    result.append("Build configuration:");
2492    colorizer.reset(result);
2493    appendSfConfigString(result);
2494    appendUiConfigString(result);
2495    appendGuiConfigString(result);
2496    result.append("\n");
2497
2498    colorizer.bold(result);
2499    result.append("Sync configuration: ");
2500    colorizer.reset(result);
2501    result.append(SyncFeatures::getInstance().toString());
2502    result.append("\n");
2503
2504    colorizer.bold(result);
2505    result.append("DispSync configuration: ");
2506    colorizer.reset(result);
2507    result.appendFormat("app phase %" PRId64 " ns, sf phase %" PRId64 " ns, "
2508            "present offset %d ns (refresh %" PRId64 " ns)",
2509        vsyncPhaseOffsetNs, sfVsyncPhaseOffsetNs, PRESENT_TIME_OFFSET_FROM_VSYNC_NS,
2510        mHwc->getRefreshPeriod(HWC_DISPLAY_PRIMARY));
2511    result.append("\n");
2512
2513    /*
2514     * Dump the visible layer list
2515     */
2516    const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
2517    const size_t count = currentLayers.size();
2518    colorizer.bold(result);
2519    result.appendFormat("Visible layers (count = %zu)\n", count);
2520    colorizer.reset(result);
2521    for (size_t i=0 ; i<count ; i++) {
2522        const sp<Layer>& layer(currentLayers[i]);
2523        layer->dump(result, colorizer);
2524    }
2525
2526    /*
2527     * Dump Display state
2528     */
2529
2530    colorizer.bold(result);
2531    result.appendFormat("Displays (%zu entries)\n", mDisplays.size());
2532    colorizer.reset(result);
2533    for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
2534        const sp<const DisplayDevice>& hw(mDisplays[dpy]);
2535        hw->dump(result);
2536    }
2537
2538    /*
2539     * Dump SurfaceFlinger global state
2540     */
2541
2542    colorizer.bold(result);
2543    result.append("SurfaceFlinger global state:\n");
2544    colorizer.reset(result);
2545
2546    HWComposer& hwc(getHwComposer());
2547    sp<const DisplayDevice> hw(getDefaultDisplayDevice());
2548
2549    colorizer.bold(result);
2550    result.appendFormat("EGL implementation : %s\n",
2551            eglQueryStringImplementationANDROID(mEGLDisplay, EGL_VERSION));
2552    colorizer.reset(result);
2553    result.appendFormat("%s\n",
2554            eglQueryStringImplementationANDROID(mEGLDisplay, EGL_EXTENSIONS));
2555
2556    mRenderEngine->dump(result);
2557
2558    hw->undefinedRegion.dump(result, "undefinedRegion");
2559    result.appendFormat("  orientation=%d, isDisplayOn=%d\n",
2560            hw->getOrientation(), hw->isDisplayOn());
2561    result.appendFormat(
2562            "  last eglSwapBuffers() time: %f us\n"
2563            "  last transaction time     : %f us\n"
2564            "  transaction-flags         : %08x\n"
2565            "  refresh-rate              : %f fps\n"
2566            "  x-dpi                     : %f\n"
2567            "  y-dpi                     : %f\n"
2568            "  gpu_to_cpu_unsupported    : %d\n"
2569            ,
2570            mLastSwapBufferTime/1000.0,
2571            mLastTransactionTime/1000.0,
2572            mTransactionFlags,
2573            1e9 / hwc.getRefreshPeriod(HWC_DISPLAY_PRIMARY),
2574            hwc.getDpiX(HWC_DISPLAY_PRIMARY),
2575            hwc.getDpiY(HWC_DISPLAY_PRIMARY),
2576            !mGpuToCpuSupported);
2577
2578    result.appendFormat("  eglSwapBuffers time: %f us\n",
2579            inSwapBuffersDuration/1000.0);
2580
2581    result.appendFormat("  transaction time: %f us\n",
2582            inTransactionDuration/1000.0);
2583
2584    /*
2585     * VSYNC state
2586     */
2587    mEventThread->dump(result);
2588
2589    /*
2590     * Dump HWComposer state
2591     */
2592    colorizer.bold(result);
2593    result.append("h/w composer state:\n");
2594    colorizer.reset(result);
2595    result.appendFormat("  h/w composer %s and %s\n",
2596            hwc.initCheck()==NO_ERROR ? "present" : "not present",
2597                    (mDebugDisableHWC || mDebugRegion || mDaltonize
2598                            || mHasColorMatrix) ? "disabled" : "enabled");
2599    hwc.dump(result);
2600
2601    /*
2602     * Dump gralloc state
2603     */
2604    const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
2605    alloc.dump(result);
2606}
2607
2608const Vector< sp<Layer> >&
2609SurfaceFlinger::getLayerSortedByZForHwcDisplay(int id) {
2610    // Note: mStateLock is held here
2611    wp<IBinder> dpy;
2612    for (size_t i=0 ; i<mDisplays.size() ; i++) {
2613        if (mDisplays.valueAt(i)->getHwcDisplayId() == id) {
2614            dpy = mDisplays.keyAt(i);
2615            break;
2616        }
2617    }
2618    if (dpy == NULL) {
2619        ALOGE("getLayerSortedByZForHwcDisplay: invalid hwc display id %d", id);
2620        // Just use the primary display so we have something to return
2621        dpy = getBuiltInDisplay(DisplayDevice::DISPLAY_PRIMARY);
2622    }
2623    return getDisplayDevice(dpy)->getVisibleLayersSortedByZ();
2624}
2625
2626bool SurfaceFlinger::startDdmConnection()
2627{
2628    void* libddmconnection_dso =
2629            dlopen("libsurfaceflinger_ddmconnection.so", RTLD_NOW);
2630    if (!libddmconnection_dso) {
2631        return false;
2632    }
2633    void (*DdmConnection_start)(const char* name);
2634    DdmConnection_start =
2635            (decltype(DdmConnection_start))dlsym(libddmconnection_dso, "DdmConnection_start");
2636    if (!DdmConnection_start) {
2637        dlclose(libddmconnection_dso);
2638        return false;
2639    }
2640    (*DdmConnection_start)(getServiceName());
2641    return true;
2642}
2643
2644status_t SurfaceFlinger::onTransact(
2645    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
2646{
2647    switch (code) {
2648        case CREATE_CONNECTION:
2649        case CREATE_DISPLAY:
2650        case SET_TRANSACTION_STATE:
2651        case BOOT_FINISHED:
2652        case CLEAR_ANIMATION_FRAME_STATS:
2653        case GET_ANIMATION_FRAME_STATS:
2654        case SET_POWER_MODE:
2655        {
2656            // codes that require permission check
2657            IPCThreadState* ipc = IPCThreadState::self();
2658            const int pid = ipc->getCallingPid();
2659            const int uid = ipc->getCallingUid();
2660            if ((uid != AID_GRAPHICS) &&
2661                    !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)) {
2662                ALOGE("Permission Denial: "
2663                        "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
2664                return PERMISSION_DENIED;
2665            }
2666            break;
2667        }
2668        case CAPTURE_SCREEN:
2669        {
2670            // codes that require permission check
2671            IPCThreadState* ipc = IPCThreadState::self();
2672            const int pid = ipc->getCallingPid();
2673            const int uid = ipc->getCallingUid();
2674            if ((uid != AID_GRAPHICS) &&
2675                    !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
2676                ALOGE("Permission Denial: "
2677                        "can't read framebuffer pid=%d, uid=%d", pid, uid);
2678                return PERMISSION_DENIED;
2679            }
2680            break;
2681        }
2682    }
2683
2684    status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
2685    if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
2686        CHECK_INTERFACE(ISurfaceComposer, data, reply);
2687        if (CC_UNLIKELY(!PermissionCache::checkCallingPermission(sHardwareTest))) {
2688            IPCThreadState* ipc = IPCThreadState::self();
2689            const int pid = ipc->getCallingPid();
2690            const int uid = ipc->getCallingUid();
2691            ALOGE("Permission Denial: "
2692                    "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
2693            return PERMISSION_DENIED;
2694        }
2695        int n;
2696        switch (code) {
2697            case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
2698            case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
2699                return NO_ERROR;
2700            case 1002:  // SHOW_UPDATES
2701                n = data.readInt32();
2702                mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
2703                invalidateHwcGeometry();
2704                repaintEverything();
2705                return NO_ERROR;
2706            case 1004:{ // repaint everything
2707                repaintEverything();
2708                return NO_ERROR;
2709            }
2710            case 1005:{ // force transaction
2711                setTransactionFlags(
2712                        eTransactionNeeded|
2713                        eDisplayTransactionNeeded|
2714                        eTraversalNeeded);
2715                return NO_ERROR;
2716            }
2717            case 1006:{ // send empty update
2718                signalRefresh();
2719                return NO_ERROR;
2720            }
2721            case 1008:  // toggle use of hw composer
2722                n = data.readInt32();
2723                mDebugDisableHWC = n ? 1 : 0;
2724                invalidateHwcGeometry();
2725                repaintEverything();
2726                return NO_ERROR;
2727            case 1009:  // toggle use of transform hint
2728                n = data.readInt32();
2729                mDebugDisableTransformHint = n ? 1 : 0;
2730                invalidateHwcGeometry();
2731                repaintEverything();
2732                return NO_ERROR;
2733            case 1010:  // interrogate.
2734                reply->writeInt32(0);
2735                reply->writeInt32(0);
2736                reply->writeInt32(mDebugRegion);
2737                reply->writeInt32(0);
2738                reply->writeInt32(mDebugDisableHWC);
2739                return NO_ERROR;
2740            case 1013: {
2741                Mutex::Autolock _l(mStateLock);
2742                sp<const DisplayDevice> hw(getDefaultDisplayDevice());
2743                reply->writeInt32(hw->getPageFlipCount());
2744                return NO_ERROR;
2745            }
2746            case 1014: {
2747                // daltonize
2748                n = data.readInt32();
2749                switch (n % 10) {
2750                    case 1: mDaltonizer.setType(Daltonizer::protanomaly);   break;
2751                    case 2: mDaltonizer.setType(Daltonizer::deuteranomaly); break;
2752                    case 3: mDaltonizer.setType(Daltonizer::tritanomaly);   break;
2753                }
2754                if (n >= 10) {
2755                    mDaltonizer.setMode(Daltonizer::correction);
2756                } else {
2757                    mDaltonizer.setMode(Daltonizer::simulation);
2758                }
2759                mDaltonize = n > 0;
2760                invalidateHwcGeometry();
2761                repaintEverything();
2762                return NO_ERROR;
2763            }
2764            case 1015: {
2765                // apply a color matrix
2766                n = data.readInt32();
2767                mHasColorMatrix = n ? 1 : 0;
2768                if (n) {
2769                    // color matrix is sent as mat3 matrix followed by vec3
2770                    // offset, then packed into a mat4 where the last row is
2771                    // the offset and extra values are 0
2772                    for (size_t i = 0 ; i < 4; i++) {
2773                      for (size_t j = 0; j < 4; j++) {
2774                          mColorMatrix[i][j] = data.readFloat();
2775                      }
2776                    }
2777                } else {
2778                    mColorMatrix = mat4();
2779                }
2780                invalidateHwcGeometry();
2781                repaintEverything();
2782                return NO_ERROR;
2783            }
2784            // This is an experimental interface
2785            // Needs to be shifted to proper binder interface when we productize
2786            case 1016: {
2787                n = data.readInt32();
2788                mPrimaryDispSync.setRefreshSkipCount(n);
2789                return NO_ERROR;
2790            }
2791        }
2792    }
2793    return err;
2794}
2795
2796void SurfaceFlinger::repaintEverything() {
2797    android_atomic_or(1, &mRepaintEverything);
2798    signalTransaction();
2799}
2800
2801// ---------------------------------------------------------------------------
2802// Capture screen into an IGraphiBufferProducer
2803// ---------------------------------------------------------------------------
2804
2805/* The code below is here to handle b/8734824
2806 *
2807 * We create a IGraphicBufferProducer wrapper that forwards all calls
2808 * from the surfaceflinger thread to the calling binder thread, where they
2809 * are executed. This allows the calling thread in the calling process to be
2810 * reused and not depend on having "enough" binder threads to handle the
2811 * requests.
2812 */
2813class GraphicProducerWrapper : public BBinder, public MessageHandler {
2814    /* Parts of GraphicProducerWrapper are run on two different threads,
2815     * communicating by sending messages via Looper but also by shared member
2816     * data. Coherence maintenance is subtle and in places implicit (ugh).
2817     *
2818     * Don't rely on Looper's sendMessage/handleMessage providing
2819     * release/acquire semantics for any data not actually in the Message.
2820     * Data going from surfaceflinger to binder threads needs to be
2821     * synchronized explicitly.
2822     *
2823     * Barrier open/wait do provide release/acquire semantics. This provides
2824     * implicit synchronization for data coming back from binder to
2825     * surfaceflinger threads.
2826     */
2827
2828    sp<IGraphicBufferProducer> impl;
2829    sp<Looper> looper;
2830    status_t result;
2831    bool exitPending;
2832    bool exitRequested;
2833    Barrier barrier;
2834    uint32_t code;
2835    Parcel const* data;
2836    Parcel* reply;
2837
2838    enum {
2839        MSG_API_CALL,
2840        MSG_EXIT
2841    };
2842
2843    /*
2844     * Called on surfaceflinger thread. This is called by our "fake"
2845     * BpGraphicBufferProducer. We package the data and reply Parcel and
2846     * forward them to the binder thread.
2847     */
2848    virtual status_t transact(uint32_t code,
2849            const Parcel& data, Parcel* reply, uint32_t /* flags */) {
2850        this->code = code;
2851        this->data = &data;
2852        this->reply = reply;
2853        if (exitPending) {
2854            // if we've exited, we run the message synchronously right here.
2855            // note (JH): as far as I can tell from looking at the code, this
2856            // never actually happens. if it does, i'm not sure if it happens
2857            // on the surfaceflinger or binder thread.
2858            handleMessage(Message(MSG_API_CALL));
2859        } else {
2860            barrier.close();
2861            // Prevent stores to this->{code, data, reply} from being
2862            // reordered later than the construction of Message.
2863            atomic_thread_fence(memory_order_release);
2864            looper->sendMessage(this, Message(MSG_API_CALL));
2865            barrier.wait();
2866        }
2867        return result;
2868    }
2869
2870    /*
2871     * here we run on the binder thread. All we've got to do is
2872     * call the real BpGraphicBufferProducer.
2873     */
2874    virtual void handleMessage(const Message& message) {
2875        int what = message.what;
2876        // Prevent reads below from happening before the read from Message
2877        atomic_thread_fence(memory_order_acquire);
2878        if (what == MSG_API_CALL) {
2879            result = impl->asBinder()->transact(code, data[0], reply);
2880            barrier.open();
2881        } else if (what == MSG_EXIT) {
2882            exitRequested = true;
2883        }
2884    }
2885
2886public:
2887    GraphicProducerWrapper(const sp<IGraphicBufferProducer>& impl)
2888    :   impl(impl),
2889        looper(new Looper(true)),
2890        exitPending(false),
2891        exitRequested(false)
2892    {}
2893
2894    // Binder thread
2895    status_t waitForResponse() {
2896        do {
2897            looper->pollOnce(-1);
2898        } while (!exitRequested);
2899        return result;
2900    }
2901
2902    // Client thread
2903    void exit(status_t result) {
2904        this->result = result;
2905        exitPending = true;
2906        // Ensure this->result is visible to the binder thread before it
2907        // handles the message.
2908        atomic_thread_fence(memory_order_release);
2909        looper->sendMessage(this, Message(MSG_EXIT));
2910    }
2911};
2912
2913
2914status_t SurfaceFlinger::captureScreen(const sp<IBinder>& display,
2915        const sp<IGraphicBufferProducer>& producer,
2916        Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
2917        uint32_t minLayerZ, uint32_t maxLayerZ,
2918        bool useIdentityTransform) {
2919
2920    if (CC_UNLIKELY(display == 0))
2921        return BAD_VALUE;
2922
2923    if (CC_UNLIKELY(producer == 0))
2924        return BAD_VALUE;
2925
2926    // if we have secure windows on this display, never allow the screen capture
2927    // unless the producer interface is local (i.e.: we can take a screenshot for
2928    // ourselves).
2929    if (!producer->asBinder()->localBinder()) {
2930        Mutex::Autolock _l(mStateLock);
2931        sp<const DisplayDevice> hw(getDisplayDevice(display));
2932        if (hw->getSecureLayerVisible()) {
2933            ALOGW("FB is protected: PERMISSION_DENIED");
2934            return PERMISSION_DENIED;
2935        }
2936    }
2937
2938    class MessageCaptureScreen : public MessageBase {
2939        SurfaceFlinger* flinger;
2940        sp<IBinder> display;
2941        sp<IGraphicBufferProducer> producer;
2942        Rect sourceCrop;
2943        uint32_t reqWidth, reqHeight;
2944        uint32_t minLayerZ,maxLayerZ;
2945        bool useIdentityTransform;
2946        status_t result;
2947    public:
2948        MessageCaptureScreen(SurfaceFlinger* flinger,
2949                const sp<IBinder>& display,
2950                const sp<IGraphicBufferProducer>& producer,
2951                Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
2952                uint32_t minLayerZ, uint32_t maxLayerZ,
2953                bool useIdentityTransform)
2954            : flinger(flinger), display(display), producer(producer),
2955              sourceCrop(sourceCrop), reqWidth(reqWidth), reqHeight(reqHeight),
2956              minLayerZ(minLayerZ), maxLayerZ(maxLayerZ),
2957              useIdentityTransform(useIdentityTransform),
2958              result(PERMISSION_DENIED)
2959        {
2960        }
2961        status_t getResult() const {
2962            return result;
2963        }
2964        virtual bool handler() {
2965            Mutex::Autolock _l(flinger->mStateLock);
2966            sp<const DisplayDevice> hw(flinger->getDisplayDevice(display));
2967            result = flinger->captureScreenImplLocked(hw, producer,
2968                    sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ,
2969                    useIdentityTransform);
2970            static_cast<GraphicProducerWrapper*>(producer->asBinder().get())->exit(result);
2971            return true;
2972        }
2973    };
2974
2975    // make sure to process transactions before screenshots -- a transaction
2976    // might already be pending but scheduled for VSYNC; this guarantees we
2977    // will handle it before the screenshot. When VSYNC finally arrives
2978    // the scheduled transaction will be a no-op. If no transactions are
2979    // scheduled at this time, this will end-up being a no-op as well.
2980    mEventQueue.invalidateTransactionNow();
2981
2982    // this creates a "fake" BBinder which will serve as a "fake" remote
2983    // binder to receive the marshaled calls and forward them to the
2984    // real remote (a BpGraphicBufferProducer)
2985    sp<GraphicProducerWrapper> wrapper = new GraphicProducerWrapper(producer);
2986
2987    // the asInterface() call below creates our "fake" BpGraphicBufferProducer
2988    // which does the marshaling work forwards to our "fake remote" above.
2989    sp<MessageBase> msg = new MessageCaptureScreen(this,
2990            display, IGraphicBufferProducer::asInterface( wrapper ),
2991            sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ,
2992            useIdentityTransform);
2993
2994    status_t res = postMessageAsync(msg);
2995    if (res == NO_ERROR) {
2996        res = wrapper->waitForResponse();
2997    }
2998    return res;
2999}
3000
3001
3002void SurfaceFlinger::renderScreenImplLocked(
3003        const sp<const DisplayDevice>& hw,
3004        Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
3005        uint32_t minLayerZ, uint32_t maxLayerZ,
3006        bool yswap, bool useIdentityTransform)
3007{
3008    ATRACE_CALL();
3009    RenderEngine& engine(getRenderEngine());
3010
3011    // get screen geometry
3012    const uint32_t hw_w = hw->getWidth();
3013    const uint32_t hw_h = hw->getHeight();
3014    const bool filtering = reqWidth != hw_w || reqWidth != hw_h;
3015
3016    // if a default or invalid sourceCrop is passed in, set reasonable values
3017    if (sourceCrop.width() == 0 || sourceCrop.height() == 0 ||
3018            !sourceCrop.isValid()) {
3019        sourceCrop.setLeftTop(Point(0, 0));
3020        sourceCrop.setRightBottom(Point(hw_w, hw_h));
3021    }
3022
3023    // ensure that sourceCrop is inside screen
3024    if (sourceCrop.left < 0) {
3025        ALOGE("Invalid crop rect: l = %d (< 0)", sourceCrop.left);
3026    }
3027    if (sourceCrop.right > hw_w) {
3028        ALOGE("Invalid crop rect: r = %d (> %d)", sourceCrop.right, hw_w);
3029    }
3030    if (sourceCrop.top < 0) {
3031        ALOGE("Invalid crop rect: t = %d (< 0)", sourceCrop.top);
3032    }
3033    if (sourceCrop.bottom > hw_h) {
3034        ALOGE("Invalid crop rect: b = %d (> %d)", sourceCrop.bottom, hw_h);
3035    }
3036
3037    // make sure to clear all GL error flags
3038    engine.checkErrors();
3039
3040    // set-up our viewport
3041    engine.setViewportAndProjection(reqWidth, reqHeight, sourceCrop, hw_h, yswap);
3042    engine.disableTexturing();
3043
3044    // redraw the screen entirely...
3045    engine.clearWithColor(0, 0, 0, 1);
3046
3047    const LayerVector& layers( mDrawingState.layersSortedByZ );
3048    const size_t count = layers.size();
3049    for (size_t i=0 ; i<count ; ++i) {
3050        const sp<Layer>& layer(layers[i]);
3051        const Layer::State& state(layer->getDrawingState());
3052        if (state.layerStack == hw->getLayerStack()) {
3053            if (state.z >= minLayerZ && state.z <= maxLayerZ) {
3054                if (layer->isVisible()) {
3055                    if (filtering) layer->setFiltering(true);
3056                    layer->draw(hw, useIdentityTransform);
3057                    if (filtering) layer->setFiltering(false);
3058                }
3059            }
3060        }
3061    }
3062
3063    // compositionComplete is needed for older driver
3064    hw->compositionComplete();
3065    hw->setViewportAndProjection();
3066}
3067
3068
3069status_t SurfaceFlinger::captureScreenImplLocked(
3070        const sp<const DisplayDevice>& hw,
3071        const sp<IGraphicBufferProducer>& producer,
3072        Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
3073        uint32_t minLayerZ, uint32_t maxLayerZ,
3074        bool useIdentityTransform)
3075{
3076    ATRACE_CALL();
3077
3078    // get screen geometry
3079    const uint32_t hw_w = hw->getWidth();
3080    const uint32_t hw_h = hw->getHeight();
3081
3082    if ((reqWidth > hw_w) || (reqHeight > hw_h)) {
3083        ALOGE("size mismatch (%d, %d) > (%d, %d)",
3084                reqWidth, reqHeight, hw_w, hw_h);
3085        return BAD_VALUE;
3086    }
3087
3088    reqWidth  = (!reqWidth)  ? hw_w : reqWidth;
3089    reqHeight = (!reqHeight) ? hw_h : reqHeight;
3090
3091    // create a surface (because we're a producer, and we need to
3092    // dequeue/queue a buffer)
3093    sp<Surface> sur = new Surface(producer, false);
3094    ANativeWindow* window = sur.get();
3095
3096    status_t result = NO_ERROR;
3097    if (native_window_api_connect(window, NATIVE_WINDOW_API_EGL) == NO_ERROR) {
3098        uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
3099                        GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
3100
3101        int err = 0;
3102        err = native_window_set_buffers_dimensions(window, reqWidth, reqHeight);
3103        err |= native_window_set_scaling_mode(window, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
3104        err |= native_window_set_buffers_format(window, HAL_PIXEL_FORMAT_RGBA_8888);
3105        err |= native_window_set_usage(window, usage);
3106
3107        if (err == NO_ERROR) {
3108            ANativeWindowBuffer* buffer;
3109            /* TODO: Once we have the sync framework everywhere this can use
3110             * server-side waits on the fence that dequeueBuffer returns.
3111             */
3112            result = native_window_dequeue_buffer_and_wait(window,  &buffer);
3113            if (result == NO_ERROR) {
3114                // create an EGLImage from the buffer so we can later
3115                // turn it into a texture
3116                EGLImageKHR image = eglCreateImageKHR(mEGLDisplay, EGL_NO_CONTEXT,
3117                        EGL_NATIVE_BUFFER_ANDROID, buffer, NULL);
3118                if (image != EGL_NO_IMAGE_KHR) {
3119                    // this binds the given EGLImage as a framebuffer for the
3120                    // duration of this scope.
3121                    RenderEngine::BindImageAsFramebuffer imageBond(getRenderEngine(), image);
3122                    if (imageBond.getStatus() == NO_ERROR) {
3123                        // this will in fact render into our dequeued buffer
3124                        // via an FBO, which means we didn't have to create
3125                        // an EGLSurface and therefore we're not
3126                        // dependent on the context's EGLConfig.
3127                        renderScreenImplLocked(hw, sourceCrop, reqWidth, reqHeight,
3128                                minLayerZ, maxLayerZ, true, useIdentityTransform);
3129
3130                        // Create a sync point and wait on it, so we know the buffer is
3131                        // ready before we pass it along.  We can't trivially call glFlush(),
3132                        // so we use a wait flag instead.
3133                        // TODO: pass a sync fd to queueBuffer() and let the consumer wait.
3134                        EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, NULL);
3135                        if (sync != EGL_NO_SYNC_KHR) {
3136                            EGLint result = eglClientWaitSyncKHR(mEGLDisplay, sync,
3137                                    EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, 2000000000 /*2 sec*/);
3138                            EGLint eglErr = eglGetError();
3139                            eglDestroySyncKHR(mEGLDisplay, sync);
3140                            if (result == EGL_TIMEOUT_EXPIRED_KHR) {
3141                                ALOGW("captureScreen: fence wait timed out");
3142                            } else {
3143                                ALOGW_IF(eglErr != EGL_SUCCESS,
3144                                        "captureScreen: error waiting on EGL fence: %#x", eglErr);
3145                            }
3146                        } else {
3147                            ALOGW("captureScreen: error creating EGL fence: %#x", eglGetError());
3148                            // not fatal
3149                        }
3150
3151                        if (DEBUG_SCREENSHOTS) {
3152                            uint32_t* pixels = new uint32_t[reqWidth*reqHeight];
3153                            getRenderEngine().readPixels(0, 0, reqWidth, reqHeight, pixels);
3154                            checkScreenshot(reqWidth, reqHeight, reqWidth, pixels,
3155                                    hw, minLayerZ, maxLayerZ);
3156                            delete [] pixels;
3157                        }
3158
3159                    } else {
3160                        ALOGE("got GL_FRAMEBUFFER_COMPLETE_OES error while taking screenshot");
3161                        result = INVALID_OPERATION;
3162                    }
3163                    // destroy our image
3164                    eglDestroyImageKHR(mEGLDisplay, image);
3165                } else {
3166                    result = BAD_VALUE;
3167                }
3168                window->queueBuffer(window, buffer, -1);
3169            }
3170        } else {
3171            result = BAD_VALUE;
3172        }
3173        native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
3174    }
3175
3176    return result;
3177}
3178
3179void SurfaceFlinger::checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
3180        const sp<const DisplayDevice>& hw, uint32_t minLayerZ, uint32_t maxLayerZ) {
3181    if (DEBUG_SCREENSHOTS) {
3182        for (size_t y=0 ; y<h ; y++) {
3183            uint32_t const * p = (uint32_t const *)vaddr + y*s;
3184            for (size_t x=0 ; x<w ; x++) {
3185                if (p[x] != 0xFF000000) return;
3186            }
3187        }
3188        ALOGE("*** we just took a black screenshot ***\n"
3189                "requested minz=%d, maxz=%d, layerStack=%d",
3190                minLayerZ, maxLayerZ, hw->getLayerStack());
3191        const LayerVector& layers( mDrawingState.layersSortedByZ );
3192        const size_t count = layers.size();
3193        for (size_t i=0 ; i<count ; ++i) {
3194            const sp<Layer>& layer(layers[i]);
3195            const Layer::State& state(layer->getDrawingState());
3196            const bool visible = (state.layerStack == hw->getLayerStack())
3197                                && (state.z >= minLayerZ && state.z <= maxLayerZ)
3198                                && (layer->isVisible());
3199            ALOGE("%c index=%zu, name=%s, layerStack=%d, z=%d, visible=%d, flags=%x, alpha=%x",
3200                    visible ? '+' : '-',
3201                            i, layer->getName().string(), state.layerStack, state.z,
3202                            layer->isVisible(), state.flags, state.alpha);
3203        }
3204    }
3205}
3206
3207// ---------------------------------------------------------------------------
3208
3209SurfaceFlinger::LayerVector::LayerVector() {
3210}
3211
3212SurfaceFlinger::LayerVector::LayerVector(const LayerVector& rhs)
3213    : SortedVector<sp<Layer> >(rhs) {
3214}
3215
3216int SurfaceFlinger::LayerVector::do_compare(const void* lhs,
3217    const void* rhs) const
3218{
3219    // sort layers per layer-stack, then by z-order and finally by sequence
3220    const sp<Layer>& l(*reinterpret_cast<const sp<Layer>*>(lhs));
3221    const sp<Layer>& r(*reinterpret_cast<const sp<Layer>*>(rhs));
3222
3223    uint32_t ls = l->getCurrentState().layerStack;
3224    uint32_t rs = r->getCurrentState().layerStack;
3225    if (ls != rs)
3226        return ls - rs;
3227
3228    uint32_t lz = l->getCurrentState().z;
3229    uint32_t rz = r->getCurrentState().z;
3230    if (lz != rz)
3231        return lz - rz;
3232
3233    return l->sequence - r->sequence;
3234}
3235
3236// ---------------------------------------------------------------------------
3237
3238SurfaceFlinger::DisplayDeviceState::DisplayDeviceState()
3239    : type(DisplayDevice::DISPLAY_ID_INVALID), width(0), height(0) {
3240}
3241
3242SurfaceFlinger::DisplayDeviceState::DisplayDeviceState(DisplayDevice::DisplayType type)
3243    : type(type), layerStack(DisplayDevice::NO_LAYER_STACK), orientation(0), width(0), height(0) {
3244    viewport.makeInvalid();
3245    frame.makeInvalid();
3246}
3247
3248// ---------------------------------------------------------------------------
3249
3250}; // namespace android
3251
3252
3253#if defined(__gl_h_)
3254#error "don't include gl/gl.h in this file"
3255#endif
3256
3257#if defined(__gl2_h_)
3258#error "don't include gl2/gl2.h in this file"
3259#endif
3260