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