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