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