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