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