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