SurfaceFlinger.cpp revision e6f0984361f634ff36bc0ad1c2d45f4554619ac8 
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#include <stdlib.h>
18#include <stdio.h>
19#include <stdint.h>
20#include <unistd.h>
21#include <fcntl.h>
22#include <errno.h>
23#include <math.h>
24#include <limits.h>
25#include <sys/types.h>
26#include <sys/stat.h>
27#include <sys/ioctl.h>
28
29#include <cutils/log.h>
30#include <cutils/properties.h>
31
32#include <binder/IPCThreadState.h>
33#include <binder/IServiceManager.h>
34#include <binder/MemoryHeapBase.h>
35
36#include <utils/String8.h>
37#include <utils/String16.h>
38#include <utils/StopWatch.h>
39
40#include <ui/GraphicBufferAllocator.h>
41#include <ui/GraphicLog.h>
42#include <ui/PixelFormat.h>
43
44#include <pixelflinger/pixelflinger.h>
45#include <GLES/gl.h>
46
47#include "clz.h"
48#include "GLExtensions.h"
49#include "Layer.h"
50#include "LayerDim.h"
51#include "SurfaceFlinger.h"
52
53#include "DisplayHardware/DisplayHardware.h"
54#include "DisplayHardware/HWComposer.h"
55
56/* ideally AID_GRAPHICS would be in a semi-public header
57 * or there would be a way to map a user/group name to its id
58 */
59#ifndef AID_GRAPHICS
60#define AID_GRAPHICS 1003
61#endif
62
63#define DISPLAY_COUNT       1
64
65namespace android {
66// ---------------------------------------------------------------------------
67
68SurfaceFlinger::SurfaceFlinger()
69    :   BnSurfaceComposer(), Thread(false),
70        mTransactionFlags(0),
71        mTransactionCount(0),
72        mResizeTransationPending(false),
73        mLayersRemoved(false),
74        mBootTime(systemTime()),
75        mHardwareTest("android.permission.HARDWARE_TEST"),
76        mAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER"),
77        mReadFramebuffer("android.permission.READ_FRAME_BUFFER"),
78        mDump("android.permission.DUMP"),
79        mVisibleRegionsDirty(false),
80        mHwWorkListDirty(false),
81        mDeferReleaseConsole(false),
82        mFreezeDisplay(false),
83        mElectronBeamAnimationMode(0),
84        mFreezeCount(0),
85        mFreezeDisplayTime(0),
86        mDebugRegion(0),
87        mDebugBackground(0),
88        mDebugDisableHWC(0),
89        mDebugInSwapBuffers(0),
90        mLastSwapBufferTime(0),
91        mDebugInTransaction(0),
92        mLastTransactionTime(0),
93        mBootFinished(false),
94        mConsoleSignals(0),
95        mSecureFrameBuffer(0)
96{
97    init();
98}
99
100void SurfaceFlinger::init()
101{
102    LOGI("SurfaceFlinger is starting");
103
104    // debugging stuff...
105    char value[PROPERTY_VALUE_MAX];
106    property_get("debug.sf.showupdates", value, "0");
107    mDebugRegion = atoi(value);
108    property_get("debug.sf.showbackground", value, "0");
109    mDebugBackground = atoi(value);
110
111    LOGI_IF(mDebugRegion,       "showupdates enabled");
112    LOGI_IF(mDebugBackground,   "showbackground enabled");
113}
114
115SurfaceFlinger::~SurfaceFlinger()
116{
117    glDeleteTextures(1, &mWormholeTexName);
118}
119
120sp<IMemoryHeap> SurfaceFlinger::getCblk() const
121{
122    return mServerHeap;
123}
124
125sp<ISurfaceComposerClient> SurfaceFlinger::createConnection()
126{
127    sp<ISurfaceComposerClient> bclient;
128    sp<Client> client(new Client(this));
129    status_t err = client->initCheck();
130    if (err == NO_ERROR) {
131        bclient = client;
132    }
133    return bclient;
134}
135
136sp<ISurfaceComposerClient> SurfaceFlinger::createClientConnection()
137{
138    sp<ISurfaceComposerClient> bclient;
139    sp<UserClient> client(new UserClient(this));
140    status_t err = client->initCheck();
141    if (err == NO_ERROR) {
142        bclient = client;
143    }
144    return bclient;
145}
146
147
148const GraphicPlane& SurfaceFlinger::graphicPlane(int dpy) const
149{
150    LOGE_IF(uint32_t(dpy) >= DISPLAY_COUNT, "Invalid DisplayID %d", dpy);
151    const GraphicPlane& plane(mGraphicPlanes[dpy]);
152    return plane;
153}
154
155GraphicPlane& SurfaceFlinger::graphicPlane(int dpy)
156{
157    return const_cast<GraphicPlane&>(
158        const_cast<SurfaceFlinger const *>(this)->graphicPlane(dpy));
159}
160
161void SurfaceFlinger::bootFinished()
162{
163    const nsecs_t now = systemTime();
164    const nsecs_t duration = now - mBootTime;
165    LOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
166    mBootFinished = true;
167    property_set("ctl.stop", "bootanim");
168}
169
170void SurfaceFlinger::onFirstRef()
171{
172    run("SurfaceFlinger", PRIORITY_URGENT_DISPLAY);
173
174    // Wait for the main thread to be done with its initialization
175    mReadyToRunBarrier.wait();
176}
177
178static inline uint16_t pack565(int r, int g, int b) {
179    return (r<<11)|(g<<5)|b;
180}
181
182status_t SurfaceFlinger::readyToRun()
183{
184    LOGI(   "SurfaceFlinger's main thread ready to run. "
185            "Initializing graphics H/W...");
186
187    // we only support one display currently
188    int dpy = 0;
189
190    {
191        // initialize the main display
192        GraphicPlane& plane(graphicPlane(dpy));
193        DisplayHardware* const hw = new DisplayHardware(this, dpy);
194        plane.setDisplayHardware(hw);
195    }
196
197    // create the shared control-block
198    mServerHeap = new MemoryHeapBase(4096,
199            MemoryHeapBase::READ_ONLY, "SurfaceFlinger read-only heap");
200    LOGE_IF(mServerHeap==0, "can't create shared memory dealer");
201
202    mServerCblk = static_cast<surface_flinger_cblk_t*>(mServerHeap->getBase());
203    LOGE_IF(mServerCblk==0, "can't get to shared control block's address");
204
205    new(mServerCblk) surface_flinger_cblk_t;
206
207    // initialize primary screen
208    // (other display should be initialized in the same manner, but
209    // asynchronously, as they could come and go. None of this is supported
210    // yet).
211    const GraphicPlane& plane(graphicPlane(dpy));
212    const DisplayHardware& hw = plane.displayHardware();
213    const uint32_t w = hw.getWidth();
214    const uint32_t h = hw.getHeight();
215    const uint32_t f = hw.getFormat();
216    hw.makeCurrent();
217
218    // initialize the shared control block
219    mServerCblk->connected |= 1<<dpy;
220    display_cblk_t* dcblk = mServerCblk->displays + dpy;
221    memset(dcblk, 0, sizeof(display_cblk_t));
222    dcblk->w            = plane.getWidth();
223    dcblk->h            = plane.getHeight();
224    dcblk->format       = f;
225    dcblk->orientation  = ISurfaceComposer::eOrientationDefault;
226    dcblk->xdpi         = hw.getDpiX();
227    dcblk->ydpi         = hw.getDpiY();
228    dcblk->fps          = hw.getRefreshRate();
229    dcblk->density      = hw.getDensity();
230
231    // Initialize OpenGL|ES
232    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
233    glPixelStorei(GL_PACK_ALIGNMENT, 4);
234    glEnableClientState(GL_VERTEX_ARRAY);
235    glEnable(GL_SCISSOR_TEST);
236    glShadeModel(GL_FLAT);
237    glDisable(GL_DITHER);
238    glDisable(GL_CULL_FACE);
239
240    const uint16_t g0 = pack565(0x0F,0x1F,0x0F);
241    const uint16_t g1 = pack565(0x17,0x2f,0x17);
242    const uint16_t textureData[4] = { g0, g1, g1, g0 };
243    glGenTextures(1, &mWormholeTexName);
244    glBindTexture(GL_TEXTURE_2D, mWormholeTexName);
245    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
246    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
247    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
248    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
249    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 2, 2, 0,
250            GL_RGB, GL_UNSIGNED_SHORT_5_6_5, textureData);
251
252    glViewport(0, 0, w, h);
253    glMatrixMode(GL_PROJECTION);
254    glLoadIdentity();
255    glOrthof(0, w, h, 0, 0, 1);
256
257   LayerDim::initDimmer(this, w, h);
258
259    mReadyToRunBarrier.open();
260
261    /*
262     *  We're now ready to accept clients...
263     */
264
265    // start boot animation
266    property_set("ctl.start", "bootanim");
267
268    return NO_ERROR;
269}
270
271// ----------------------------------------------------------------------------
272#if 0
273#pragma mark -
274#pragma mark Events Handler
275#endif
276
277void SurfaceFlinger::waitForEvent()
278{
279    while (true) {
280        nsecs_t timeout = -1;
281        const nsecs_t freezeDisplayTimeout = ms2ns(5000);
282        if (UNLIKELY(isFrozen())) {
283            // wait 5 seconds
284            const nsecs_t now = systemTime();
285            if (mFreezeDisplayTime == 0) {
286                mFreezeDisplayTime = now;
287            }
288            nsecs_t waitTime = freezeDisplayTimeout - (now - mFreezeDisplayTime);
289            timeout = waitTime>0 ? waitTime : 0;
290        }
291
292        sp<MessageBase> msg = mEventQueue.waitMessage(timeout);
293
294        // see if we timed out
295        if (isFrozen()) {
296            const nsecs_t now = systemTime();
297            nsecs_t frozenTime = (now - mFreezeDisplayTime);
298            if (frozenTime >= freezeDisplayTimeout) {
299                // we timed out and are still frozen
300                LOGW("timeout expired mFreezeDisplay=%d, mFreezeCount=%d",
301                        mFreezeDisplay, mFreezeCount);
302                mFreezeDisplayTime = 0;
303                mFreezeCount = 0;
304                mFreezeDisplay = false;
305            }
306        }
307
308        if (msg != 0) {
309            switch (msg->what) {
310                case MessageQueue::INVALIDATE:
311                    // invalidate message, just return to the main loop
312                    return;
313            }
314        }
315    }
316}
317
318void SurfaceFlinger::signalEvent() {
319    mEventQueue.invalidate();
320}
321
322void SurfaceFlinger::signal() const {
323    // this is the IPC call
324    const_cast<SurfaceFlinger*>(this)->signalEvent();
325}
326
327status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,
328        nsecs_t reltime, uint32_t flags)
329{
330    return mEventQueue.postMessage(msg, reltime, flags);
331}
332
333status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
334        nsecs_t reltime, uint32_t flags)
335{
336    status_t res = mEventQueue.postMessage(msg, reltime, flags);
337    if (res == NO_ERROR) {
338        msg->wait();
339    }
340    return res;
341}
342
343// ----------------------------------------------------------------------------
344#if 0
345#pragma mark -
346#pragma mark Main loop
347#endif
348
349bool SurfaceFlinger::threadLoop()
350{
351    waitForEvent();
352
353    // check for transactions
354    if (UNLIKELY(mConsoleSignals)) {
355        handleConsoleEvents();
356    }
357
358    if (LIKELY(mTransactionCount == 0)) {
359        // if we're in a global transaction, don't do anything.
360        const uint32_t mask = eTransactionNeeded | eTraversalNeeded;
361        uint32_t transactionFlags = getTransactionFlags(mask);
362        if (LIKELY(transactionFlags)) {
363            handleTransaction(transactionFlags);
364        }
365    }
366
367    // post surfaces (if needed)
368    handlePageFlip();
369
370    if (UNLIKELY(mHwWorkListDirty)) {
371        // build the h/w work list
372        handleWorkList();
373    }
374
375    const DisplayHardware& hw(graphicPlane(0).displayHardware());
376    if (LIKELY(hw.canDraw() && !isFrozen())) {
377        // repaint the framebuffer (if needed)
378
379        const int index = hw.getCurrentBufferIndex();
380        GraphicLog& logger(GraphicLog::getInstance());
381
382        logger.log(GraphicLog::SF_REPAINT, index);
383        handleRepaint();
384
385        // inform the h/w that we're done compositing
386        logger.log(GraphicLog::SF_COMPOSITION_COMPLETE, index);
387        hw.compositionComplete();
388
389        logger.log(GraphicLog::SF_SWAP_BUFFERS, index);
390        postFramebuffer();
391
392        logger.log(GraphicLog::SF_UNLOCK_CLIENTS, index);
393        unlockClients();
394
395        logger.log(GraphicLog::SF_REPAINT_DONE, index);
396    } else {
397        // pretend we did the post
398        hw.compositionComplete();
399        unlockClients();
400        usleep(16667); // 60 fps period
401    }
402    return true;
403}
404
405void SurfaceFlinger::postFramebuffer()
406{
407    if (!mInvalidRegion.isEmpty()) {
408        const DisplayHardware& hw(graphicPlane(0).displayHardware());
409        const nsecs_t now = systemTime();
410        mDebugInSwapBuffers = now;
411        hw.flip(mInvalidRegion);
412        mLastSwapBufferTime = systemTime() - now;
413        mDebugInSwapBuffers = 0;
414        mInvalidRegion.clear();
415    }
416}
417
418void SurfaceFlinger::handleConsoleEvents()
419{
420    // something to do with the console
421    const DisplayHardware& hw = graphicPlane(0).displayHardware();
422
423    int what = android_atomic_and(0, &mConsoleSignals);
424    if (what & eConsoleAcquired) {
425        hw.acquireScreen();
426        // this is a temporary work-around, eventually this should be called
427        // by the power-manager
428        SurfaceFlinger::turnElectronBeamOn(mElectronBeamAnimationMode);
429    }
430
431    if (mDeferReleaseConsole && hw.isScreenAcquired()) {
432        // We got the release signal before the acquire signal
433        mDeferReleaseConsole = false;
434        hw.releaseScreen();
435    }
436
437    if (what & eConsoleReleased) {
438        if (hw.isScreenAcquired()) {
439            hw.releaseScreen();
440        } else {
441            mDeferReleaseConsole = true;
442        }
443    }
444
445    mDirtyRegion.set(hw.bounds());
446}
447
448void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
449{
450    Vector< sp<LayerBase> > ditchedLayers;
451
452    /*
453     * Perform and commit the transaction
454     */
455
456    { // scope for the lock
457        Mutex::Autolock _l(mStateLock);
458        const nsecs_t now = systemTime();
459        mDebugInTransaction = now;
460        handleTransactionLocked(transactionFlags, ditchedLayers);
461        mLastTransactionTime = systemTime() - now;
462        mDebugInTransaction = 0;
463        mHwWorkListDirty = true;
464        // here the transaction has been committed
465    }
466
467    /*
468     * Clean-up all layers that went away
469     * (do this without the lock held)
470     */
471
472    const size_t count = ditchedLayers.size();
473    for (size_t i=0 ; i<count ; i++) {
474        if (ditchedLayers[i] != 0) {
475            //LOGD("ditching layer %p", ditchedLayers[i].get());
476            ditchedLayers[i]->ditch();
477        }
478    }
479}
480
481void SurfaceFlinger::handleTransactionLocked(
482        uint32_t transactionFlags, Vector< sp<LayerBase> >& ditchedLayers)
483{
484    const LayerVector& currentLayers(mCurrentState.layersSortedByZ);
485    const size_t count = currentLayers.size();
486
487    /*
488     * Traversal of the children
489     * (perform the transaction for each of them if needed)
490     */
491
492    const bool layersNeedTransaction = transactionFlags & eTraversalNeeded;
493    if (layersNeedTransaction) {
494        for (size_t i=0 ; i<count ; i++) {
495            const sp<LayerBase>& layer = currentLayers[i];
496            uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
497            if (!trFlags) continue;
498
499            const uint32_t flags = layer->doTransaction(0);
500            if (flags & Layer::eVisibleRegion)
501                mVisibleRegionsDirty = true;
502        }
503    }
504
505    /*
506     * Perform our own transaction if needed
507     */
508
509    if (transactionFlags & eTransactionNeeded) {
510        if (mCurrentState.orientation != mDrawingState.orientation) {
511            // the orientation has changed, recompute all visible regions
512            // and invalidate everything.
513
514            const int dpy = 0;
515            const int orientation = mCurrentState.orientation;
516            const uint32_t type = mCurrentState.orientationType;
517            GraphicPlane& plane(graphicPlane(dpy));
518            plane.setOrientation(orientation);
519
520            // update the shared control block
521            const DisplayHardware& hw(plane.displayHardware());
522            volatile display_cblk_t* dcblk = mServerCblk->displays + dpy;
523            dcblk->orientation = orientation;
524            dcblk->w = plane.getWidth();
525            dcblk->h = plane.getHeight();
526
527            mVisibleRegionsDirty = true;
528            mDirtyRegion.set(hw.bounds());
529        }
530
531        if (mCurrentState.freezeDisplay != mDrawingState.freezeDisplay) {
532            // freezing or unfreezing the display -> trigger animation if needed
533            mFreezeDisplay = mCurrentState.freezeDisplay;
534            if (mFreezeDisplay)
535                 mFreezeDisplayTime = 0;
536        }
537
538        if (currentLayers.size() > mDrawingState.layersSortedByZ.size()) {
539            // layers have been added
540            mVisibleRegionsDirty = true;
541        }
542
543        // some layers might have been removed, so
544        // we need to update the regions they're exposing.
545        if (mLayersRemoved) {
546            mLayersRemoved = false;
547            mVisibleRegionsDirty = true;
548            const LayerVector& previousLayers(mDrawingState.layersSortedByZ);
549            const size_t count = previousLayers.size();
550            for (size_t i=0 ; i<count ; i++) {
551                const sp<LayerBase>& layer(previousLayers[i]);
552                if (currentLayers.indexOf( layer ) < 0) {
553                    // this layer is not visible anymore
554                    ditchedLayers.add(layer);
555                    mDirtyRegionRemovedLayer.orSelf(layer->visibleRegionScreen);
556                }
557            }
558        }
559    }
560
561    commitTransaction();
562}
563
564sp<FreezeLock> SurfaceFlinger::getFreezeLock() const
565{
566    return new FreezeLock(const_cast<SurfaceFlinger *>(this));
567}
568
569void SurfaceFlinger::computeVisibleRegions(
570    LayerVector& currentLayers, Region& dirtyRegion, Region& opaqueRegion)
571{
572    const GraphicPlane& plane(graphicPlane(0));
573    const Transform& planeTransform(plane.transform());
574    const DisplayHardware& hw(plane.displayHardware());
575    const Region screenRegion(hw.bounds());
576
577    Region aboveOpaqueLayers;
578    Region aboveCoveredLayers;
579    Region dirty;
580
581    bool secureFrameBuffer = false;
582
583    size_t i = currentLayers.size();
584    while (i--) {
585        const sp<LayerBase>& layer = currentLayers[i];
586        layer->validateVisibility(planeTransform);
587
588        // start with the whole surface at its current location
589        const Layer::State& s(layer->drawingState());
590
591        /*
592         * opaqueRegion: area of a surface that is fully opaque.
593         */
594        Region opaqueRegion;
595
596        /*
597         * visibleRegion: area of a surface that is visible on screen
598         * and not fully transparent. This is essentially the layer's
599         * footprint minus the opaque regions above it.
600         * Areas covered by a translucent surface are considered visible.
601         */
602        Region visibleRegion;
603
604        /*
605         * coveredRegion: area of a surface that is covered by all
606         * visible regions above it (which includes the translucent areas).
607         */
608        Region coveredRegion;
609
610
611        // handle hidden surfaces by setting the visible region to empty
612        if (LIKELY(!(s.flags & ISurfaceComposer::eLayerHidden) && s.alpha)) {
613            const bool translucent = layer->needsBlending();
614            const Rect bounds(layer->visibleBounds());
615            visibleRegion.set(bounds);
616            visibleRegion.andSelf(screenRegion);
617            if (!visibleRegion.isEmpty()) {
618                // Remove the transparent area from the visible region
619                if (translucent) {
620                    visibleRegion.subtractSelf(layer->transparentRegionScreen);
621                }
622
623                // compute the opaque region
624                const int32_t layerOrientation = layer->getOrientation();
625                if (s.alpha==255 && !translucent &&
626                        ((layerOrientation & Transform::ROT_INVALID) == false)) {
627                    // the opaque region is the layer's footprint
628                    opaqueRegion = visibleRegion;
629                }
630            }
631        }
632
633        // Clip the covered region to the visible region
634        coveredRegion = aboveCoveredLayers.intersect(visibleRegion);
635
636        // Update aboveCoveredLayers for next (lower) layer
637        aboveCoveredLayers.orSelf(visibleRegion);
638
639        // subtract the opaque region covered by the layers above us
640        visibleRegion.subtractSelf(aboveOpaqueLayers);
641
642        // compute this layer's dirty region
643        if (layer->contentDirty) {
644            // we need to invalidate the whole region
645            dirty = visibleRegion;
646            // as well, as the old visible region
647            dirty.orSelf(layer->visibleRegionScreen);
648            layer->contentDirty = false;
649        } else {
650            /* compute the exposed region:
651             *   the exposed region consists of two components:
652             *   1) what's VISIBLE now and was COVERED before
653             *   2) what's EXPOSED now less what was EXPOSED before
654             *
655             * note that (1) is conservative, we start with the whole
656             * visible region but only keep what used to be covered by
657             * something -- which mean it may have been exposed.
658             *
659             * (2) handles areas that were not covered by anything but got
660             * exposed because of a resize.
661             */
662            const Region newExposed = visibleRegion - coveredRegion;
663            const Region oldVisibleRegion = layer->visibleRegionScreen;
664            const Region oldCoveredRegion = layer->coveredRegionScreen;
665            const Region oldExposed = oldVisibleRegion - oldCoveredRegion;
666            dirty = (visibleRegion&oldCoveredRegion) | (newExposed-oldExposed);
667        }
668        dirty.subtractSelf(aboveOpaqueLayers);
669
670        // accumulate to the screen dirty region
671        dirtyRegion.orSelf(dirty);
672
673        // Update aboveOpaqueLayers for next (lower) layer
674        aboveOpaqueLayers.orSelf(opaqueRegion);
675
676        // Store the visible region is screen space
677        layer->setVisibleRegion(visibleRegion);
678        layer->setCoveredRegion(coveredRegion);
679
680        // If a secure layer is partially visible, lock-down the screen!
681        if (layer->isSecure() && !visibleRegion.isEmpty()) {
682            secureFrameBuffer = true;
683        }
684    }
685
686    // invalidate the areas where a layer was removed
687    dirtyRegion.orSelf(mDirtyRegionRemovedLayer);
688    mDirtyRegionRemovedLayer.clear();
689
690    mSecureFrameBuffer = secureFrameBuffer;
691    opaqueRegion = aboveOpaqueLayers;
692}
693
694
695void SurfaceFlinger::commitTransaction()
696{
697    mDrawingState = mCurrentState;
698    mResizeTransationPending = false;
699    mTransactionCV.broadcast();
700}
701
702void SurfaceFlinger::handlePageFlip()
703{
704    bool visibleRegions = mVisibleRegionsDirty;
705    LayerVector& currentLayers(
706            const_cast<LayerVector&>(mDrawingState.layersSortedByZ));
707    visibleRegions |= lockPageFlip(currentLayers);
708
709        const DisplayHardware& hw = graphicPlane(0).displayHardware();
710        const Region screenRegion(hw.bounds());
711        if (visibleRegions) {
712            Region opaqueRegion;
713            computeVisibleRegions(currentLayers, mDirtyRegion, opaqueRegion);
714
715            /*
716             *  rebuild the visible layer list
717             */
718            mVisibleLayersSortedByZ.clear();
719            const LayerVector& currentLayers(mDrawingState.layersSortedByZ);
720            size_t count = currentLayers.size();
721            mVisibleLayersSortedByZ.setCapacity(count);
722            for (size_t i=0 ; i<count ; i++) {
723                if (!currentLayers[i]->visibleRegionScreen.isEmpty())
724                    mVisibleLayersSortedByZ.add(currentLayers[i]);
725            }
726
727            mWormholeRegion = screenRegion.subtract(opaqueRegion);
728            mVisibleRegionsDirty = false;
729            mHwWorkListDirty = true;
730        }
731
732    unlockPageFlip(currentLayers);
733    mDirtyRegion.andSelf(screenRegion);
734}
735
736bool SurfaceFlinger::lockPageFlip(const LayerVector& currentLayers)
737{
738    bool recomputeVisibleRegions = false;
739    size_t count = currentLayers.size();
740    sp<LayerBase> const* layers = currentLayers.array();
741    for (size_t i=0 ; i<count ; i++) {
742        const sp<LayerBase>& layer(layers[i]);
743        layer->lockPageFlip(recomputeVisibleRegions);
744    }
745    return recomputeVisibleRegions;
746}
747
748void SurfaceFlinger::unlockPageFlip(const LayerVector& currentLayers)
749{
750    const GraphicPlane& plane(graphicPlane(0));
751    const Transform& planeTransform(plane.transform());
752    size_t count = currentLayers.size();
753    sp<LayerBase> const* layers = currentLayers.array();
754    for (size_t i=0 ; i<count ; i++) {
755        const sp<LayerBase>& layer(layers[i]);
756        layer->unlockPageFlip(planeTransform, mDirtyRegion);
757    }
758}
759
760void SurfaceFlinger::handleWorkList()
761{
762    mHwWorkListDirty = false;
763    HWComposer& hwc(graphicPlane(0).displayHardware().getHwComposer());
764    if (hwc.initCheck() == NO_ERROR) {
765        const Vector< sp<LayerBase> >& currentLayers(mVisibleLayersSortedByZ);
766        const size_t count = currentLayers.size();
767        hwc.createWorkList(count);
768        hwc_layer_t* const cur(hwc.getLayers());
769        for (size_t i=0 ; cur && i<count ; i++) {
770            currentLayers[i]->setGeometry(&cur[i]);
771            if (mDebugDisableHWC) {
772                cur[i].compositionType = HWC_FRAMEBUFFER;
773                cur[i].flags |= HWC_SKIP_LAYER;
774            }
775        }
776    }
777}
778
779void SurfaceFlinger::handleRepaint()
780{
781    // compute the invalid region
782    mInvalidRegion.orSelf(mDirtyRegion);
783
784    if (UNLIKELY(mDebugRegion)) {
785        debugFlashRegions();
786    }
787
788    // set the frame buffer
789    const DisplayHardware& hw(graphicPlane(0).displayHardware());
790    glMatrixMode(GL_MODELVIEW);
791    glLoadIdentity();
792
793    uint32_t flags = hw.getFlags();
794    if ((flags & DisplayHardware::SWAP_RECTANGLE) ||
795        (flags & DisplayHardware::BUFFER_PRESERVED))
796    {
797        // we can redraw only what's dirty, but since SWAP_RECTANGLE only
798        // takes a rectangle, we must make sure to update that whole
799        // rectangle in that case
800        if (flags & DisplayHardware::SWAP_RECTANGLE) {
801            // TODO: we really should be able to pass a region to
802            // SWAP_RECTANGLE so that we don't have to redraw all this.
803            mDirtyRegion.set(mInvalidRegion.bounds());
804        } else {
805            // in the BUFFER_PRESERVED case, obviously, we can update only
806            // what's needed and nothing more.
807            // NOTE: this is NOT a common case, as preserving the backbuffer
808            // is costly and usually involves copying the whole update back.
809        }
810    } else {
811        if (flags & DisplayHardware::PARTIAL_UPDATES) {
812            // We need to redraw the rectangle that will be updated
813            // (pushed to the framebuffer).
814            // This is needed because PARTIAL_UPDATES only takes one
815            // rectangle instead of a region (see DisplayHardware::flip())
816            mDirtyRegion.set(mInvalidRegion.bounds());
817        } else {
818            // we need to redraw everything (the whole screen)
819            mDirtyRegion.set(hw.bounds());
820            mInvalidRegion = mDirtyRegion;
821        }
822    }
823
824    // compose all surfaces
825    composeSurfaces(mDirtyRegion);
826
827    // clear the dirty regions
828    mDirtyRegion.clear();
829}
830
831void SurfaceFlinger::composeSurfaces(const Region& dirty)
832{
833    if (UNLIKELY(!mWormholeRegion.isEmpty())) {
834        // should never happen unless the window manager has a bug
835        // draw something...
836        drawWormhole();
837    }
838
839    status_t err = NO_ERROR;
840    const Vector< sp<LayerBase> >& layers(mVisibleLayersSortedByZ);
841    size_t count = layers.size();
842
843    const DisplayHardware& hw(graphicPlane(0).displayHardware());
844    HWComposer& hwc(hw.getHwComposer());
845    hwc_layer_t* const cur(hwc.getLayers());
846
847    LOGE_IF(cur && hwc.getNumLayers() != count,
848            "HAL number of layers (%d) doesn't match surfaceflinger (%d)",
849            hwc.getNumLayers(), count);
850
851    // just to be extra-safe, use the smallest count
852    if (hwc.initCheck() == NO_ERROR) {
853        count = count < hwc.getNumLayers() ? count : hwc.getNumLayers();
854    }
855
856    /*
857     *  update the per-frame h/w composer data for each layer
858     *  and build the transparent region of the FB
859     */
860    Region transparent;
861    if (cur) {
862        for (size_t i=0 ; i<count ; i++) {
863            const sp<LayerBase>& layer(layers[i]);
864            layer->setPerFrameData(&cur[i]);
865            if (cur[i].hints & HWC_HINT_CLEAR_FB) {
866                if (!(layer->needsBlending())) {
867                    transparent.orSelf(layer->visibleRegionScreen);
868                }
869            }
870        }
871        err = hwc.prepare();
872        LOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
873    }
874
875    /*
876     *  clear the area of the FB that need to be transparent
877     */
878    transparent.andSelf(dirty);
879    if (!transparent.isEmpty()) {
880        glClearColor(0,0,0,0);
881        Region::const_iterator it = transparent.begin();
882        Region::const_iterator const end = transparent.end();
883        const int32_t height = hw.getHeight();
884        while (it != end) {
885            const Rect& r(*it++);
886            const GLint sy = height - (r.top + r.height());
887            glScissor(r.left, sy, r.width(), r.height());
888            glClear(GL_COLOR_BUFFER_BIT);
889        }
890    }
891
892
893    /*
894     * and then, render the layers targeted at the framebuffer
895     */
896    for (size_t i=0 ; i<count ; i++) {
897        if (cur) {
898            if ((cur[i].compositionType != HWC_FRAMEBUFFER) &&
899                !(cur[i].flags & HWC_SKIP_LAYER)) {
900                // skip layers handled by the HAL
901                continue;
902            }
903        }
904
905        const sp<LayerBase>& layer(layers[i]);
906        const Region clip(dirty.intersect(layer->visibleRegionScreen));
907        if (!clip.isEmpty()) {
908            layer->draw(clip);
909        }
910    }
911}
912
913void SurfaceFlinger::unlockClients()
914{
915    const LayerVector& drawingLayers(mDrawingState.layersSortedByZ);
916    const size_t count = drawingLayers.size();
917    sp<LayerBase> const* const layers = drawingLayers.array();
918    for (size_t i=0 ; i<count ; ++i) {
919        const sp<LayerBase>& layer = layers[i];
920        layer->finishPageFlip();
921    }
922}
923
924void SurfaceFlinger::debugFlashRegions()
925{
926    const DisplayHardware& hw(graphicPlane(0).displayHardware());
927    const uint32_t flags = hw.getFlags();
928
929    if (!((flags & DisplayHardware::SWAP_RECTANGLE) ||
930            (flags & DisplayHardware::BUFFER_PRESERVED))) {
931        const Region repaint((flags & DisplayHardware::PARTIAL_UPDATES) ?
932                mDirtyRegion.bounds() : hw.bounds());
933        composeSurfaces(repaint);
934    }
935
936    TextureManager::deactivateTextures();
937
938    glDisable(GL_BLEND);
939    glDisable(GL_DITHER);
940    glDisable(GL_SCISSOR_TEST);
941
942    static int toggle = 0;
943    toggle = 1 - toggle;
944    if (toggle) {
945        glColor4f(1, 0, 1, 1);
946    } else {
947        glColor4f(1, 1, 0, 1);
948    }
949
950    Region::const_iterator it = mDirtyRegion.begin();
951    Region::const_iterator const end = mDirtyRegion.end();
952    while (it != end) {
953        const Rect& r = *it++;
954        GLfloat vertices[][2] = {
955                { r.left,  r.top },
956                { r.left,  r.bottom },
957                { r.right, r.bottom },
958                { r.right, r.top }
959        };
960        glVertexPointer(2, GL_FLOAT, 0, vertices);
961        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
962    }
963
964    if (mInvalidRegion.isEmpty()) {
965        mDirtyRegion.dump("mDirtyRegion");
966        mInvalidRegion.dump("mInvalidRegion");
967    }
968    hw.flip(mInvalidRegion);
969
970    if (mDebugRegion > 1)
971        usleep(mDebugRegion * 1000);
972
973    glEnable(GL_SCISSOR_TEST);
974    //mDirtyRegion.dump("mDirtyRegion");
975}
976
977void SurfaceFlinger::drawWormhole() const
978{
979    const Region region(mWormholeRegion.intersect(mDirtyRegion));
980    if (region.isEmpty())
981        return;
982
983    const DisplayHardware& hw(graphicPlane(0).displayHardware());
984    const int32_t width = hw.getWidth();
985    const int32_t height = hw.getHeight();
986
987    glDisable(GL_BLEND);
988    glDisable(GL_DITHER);
989
990    if (LIKELY(!mDebugBackground)) {
991        glClearColor(0,0,0,0);
992        Region::const_iterator it = region.begin();
993        Region::const_iterator const end = region.end();
994        while (it != end) {
995            const Rect& r = *it++;
996            const GLint sy = height - (r.top + r.height());
997            glScissor(r.left, sy, r.width(), r.height());
998            glClear(GL_COLOR_BUFFER_BIT);
999        }
1000    } else {
1001        const GLshort vertices[][2] = { { 0, 0 }, { width, 0 },
1002                { width, height }, { 0, height }  };
1003        const GLshort tcoords[][2] = { { 0, 0 }, { 1, 0 },  { 1, 1 }, { 0, 1 } };
1004        glVertexPointer(2, GL_SHORT, 0, vertices);
1005        glTexCoordPointer(2, GL_SHORT, 0, tcoords);
1006        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1007#if defined(GL_OES_EGL_image_external)
1008        if (GLExtensions::getInstance().haveTextureExternal()) {
1009            glDisable(GL_TEXTURE_EXTERNAL_OES);
1010        }
1011#endif
1012        glEnable(GL_TEXTURE_2D);
1013        glBindTexture(GL_TEXTURE_2D, mWormholeTexName);
1014        glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1015        glMatrixMode(GL_TEXTURE);
1016        glLoadIdentity();
1017        glScalef(width*(1.0f/32.0f), height*(1.0f/32.0f), 1);
1018        Region::const_iterator it = region.begin();
1019        Region::const_iterator const end = region.end();
1020        while (it != end) {
1021            const Rect& r = *it++;
1022            const GLint sy = height - (r.top + r.height());
1023            glScissor(r.left, sy, r.width(), r.height());
1024            glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1025        }
1026        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1027        glLoadIdentity();
1028        glMatrixMode(GL_MODELVIEW);
1029    }
1030}
1031
1032void SurfaceFlinger::debugShowFPS() const
1033{
1034    static int mFrameCount;
1035    static int mLastFrameCount = 0;
1036    static nsecs_t mLastFpsTime = 0;
1037    static float mFps = 0;
1038    mFrameCount++;
1039    nsecs_t now = systemTime();
1040    nsecs_t diff = now - mLastFpsTime;
1041    if (diff > ms2ns(250)) {
1042        mFps =  ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
1043        mLastFpsTime = now;
1044        mLastFrameCount = mFrameCount;
1045    }
1046    // XXX: mFPS has the value we want
1047 }
1048
1049status_t SurfaceFlinger::addLayer(const sp<LayerBase>& layer)
1050{
1051    Mutex::Autolock _l(mStateLock);
1052    addLayer_l(layer);
1053    setTransactionFlags(eTransactionNeeded|eTraversalNeeded);
1054    return NO_ERROR;
1055}
1056
1057status_t SurfaceFlinger::addLayer_l(const sp<LayerBase>& layer)
1058{
1059    ssize_t i = mCurrentState.layersSortedByZ.add(layer);
1060    return (i < 0) ? status_t(i) : status_t(NO_ERROR);
1061}
1062
1063ssize_t SurfaceFlinger::addClientLayer(const sp<Client>& client,
1064        const sp<LayerBaseClient>& lbc)
1065{
1066    Mutex::Autolock _l(mStateLock);
1067
1068    // attach this layer to the client
1069    ssize_t name = client->attachLayer(lbc);
1070
1071    // add this layer to the current state list
1072    addLayer_l(lbc);
1073
1074    return name;
1075}
1076
1077status_t SurfaceFlinger::removeLayer(const sp<LayerBase>& layer)
1078{
1079    Mutex::Autolock _l(mStateLock);
1080    status_t err = purgatorizeLayer_l(layer);
1081    if (err == NO_ERROR)
1082        setTransactionFlags(eTransactionNeeded);
1083    return err;
1084}
1085
1086status_t SurfaceFlinger::removeLayer_l(const sp<LayerBase>& layerBase)
1087{
1088    sp<LayerBaseClient> lbc(layerBase->getLayerBaseClient());
1089    if (lbc != 0) {
1090        mLayerMap.removeItem( lbc->getSurface()->asBinder() );
1091    }
1092    ssize_t index = mCurrentState.layersSortedByZ.remove(layerBase);
1093    if (index >= 0) {
1094        mLayersRemoved = true;
1095        return NO_ERROR;
1096    }
1097    return status_t(index);
1098}
1099
1100status_t SurfaceFlinger::purgatorizeLayer_l(const sp<LayerBase>& layerBase)
1101{
1102    // remove the layer from the main list (through a transaction).
1103    ssize_t err = removeLayer_l(layerBase);
1104
1105    layerBase->onRemoved();
1106
1107    // it's possible that we don't find a layer, because it might
1108    // have been destroyed already -- this is not technically an error
1109    // from the user because there is a race between Client::destroySurface(),
1110    // ~Client() and ~ISurface().
1111    return (err == NAME_NOT_FOUND) ? status_t(NO_ERROR) : err;
1112}
1113
1114status_t SurfaceFlinger::invalidateLayerVisibility(const sp<LayerBase>& layer)
1115{
1116    layer->forceVisibilityTransaction();
1117    setTransactionFlags(eTraversalNeeded);
1118    return NO_ERROR;
1119}
1120
1121uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags)
1122{
1123    return android_atomic_and(~flags, &mTransactionFlags) & flags;
1124}
1125
1126uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags)
1127{
1128    uint32_t old = android_atomic_or(flags, &mTransactionFlags);
1129    if ((old & flags)==0) { // wake the server up
1130        signalEvent();
1131    }
1132    return old;
1133}
1134
1135void SurfaceFlinger::openGlobalTransaction()
1136{
1137    android_atomic_inc(&mTransactionCount);
1138}
1139
1140void SurfaceFlinger::closeGlobalTransaction()
1141{
1142    if (android_atomic_dec(&mTransactionCount) == 1) {
1143        signalEvent();
1144
1145        // if there is a transaction with a resize, wait for it to
1146        // take effect before returning.
1147        Mutex::Autolock _l(mStateLock);
1148        while (mResizeTransationPending) {
1149            status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
1150            if (CC_UNLIKELY(err != NO_ERROR)) {
1151                // just in case something goes wrong in SF, return to the
1152                // called after a few seconds.
1153                LOGW_IF(err == TIMED_OUT, "closeGlobalTransaction timed out!");
1154                mResizeTransationPending = false;
1155                break;
1156            }
1157        }
1158    }
1159}
1160
1161status_t SurfaceFlinger::freezeDisplay(DisplayID dpy, uint32_t flags)
1162{
1163    if (UNLIKELY(uint32_t(dpy) >= DISPLAY_COUNT))
1164        return BAD_VALUE;
1165
1166    Mutex::Autolock _l(mStateLock);
1167    mCurrentState.freezeDisplay = 1;
1168    setTransactionFlags(eTransactionNeeded);
1169
1170    // flags is intended to communicate some sort of animation behavior
1171    // (for instance fading)
1172    return NO_ERROR;
1173}
1174
1175status_t SurfaceFlinger::unfreezeDisplay(DisplayID dpy, uint32_t flags)
1176{
1177    if (UNLIKELY(uint32_t(dpy) >= DISPLAY_COUNT))
1178        return BAD_VALUE;
1179
1180    Mutex::Autolock _l(mStateLock);
1181    mCurrentState.freezeDisplay = 0;
1182    setTransactionFlags(eTransactionNeeded);
1183
1184    // flags is intended to communicate some sort of animation behavior
1185    // (for instance fading)
1186    return NO_ERROR;
1187}
1188
1189int SurfaceFlinger::setOrientation(DisplayID dpy,
1190        int orientation, uint32_t flags)
1191{
1192    if (UNLIKELY(uint32_t(dpy) >= DISPLAY_COUNT))
1193        return BAD_VALUE;
1194
1195    Mutex::Autolock _l(mStateLock);
1196    if (mCurrentState.orientation != orientation) {
1197        if (uint32_t(orientation)<=eOrientation270 || orientation==42) {
1198            mCurrentState.orientationType = flags;
1199            mCurrentState.orientation = orientation;
1200            setTransactionFlags(eTransactionNeeded);
1201            mTransactionCV.wait(mStateLock);
1202        } else {
1203            orientation = BAD_VALUE;
1204        }
1205    }
1206    return orientation;
1207}
1208
1209sp<ISurface> SurfaceFlinger::createSurface(const sp<Client>& client, int pid,
1210        const String8& name, ISurfaceComposerClient::surface_data_t* params,
1211        DisplayID d, uint32_t w, uint32_t h, PixelFormat format,
1212        uint32_t flags)
1213{
1214    sp<LayerBaseClient> layer;
1215    sp<LayerBaseClient::Surface> surfaceHandle;
1216
1217    if (int32_t(w|h) < 0) {
1218        LOGE("createSurface() failed, w or h is negative (w=%d, h=%d)",
1219                int(w), int(h));
1220        return surfaceHandle;
1221    }
1222
1223    //LOGD("createSurface for pid %d (%d x %d)", pid, w, h);
1224    sp<Layer> normalLayer;
1225    switch (flags & eFXSurfaceMask) {
1226        case eFXSurfaceNormal:
1227            normalLayer = createNormalSurface(client, d, w, h, flags, format);
1228            layer = normalLayer;
1229            break;
1230        case eFXSurfaceBlur:
1231            // for now we treat Blur as Dim, until we can implement it
1232            // efficiently.
1233        case eFXSurfaceDim:
1234            layer = createDimSurface(client, d, w, h, flags);
1235            break;
1236    }
1237
1238    if (layer != 0) {
1239        layer->initStates(w, h, flags);
1240        layer->setName(name);
1241        ssize_t token = addClientLayer(client, layer);
1242
1243        surfaceHandle = layer->getSurface();
1244        if (surfaceHandle != 0) {
1245            params->token = token;
1246            params->identity = surfaceHandle->getIdentity();
1247            params->width = w;
1248            params->height = h;
1249            params->format = format;
1250            if (normalLayer != 0) {
1251                Mutex::Autolock _l(mStateLock);
1252                mLayerMap.add(surfaceHandle->asBinder(), normalLayer);
1253            }
1254        }
1255
1256        setTransactionFlags(eTransactionNeeded);
1257    }
1258
1259    return surfaceHandle;
1260}
1261
1262sp<Layer> SurfaceFlinger::createNormalSurface(
1263        const sp<Client>& client, DisplayID display,
1264        uint32_t w, uint32_t h, uint32_t flags,
1265        PixelFormat& format)
1266{
1267    // initialize the surfaces
1268    switch (format) { // TODO: take h/w into account
1269    case PIXEL_FORMAT_TRANSPARENT:
1270    case PIXEL_FORMAT_TRANSLUCENT:
1271        format = PIXEL_FORMAT_RGBA_8888;
1272        break;
1273    case PIXEL_FORMAT_OPAQUE:
1274#ifdef NO_RGBX_8888
1275        format = PIXEL_FORMAT_RGB_565;
1276#else
1277        format = PIXEL_FORMAT_RGBX_8888;
1278#endif
1279        break;
1280    }
1281
1282#ifdef NO_RGBX_8888
1283    if (format == PIXEL_FORMAT_RGBX_8888)
1284        format = PIXEL_FORMAT_RGBA_8888;
1285#endif
1286
1287    sp<Layer> layer = new Layer(this, display, client);
1288    status_t err = layer->setBuffers(w, h, format, flags);
1289    if (LIKELY(err != NO_ERROR)) {
1290        LOGE("createNormalSurfaceLocked() failed (%s)", strerror(-err));
1291        layer.clear();
1292    }
1293    return layer;
1294}
1295
1296sp<LayerDim> SurfaceFlinger::createDimSurface(
1297        const sp<Client>& client, DisplayID display,
1298        uint32_t w, uint32_t h, uint32_t flags)
1299{
1300    sp<LayerDim> layer = new LayerDim(this, display, client);
1301    layer->initStates(w, h, flags);
1302    return layer;
1303}
1304
1305status_t SurfaceFlinger::removeSurface(const sp<Client>& client, SurfaceID sid)
1306{
1307    /*
1308     * called by the window manager, when a surface should be marked for
1309     * destruction.
1310     *
1311     * The surface is removed from the current and drawing lists, but placed
1312     * in the purgatory queue, so it's not destroyed right-away (we need
1313     * to wait for all client's references to go away first).
1314     */
1315
1316    status_t err = NAME_NOT_FOUND;
1317    Mutex::Autolock _l(mStateLock);
1318    sp<LayerBaseClient> layer = client->getLayerUser(sid);
1319    if (layer != 0) {
1320        err = purgatorizeLayer_l(layer);
1321        if (err == NO_ERROR) {
1322            setTransactionFlags(eTransactionNeeded);
1323        }
1324    }
1325    return err;
1326}
1327
1328status_t SurfaceFlinger::destroySurface(const sp<LayerBaseClient>& layer)
1329{
1330    // called by ~ISurface() when all references are gone
1331
1332    class MessageDestroySurface : public MessageBase {
1333        SurfaceFlinger* flinger;
1334        sp<LayerBaseClient> layer;
1335    public:
1336        MessageDestroySurface(
1337                SurfaceFlinger* flinger, const sp<LayerBaseClient>& layer)
1338            : flinger(flinger), layer(layer) { }
1339        virtual bool handler() {
1340            sp<LayerBaseClient> l(layer);
1341            layer.clear(); // clear it outside of the lock;
1342            Mutex::Autolock _l(flinger->mStateLock);
1343            /*
1344             * remove the layer from the current list -- chances are that it's
1345             * not in the list anyway, because it should have been removed
1346             * already upon request of the client (eg: window manager).
1347             * However, a buggy client could have not done that.
1348             * Since we know we don't have any more clients, we don't need
1349             * to use the purgatory.
1350             */
1351            status_t err = flinger->removeLayer_l(l);
1352            LOGE_IF(err<0 && err != NAME_NOT_FOUND,
1353                    "error removing layer=%p (%s)", l.get(), strerror(-err));
1354            return true;
1355        }
1356    };
1357
1358    postMessageAsync( new MessageDestroySurface(this, layer) );
1359    return NO_ERROR;
1360}
1361
1362status_t SurfaceFlinger::setClientState(
1363        const sp<Client>& client,
1364        int32_t count,
1365        const layer_state_t* states)
1366{
1367    Mutex::Autolock _l(mStateLock);
1368    uint32_t flags = 0;
1369    for (int i=0 ; i<count ; i++) {
1370        const layer_state_t& s(states[i]);
1371        sp<LayerBaseClient> layer(client->getLayerUser(s.surface));
1372        if (layer != 0) {
1373            const uint32_t what = s.what;
1374            if (what & ePositionChanged) {
1375                if (layer->setPosition(s.x, s.y))
1376                    flags |= eTraversalNeeded;
1377            }
1378            if (what & eLayerChanged) {
1379                ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
1380                if (layer->setLayer(s.z)) {
1381                    mCurrentState.layersSortedByZ.removeAt(idx);
1382                    mCurrentState.layersSortedByZ.add(layer);
1383                    // we need traversal (state changed)
1384                    // AND transaction (list changed)
1385                    flags |= eTransactionNeeded|eTraversalNeeded;
1386                }
1387            }
1388            if (what & eSizeChanged) {
1389                if (layer->setSize(s.w, s.h)) {
1390                    flags |= eTraversalNeeded;
1391                    mResizeTransationPending = true;
1392                }
1393            }
1394            if (what & eAlphaChanged) {
1395                if (layer->setAlpha(uint8_t(255.0f*s.alpha+0.5f)))
1396                    flags |= eTraversalNeeded;
1397            }
1398            if (what & eMatrixChanged) {
1399                if (layer->setMatrix(s.matrix))
1400                    flags |= eTraversalNeeded;
1401            }
1402            if (what & eTransparentRegionChanged) {
1403                if (layer->setTransparentRegionHint(s.transparentRegion))
1404                    flags |= eTraversalNeeded;
1405            }
1406            if (what & eVisibilityChanged) {
1407                if (layer->setFlags(s.flags, s.mask))
1408                    flags |= eTraversalNeeded;
1409            }
1410        }
1411    }
1412    if (flags) {
1413        setTransactionFlags(flags);
1414    }
1415    return NO_ERROR;
1416}
1417
1418void SurfaceFlinger::screenReleased(int dpy)
1419{
1420    // this may be called by a signal handler, we can't do too much in here
1421    android_atomic_or(eConsoleReleased, &mConsoleSignals);
1422    signalEvent();
1423}
1424
1425void SurfaceFlinger::screenAcquired(int dpy)
1426{
1427    // this may be called by a signal handler, we can't do too much in here
1428    android_atomic_or(eConsoleAcquired, &mConsoleSignals);
1429    signalEvent();
1430}
1431
1432status_t SurfaceFlinger::dump(int fd, const Vector<String16>& args)
1433{
1434    const size_t SIZE = 4096;
1435    char buffer[SIZE];
1436    String8 result;
1437    if (!mDump.checkCalling()) {
1438        snprintf(buffer, SIZE, "Permission Denial: "
1439                "can't dump SurfaceFlinger from pid=%d, uid=%d\n",
1440                IPCThreadState::self()->getCallingPid(),
1441                IPCThreadState::self()->getCallingUid());
1442        result.append(buffer);
1443    } else {
1444
1445        // figure out if we're stuck somewhere
1446        const nsecs_t now = systemTime();
1447        const nsecs_t inSwapBuffers(mDebugInSwapBuffers);
1448        const nsecs_t inTransaction(mDebugInTransaction);
1449        nsecs_t inSwapBuffersDuration = (inSwapBuffers) ? now-inSwapBuffers : 0;
1450        nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
1451
1452        // Try to get the main lock, but don't insist if we can't
1453        // (this would indicate SF is stuck, but we want to be able to
1454        // print something in dumpsys).
1455        int retry = 3;
1456        while (mStateLock.tryLock()<0 && --retry>=0) {
1457            usleep(1000000);
1458        }
1459        const bool locked(retry >= 0);
1460        if (!locked) {
1461            snprintf(buffer, SIZE,
1462                    "SurfaceFlinger appears to be unresponsive, "
1463                    "dumping anyways (no locks held)\n");
1464            result.append(buffer);
1465        }
1466
1467        const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
1468        const size_t count = currentLayers.size();
1469        for (size_t i=0 ; i<count ; i++) {
1470            const sp<LayerBase>& layer(currentLayers[i]);
1471            layer->dump(result, buffer, SIZE);
1472            const Layer::State& s(layer->drawingState());
1473            s.transparentRegion.dump(result, "transparentRegion");
1474            layer->transparentRegionScreen.dump(result, "transparentRegionScreen");
1475            layer->visibleRegionScreen.dump(result, "visibleRegionScreen");
1476        }
1477
1478        mWormholeRegion.dump(result, "WormholeRegion");
1479        const DisplayHardware& hw(graphicPlane(0).displayHardware());
1480        snprintf(buffer, SIZE,
1481                "  display frozen: %s, freezeCount=%d, orientation=%d, canDraw=%d\n",
1482                mFreezeDisplay?"yes":"no", mFreezeCount,
1483                mCurrentState.orientation, hw.canDraw());
1484        result.append(buffer);
1485        snprintf(buffer, SIZE,
1486                "  last eglSwapBuffers() time: %f us\n"
1487                "  last transaction time     : %f us\n",
1488                mLastSwapBufferTime/1000.0, mLastTransactionTime/1000.0);
1489        result.append(buffer);
1490
1491        if (inSwapBuffersDuration || !locked) {
1492            snprintf(buffer, SIZE, "  eglSwapBuffers time: %f us\n",
1493                    inSwapBuffersDuration/1000.0);
1494            result.append(buffer);
1495        }
1496
1497        if (inTransactionDuration || !locked) {
1498            snprintf(buffer, SIZE, "  transaction time: %f us\n",
1499                    inTransactionDuration/1000.0);
1500            result.append(buffer);
1501        }
1502
1503        HWComposer& hwc(hw.getHwComposer());
1504        snprintf(buffer, SIZE, "  h/w composer %s and %s\n",
1505                hwc.initCheck()==NO_ERROR ? "present" : "not present",
1506                mDebugDisableHWC ? "disabled" : "enabled");
1507        result.append(buffer);
1508        hwc.dump(result, buffer, SIZE);
1509
1510        const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
1511        alloc.dump(result);
1512        hw.dump(result);
1513
1514        if (locked) {
1515            mStateLock.unlock();
1516        }
1517    }
1518    write(fd, result.string(), result.size());
1519    return NO_ERROR;
1520}
1521
1522status_t SurfaceFlinger::onTransact(
1523    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
1524{
1525    switch (code) {
1526        case CREATE_CONNECTION:
1527        case OPEN_GLOBAL_TRANSACTION:
1528        case CLOSE_GLOBAL_TRANSACTION:
1529        case SET_ORIENTATION:
1530        case FREEZE_DISPLAY:
1531        case UNFREEZE_DISPLAY:
1532        case BOOT_FINISHED:
1533        case TURN_ELECTRON_BEAM_OFF:
1534        case TURN_ELECTRON_BEAM_ON:
1535        {
1536            // codes that require permission check
1537            IPCThreadState* ipc = IPCThreadState::self();
1538            const int pid = ipc->getCallingPid();
1539            const int uid = ipc->getCallingUid();
1540            if ((uid != AID_GRAPHICS) && !mAccessSurfaceFlinger.check(pid, uid)) {
1541                LOGE("Permission Denial: "
1542                        "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
1543                return PERMISSION_DENIED;
1544            }
1545            break;
1546        }
1547        case CAPTURE_SCREEN:
1548        {
1549            // codes that require permission check
1550            IPCThreadState* ipc = IPCThreadState::self();
1551            const int pid = ipc->getCallingPid();
1552            const int uid = ipc->getCallingUid();
1553            if ((uid != AID_GRAPHICS) && !mReadFramebuffer.check(pid, uid)) {
1554                LOGE("Permission Denial: "
1555                        "can't read framebuffer pid=%d, uid=%d", pid, uid);
1556                return PERMISSION_DENIED;
1557            }
1558            break;
1559        }
1560    }
1561
1562    status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
1563    if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
1564        CHECK_INTERFACE(ISurfaceComposer, data, reply);
1565        if (UNLIKELY(!mHardwareTest.checkCalling())) {
1566            IPCThreadState* ipc = IPCThreadState::self();
1567            const int pid = ipc->getCallingPid();
1568            const int uid = ipc->getCallingUid();
1569            LOGE("Permission Denial: "
1570                    "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
1571            return PERMISSION_DENIED;
1572        }
1573        int n;
1574        switch (code) {
1575            case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
1576            case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
1577                return NO_ERROR;
1578            case 1002:  // SHOW_UPDATES
1579                n = data.readInt32();
1580                mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
1581                return NO_ERROR;
1582            case 1003:  // SHOW_BACKGROUND
1583                n = data.readInt32();
1584                mDebugBackground = n ? 1 : 0;
1585                return NO_ERROR;
1586            case 1008:  // toggle use of hw composer
1587                n = data.readInt32();
1588                mDebugDisableHWC = n ? 1 : 0;
1589                mHwWorkListDirty = true;
1590                // fall-through...
1591            case 1004:{ // repaint everything
1592                Mutex::Autolock _l(mStateLock);
1593                const DisplayHardware& hw(graphicPlane(0).displayHardware());
1594                mDirtyRegion.set(hw.bounds()); // careful that's not thread-safe
1595                signalEvent();
1596                return NO_ERROR;
1597            }
1598            case 1005:{ // force transaction
1599                setTransactionFlags(eTransactionNeeded|eTraversalNeeded);
1600                return NO_ERROR;
1601            }
1602            case 1006:{ // enable/disable GraphicLog
1603                int enabled = data.readInt32();
1604                GraphicLog::getInstance().setEnabled(enabled);
1605                return NO_ERROR;
1606            }
1607            case 1007: // set mFreezeCount
1608                mFreezeCount = data.readInt32();
1609                mFreezeDisplayTime = 0;
1610                return NO_ERROR;
1611            case 1010:  // interrogate.
1612                reply->writeInt32(0);
1613                reply->writeInt32(0);
1614                reply->writeInt32(mDebugRegion);
1615                reply->writeInt32(mDebugBackground);
1616                return NO_ERROR;
1617            case 1013: {
1618                Mutex::Autolock _l(mStateLock);
1619                const DisplayHardware& hw(graphicPlane(0).displayHardware());
1620                reply->writeInt32(hw.getPageFlipCount());
1621            }
1622            return NO_ERROR;
1623        }
1624    }
1625    return err;
1626}
1627
1628// ---------------------------------------------------------------------------
1629
1630status_t SurfaceFlinger::renderScreenToTextureLocked(DisplayID dpy,
1631        GLuint* textureName, GLfloat* uOut, GLfloat* vOut)
1632{
1633    if (!GLExtensions::getInstance().haveFramebufferObject())
1634        return INVALID_OPERATION;
1635
1636    // get screen geometry
1637    const DisplayHardware& hw(graphicPlane(dpy).displayHardware());
1638    const uint32_t hw_w = hw.getWidth();
1639    const uint32_t hw_h = hw.getHeight();
1640    GLfloat u = 1;
1641    GLfloat v = 1;
1642
1643    // make sure to clear all GL error flags
1644    while ( glGetError() != GL_NO_ERROR ) ;
1645
1646    // create a FBO
1647    GLuint name, tname;
1648    glGenTextures(1, &tname);
1649    glBindTexture(GL_TEXTURE_2D, tname);
1650    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
1651            hw_w, hw_h, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1652    if (glGetError() != GL_NO_ERROR) {
1653        while ( glGetError() != GL_NO_ERROR ) ;
1654        GLint tw = (2 << (31 - clz(hw_w)));
1655        GLint th = (2 << (31 - clz(hw_h)));
1656        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
1657                tw, th, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
1658        u = GLfloat(hw_w) / tw;
1659        v = GLfloat(hw_h) / th;
1660    }
1661    glGenFramebuffersOES(1, &name);
1662    glBindFramebufferOES(GL_FRAMEBUFFER_OES, name);
1663    glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES,
1664            GL_COLOR_ATTACHMENT0_OES, GL_TEXTURE_2D, tname, 0);
1665
1666    // redraw the screen entirely...
1667    glClearColor(0,0,0,1);
1668    glClear(GL_COLOR_BUFFER_BIT);
1669    const Vector< sp<LayerBase> >& layers(mVisibleLayersSortedByZ);
1670    const size_t count = layers.size();
1671    for (size_t i=0 ; i<count ; ++i) {
1672        const sp<LayerBase>& layer(layers[i]);
1673        layer->drawForSreenShot();
1674    }
1675
1676    // back to main framebuffer
1677    glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0);
1678    glDisable(GL_SCISSOR_TEST);
1679    glDeleteFramebuffersOES(1, &name);
1680
1681    *textureName = tname;
1682    *uOut = u;
1683    *vOut = v;
1684    return NO_ERROR;
1685}
1686
1687// ---------------------------------------------------------------------------
1688
1689status_t SurfaceFlinger::electronBeamOffAnimationImplLocked()
1690{
1691    status_t result = PERMISSION_DENIED;
1692
1693    if (!GLExtensions::getInstance().haveFramebufferObject())
1694        return INVALID_OPERATION;
1695
1696    // get screen geometry
1697    const DisplayHardware& hw(graphicPlane(0).displayHardware());
1698    const uint32_t hw_w = hw.getWidth();
1699    const uint32_t hw_h = hw.getHeight();
1700    const Region screenBounds(hw.bounds());
1701
1702    GLfloat u, v;
1703    GLuint tname;
1704    result = renderScreenToTextureLocked(0, &tname, &u, &v);
1705    if (result != NO_ERROR) {
1706        return result;
1707    }
1708
1709    GLfloat vtx[8];
1710    const GLfloat texCoords[4][2] = { {0,v}, {0,0}, {u,0}, {u,v} };
1711    glEnable(GL_TEXTURE_2D);
1712    glBindTexture(GL_TEXTURE_2D, tname);
1713    glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1714    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1715    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1716    glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
1717    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1718    glVertexPointer(2, GL_FLOAT, 0, vtx);
1719
1720    class s_curve_interpolator {
1721        const float nbFrames, s, v;
1722    public:
1723        s_curve_interpolator(int nbFrames, float s)
1724        : nbFrames(1.0f / (nbFrames-1)), s(s),
1725          v(1.0f + expf(-s + 0.5f*s)) {
1726        }
1727        float operator()(int f) {
1728            const float x = f * nbFrames;
1729            return ((1.0f/(1.0f + expf(-x*s + 0.5f*s))) - 0.5f) * v + 0.5f;
1730        }
1731    };
1732
1733    class v_stretch {
1734        const GLfloat hw_w, hw_h;
1735    public:
1736        v_stretch(uint32_t hw_w, uint32_t hw_h)
1737        : hw_w(hw_w), hw_h(hw_h) {
1738        }
1739        void operator()(GLfloat* vtx, float v) {
1740            const GLfloat w = hw_w + (hw_w * v);
1741            const GLfloat h = hw_h - (hw_h * v);
1742            const GLfloat x = (hw_w - w) * 0.5f;
1743            const GLfloat y = (hw_h - h) * 0.5f;
1744            vtx[0] = x;         vtx[1] = y;
1745            vtx[2] = x;         vtx[3] = y + h;
1746            vtx[4] = x + w;     vtx[5] = y + h;
1747            vtx[6] = x + w;     vtx[7] = y;
1748        }
1749    };
1750
1751    class h_stretch {
1752        const GLfloat hw_w, hw_h;
1753    public:
1754        h_stretch(uint32_t hw_w, uint32_t hw_h)
1755        : hw_w(hw_w), hw_h(hw_h) {
1756        }
1757        void operator()(GLfloat* vtx, float v) {
1758            const GLfloat w = hw_w - (hw_w * v);
1759            const GLfloat h = 1.0f;
1760            const GLfloat x = (hw_w - w) * 0.5f;
1761            const GLfloat y = (hw_h - h) * 0.5f;
1762            vtx[0] = x;         vtx[1] = y;
1763            vtx[2] = x;         vtx[3] = y + h;
1764            vtx[4] = x + w;     vtx[5] = y + h;
1765            vtx[6] = x + w;     vtx[7] = y;
1766        }
1767    };
1768
1769    // the full animation is 24 frames
1770    const int nbFrames = 12;
1771    s_curve_interpolator itr(nbFrames, 7.5f);
1772    s_curve_interpolator itg(nbFrames, 8.0f);
1773    s_curve_interpolator itb(nbFrames, 8.5f);
1774
1775    v_stretch vverts(hw_w, hw_h);
1776    glEnable(GL_BLEND);
1777    glBlendFunc(GL_ONE, GL_ONE);
1778    for (int i=0 ; i<nbFrames ; i++) {
1779        float x, y, w, h;
1780        const float vr = itr(i);
1781        const float vg = itg(i);
1782        const float vb = itb(i);
1783
1784        // clear screen
1785        glColorMask(1,1,1,1);
1786        glClear(GL_COLOR_BUFFER_BIT);
1787        glEnable(GL_TEXTURE_2D);
1788
1789        // draw the red plane
1790        vverts(vtx, vr);
1791        glColorMask(1,0,0,1);
1792        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1793
1794        // draw the green plane
1795        vverts(vtx, vg);
1796        glColorMask(0,1,0,1);
1797        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1798
1799        // draw the blue plane
1800        vverts(vtx, vb);
1801        glColorMask(0,0,1,1);
1802        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1803
1804        // draw the white highlight (we use the last vertices)
1805        glDisable(GL_TEXTURE_2D);
1806        glColorMask(1,1,1,1);
1807        glColor4f(vg, vg, vg, 1);
1808        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1809        hw.flip(screenBounds);
1810    }
1811
1812    h_stretch hverts(hw_w, hw_h);
1813    glDisable(GL_BLEND);
1814    glDisable(GL_TEXTURE_2D);
1815    glColorMask(1,1,1,1);
1816    for (int i=0 ; i<nbFrames ; i++) {
1817        const float v = itg(i);
1818        hverts(vtx, v);
1819        glClear(GL_COLOR_BUFFER_BIT);
1820        glColor4f(1-v, 1-v, 1-v, 1);
1821        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1822        hw.flip(screenBounds);
1823    }
1824
1825    glColorMask(1,1,1,1);
1826    glEnable(GL_SCISSOR_TEST);
1827    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1828    glDeleteTextures(1, &tname);
1829    return NO_ERROR;
1830}
1831
1832status_t SurfaceFlinger::electronBeamOnAnimationImplLocked()
1833{
1834    status_t result = PERMISSION_DENIED;
1835
1836    if (!GLExtensions::getInstance().haveFramebufferObject())
1837        return INVALID_OPERATION;
1838
1839
1840    // get screen geometry
1841    const DisplayHardware& hw(graphicPlane(0).displayHardware());
1842    const uint32_t hw_w = hw.getWidth();
1843    const uint32_t hw_h = hw.getHeight();
1844    const Region screenBounds(hw.bounds());
1845
1846    GLfloat u, v;
1847    GLuint tname;
1848    result = renderScreenToTextureLocked(0, &tname, &u, &v);
1849    if (result != NO_ERROR) {
1850        return result;
1851    }
1852
1853    // back to main framebuffer
1854    glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0);
1855    glDisable(GL_SCISSOR_TEST);
1856
1857    GLfloat vtx[8];
1858    const GLfloat texCoords[4][2] = { {0,v}, {0,0}, {u,0}, {u,v} };
1859    glEnable(GL_TEXTURE_2D);
1860    glBindTexture(GL_TEXTURE_2D, tname);
1861    glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1862    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1863    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1864    glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
1865    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1866    glVertexPointer(2, GL_FLOAT, 0, vtx);
1867
1868    class s_curve_interpolator {
1869        const float nbFrames, s, v;
1870    public:
1871        s_curve_interpolator(int nbFrames, float s)
1872        : nbFrames(1.0f / (nbFrames-1)), s(s),
1873          v(1.0f + expf(-s + 0.5f*s)) {
1874        }
1875        float operator()(int f) {
1876            const float x = f * nbFrames;
1877            return ((1.0f/(1.0f + expf(-x*s + 0.5f*s))) - 0.5f) * v + 0.5f;
1878        }
1879    };
1880
1881    class v_stretch {
1882        const GLfloat hw_w, hw_h;
1883    public:
1884        v_stretch(uint32_t hw_w, uint32_t hw_h)
1885        : hw_w(hw_w), hw_h(hw_h) {
1886        }
1887        void operator()(GLfloat* vtx, float v) {
1888            const GLfloat w = hw_w + (hw_w * v);
1889            const GLfloat h = hw_h - (hw_h * v);
1890            const GLfloat x = (hw_w - w) * 0.5f;
1891            const GLfloat y = (hw_h - h) * 0.5f;
1892            vtx[0] = x;         vtx[1] = y;
1893            vtx[2] = x;         vtx[3] = y + h;
1894            vtx[4] = x + w;     vtx[5] = y + h;
1895            vtx[6] = x + w;     vtx[7] = y;
1896        }
1897    };
1898
1899    class h_stretch {
1900        const GLfloat hw_w, hw_h;
1901    public:
1902        h_stretch(uint32_t hw_w, uint32_t hw_h)
1903        : hw_w(hw_w), hw_h(hw_h) {
1904        }
1905        void operator()(GLfloat* vtx, float v) {
1906            const GLfloat w = hw_w - (hw_w * v);
1907            const GLfloat h = 1.0f;
1908            const GLfloat x = (hw_w - w) * 0.5f;
1909            const GLfloat y = (hw_h - h) * 0.5f;
1910            vtx[0] = x;         vtx[1] = y;
1911            vtx[2] = x;         vtx[3] = y + h;
1912            vtx[4] = x + w;     vtx[5] = y + h;
1913            vtx[6] = x + w;     vtx[7] = y;
1914        }
1915    };
1916
1917    // the full animation is 12 frames
1918    int nbFrames = 8;
1919    s_curve_interpolator itr(nbFrames, 7.5f);
1920    s_curve_interpolator itg(nbFrames, 8.0f);
1921    s_curve_interpolator itb(nbFrames, 8.5f);
1922
1923    h_stretch hverts(hw_w, hw_h);
1924    glDisable(GL_BLEND);
1925    glDisable(GL_TEXTURE_2D);
1926    glColorMask(1,1,1,1);
1927    for (int i=nbFrames-1 ; i>=0 ; i--) {
1928        const float v = itg(i);
1929        hverts(vtx, v);
1930        glClear(GL_COLOR_BUFFER_BIT);
1931        glColor4f(1-v, 1-v, 1-v, 1);
1932        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1933        hw.flip(screenBounds);
1934    }
1935
1936    nbFrames = 4;
1937    v_stretch vverts(hw_w, hw_h);
1938    glEnable(GL_BLEND);
1939    glBlendFunc(GL_ONE, GL_ONE);
1940    for (int i=nbFrames-1 ; i>=0 ; i--) {
1941        float x, y, w, h;
1942        const float vr = itr(i);
1943        const float vg = itg(i);
1944        const float vb = itb(i);
1945
1946        // clear screen
1947        glColorMask(1,1,1,1);
1948        glClear(GL_COLOR_BUFFER_BIT);
1949        glEnable(GL_TEXTURE_2D);
1950
1951        // draw the red plane
1952        vverts(vtx, vr);
1953        glColorMask(1,0,0,1);
1954        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1955
1956        // draw the green plane
1957        vverts(vtx, vg);
1958        glColorMask(0,1,0,1);
1959        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1960
1961        // draw the blue plane
1962        vverts(vtx, vb);
1963        glColorMask(0,0,1,1);
1964        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1965
1966        hw.flip(screenBounds);
1967    }
1968
1969    glColorMask(1,1,1,1);
1970    glEnable(GL_SCISSOR_TEST);
1971    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1972    glDeleteTextures(1, &tname);
1973
1974    return NO_ERROR;
1975}
1976
1977// ---------------------------------------------------------------------------
1978
1979status_t SurfaceFlinger::turnElectronBeamOffImplLocked(int32_t mode)
1980{
1981    DisplayHardware& hw(graphicPlane(0).editDisplayHardware());
1982    if (!hw.canDraw()) {
1983        // we're already off
1984        return NO_ERROR;
1985    }
1986    if (mode & ISurfaceComposer::eElectronBeamAnimationOff) {
1987        electronBeamOffAnimationImplLocked();
1988    }
1989
1990    // always clear the whole screen at the end of the animation
1991    glClearColor(0,0,0,1);
1992    glDisable(GL_SCISSOR_TEST);
1993    glClear(GL_COLOR_BUFFER_BIT);
1994    glEnable(GL_SCISSOR_TEST);
1995    hw.flip( Region(hw.bounds()) );
1996
1997    hw.setCanDraw(false);
1998    return NO_ERROR;
1999}
2000
2001status_t SurfaceFlinger::turnElectronBeamOff(int32_t mode)
2002{
2003    class MessageTurnElectronBeamOff : public MessageBase {
2004        SurfaceFlinger* flinger;
2005        int32_t mode;
2006        status_t result;
2007    public:
2008        MessageTurnElectronBeamOff(SurfaceFlinger* flinger, int32_t mode)
2009            : flinger(flinger), mode(mode), result(PERMISSION_DENIED) {
2010        }
2011        status_t getResult() const {
2012            return result;
2013        }
2014        virtual bool handler() {
2015            Mutex::Autolock _l(flinger->mStateLock);
2016            result = flinger->turnElectronBeamOffImplLocked(mode);
2017            return true;
2018        }
2019    };
2020
2021    sp<MessageBase> msg = new MessageTurnElectronBeamOff(this, mode);
2022    status_t res = postMessageSync(msg);
2023    if (res == NO_ERROR) {
2024        res = static_cast<MessageTurnElectronBeamOff*>( msg.get() )->getResult();
2025
2026        // work-around: when the power-manager calls us we activate the
2027        // animation. eventually, the "on" animation will be called
2028        // by the power-manager itself
2029        mElectronBeamAnimationMode = mode;
2030    }
2031    return res;
2032}
2033
2034// ---------------------------------------------------------------------------
2035
2036status_t SurfaceFlinger::turnElectronBeamOnImplLocked(int32_t mode)
2037{
2038    DisplayHardware& hw(graphicPlane(0).editDisplayHardware());
2039    if (hw.canDraw()) {
2040        // we're already on
2041        return NO_ERROR;
2042    }
2043    if (mode & ISurfaceComposer::eElectronBeamAnimationOn) {
2044        electronBeamOnAnimationImplLocked();
2045    }
2046    hw.setCanDraw(true);
2047
2048    // make sure to redraw the whole screen when the animation is done
2049    mDirtyRegion.set(hw.bounds());
2050    signalEvent();
2051
2052    return NO_ERROR;
2053}
2054
2055status_t SurfaceFlinger::turnElectronBeamOn(int32_t mode)
2056{
2057    class MessageTurnElectronBeamOn : public MessageBase {
2058        SurfaceFlinger* flinger;
2059        int32_t mode;
2060        status_t result;
2061    public:
2062        MessageTurnElectronBeamOn(SurfaceFlinger* flinger, int32_t mode)
2063            : flinger(flinger), mode(mode), result(PERMISSION_DENIED) {
2064        }
2065        status_t getResult() const {
2066            return result;
2067        }
2068        virtual bool handler() {
2069            Mutex::Autolock _l(flinger->mStateLock);
2070            result = flinger->turnElectronBeamOnImplLocked(mode);
2071            return true;
2072        }
2073    };
2074
2075    postMessageAsync( new MessageTurnElectronBeamOn(this, mode) );
2076    return NO_ERROR;
2077}
2078
2079// ---------------------------------------------------------------------------
2080
2081status_t SurfaceFlinger::captureScreenImplLocked(DisplayID dpy,
2082        sp<IMemoryHeap>* heap,
2083        uint32_t* w, uint32_t* h, PixelFormat* f,
2084        uint32_t sw, uint32_t sh,
2085        uint32_t minLayerZ, uint32_t maxLayerZ)
2086{
2087    status_t result = PERMISSION_DENIED;
2088
2089    // only one display supported for now
2090    if (UNLIKELY(uint32_t(dpy) >= DISPLAY_COUNT))
2091        return BAD_VALUE;
2092
2093    if (!GLExtensions::getInstance().haveFramebufferObject())
2094        return INVALID_OPERATION;
2095
2096    // get screen geometry
2097    const DisplayHardware& hw(graphicPlane(dpy).displayHardware());
2098    const uint32_t hw_w = hw.getWidth();
2099    const uint32_t hw_h = hw.getHeight();
2100
2101    if ((sw > hw_w) || (sh > hw_h))
2102        return BAD_VALUE;
2103
2104    sw = (!sw) ? hw_w : sw;
2105    sh = (!sh) ? hw_h : sh;
2106    const size_t size = sw * sh * 4;
2107
2108    // make sure to clear all GL error flags
2109    while ( glGetError() != GL_NO_ERROR ) ;
2110
2111    // create a FBO
2112    GLuint name, tname;
2113    glGenRenderbuffersOES(1, &tname);
2114    glBindRenderbufferOES(GL_RENDERBUFFER_OES, tname);
2115    glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_RGBA8_OES, sw, sh);
2116    glGenFramebuffersOES(1, &name);
2117    glBindFramebufferOES(GL_FRAMEBUFFER_OES, name);
2118    glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES,
2119            GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, tname);
2120
2121    GLenum status = glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES);
2122    if (status == GL_FRAMEBUFFER_COMPLETE_OES) {
2123
2124        // invert everything, b/c glReadPixel() below will invert the FB
2125        glViewport(0, 0, sw, sh);
2126        glMatrixMode(GL_PROJECTION);
2127        glPushMatrix();
2128        glLoadIdentity();
2129        glOrthof(0, hw_w, 0, hw_h, 0, 1);
2130        glMatrixMode(GL_MODELVIEW);
2131
2132        // redraw the screen entirely...
2133        glClearColor(0,0,0,1);
2134        glClear(GL_COLOR_BUFFER_BIT);
2135        const Vector< sp<LayerBase> >& layers(mVisibleLayersSortedByZ);
2136        const size_t count = layers.size();
2137        for (size_t i=0 ; i<count ; ++i) {
2138            const sp<LayerBase>& layer(layers[i]);
2139            const uint32_t z = layer->drawingState().z;
2140            if (z >= minLayerZ && z <= maxLayerZ) {
2141                layer->drawForSreenShot();
2142            }
2143        }
2144
2145        // XXX: this is needed on tegra
2146        glScissor(0, 0, sw, sh);
2147
2148        // check for errors and return screen capture
2149        if (glGetError() != GL_NO_ERROR) {
2150            // error while rendering
2151            result = INVALID_OPERATION;
2152        } else {
2153            // allocate shared memory large enough to hold the
2154            // screen capture
2155            sp<MemoryHeapBase> base(
2156                    new MemoryHeapBase(size, 0, "screen-capture") );
2157            void* const ptr = base->getBase();
2158            if (ptr) {
2159                // capture the screen with glReadPixels()
2160                glReadPixels(0, 0, sw, sh, GL_RGBA, GL_UNSIGNED_BYTE, ptr);
2161                if (glGetError() == GL_NO_ERROR) {
2162                    *heap = base;
2163                    *w = sw;
2164                    *h = sh;
2165                    *f = PIXEL_FORMAT_RGBA_8888;
2166                    result = NO_ERROR;
2167                }
2168            } else {
2169                result = NO_MEMORY;
2170            }
2171        }
2172
2173        glEnable(GL_SCISSOR_TEST);
2174        glViewport(0, 0, hw_w, hw_h);
2175        glMatrixMode(GL_PROJECTION);
2176        glPopMatrix();
2177        glMatrixMode(GL_MODELVIEW);
2178
2179
2180    } else {
2181        result = BAD_VALUE;
2182    }
2183
2184    // release FBO resources
2185    glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0);
2186    glDeleteRenderbuffersOES(1, &tname);
2187    glDeleteFramebuffersOES(1, &name);
2188
2189    hw.compositionComplete();
2190
2191    return result;
2192}
2193
2194
2195status_t SurfaceFlinger::captureScreen(DisplayID dpy,
2196        sp<IMemoryHeap>* heap,
2197        uint32_t* width, uint32_t* height, PixelFormat* format,
2198        uint32_t sw, uint32_t sh,
2199        uint32_t minLayerZ, uint32_t maxLayerZ)
2200{
2201    // only one display supported for now
2202    if (UNLIKELY(uint32_t(dpy) >= DISPLAY_COUNT))
2203        return BAD_VALUE;
2204
2205    if (!GLExtensions::getInstance().haveFramebufferObject())
2206        return INVALID_OPERATION;
2207
2208    class MessageCaptureScreen : public MessageBase {
2209        SurfaceFlinger* flinger;
2210        DisplayID dpy;
2211        sp<IMemoryHeap>* heap;
2212        uint32_t* w;
2213        uint32_t* h;
2214        PixelFormat* f;
2215        uint32_t sw;
2216        uint32_t sh;
2217        uint32_t minLayerZ;
2218        uint32_t maxLayerZ;
2219        status_t result;
2220    public:
2221        MessageCaptureScreen(SurfaceFlinger* flinger, DisplayID dpy,
2222                sp<IMemoryHeap>* heap, uint32_t* w, uint32_t* h, PixelFormat* f,
2223                uint32_t sw, uint32_t sh,
2224                uint32_t minLayerZ, uint32_t maxLayerZ)
2225            : flinger(flinger), dpy(dpy),
2226              heap(heap), w(w), h(h), f(f), sw(sw), sh(sh),
2227              minLayerZ(minLayerZ), maxLayerZ(maxLayerZ),
2228              result(PERMISSION_DENIED)
2229        {
2230        }
2231        status_t getResult() const {
2232            return result;
2233        }
2234        virtual bool handler() {
2235            Mutex::Autolock _l(flinger->mStateLock);
2236
2237            // if we have secure windows, never allow the screen capture
2238            if (flinger->mSecureFrameBuffer)
2239                return true;
2240
2241            result = flinger->captureScreenImplLocked(dpy,
2242                    heap, w, h, f, sw, sh, minLayerZ, maxLayerZ);
2243
2244            return true;
2245        }
2246    };
2247
2248    sp<MessageBase> msg = new MessageCaptureScreen(this,
2249            dpy, heap, width, height, format, sw, sh, minLayerZ, maxLayerZ);
2250    status_t res = postMessageSync(msg);
2251    if (res == NO_ERROR) {
2252        res = static_cast<MessageCaptureScreen*>( msg.get() )->getResult();
2253    }
2254    return res;
2255}
2256
2257// ---------------------------------------------------------------------------
2258
2259sp<Layer> SurfaceFlinger::getLayer(const sp<ISurface>& sur) const
2260{
2261    sp<Layer> result;
2262    Mutex::Autolock _l(mStateLock);
2263    result = mLayerMap.valueFor( sur->asBinder() ).promote();
2264    return result;
2265}
2266
2267// ---------------------------------------------------------------------------
2268
2269Client::Client(const sp<SurfaceFlinger>& flinger)
2270    : mFlinger(flinger), mNameGenerator(1)
2271{
2272}
2273
2274Client::~Client()
2275{
2276    const size_t count = mLayers.size();
2277    for (size_t i=0 ; i<count ; i++) {
2278        sp<LayerBaseClient> layer(mLayers.valueAt(i).promote());
2279        if (layer != 0) {
2280            mFlinger->removeLayer(layer);
2281        }
2282    }
2283}
2284
2285status_t Client::initCheck() const {
2286    return NO_ERROR;
2287}
2288
2289ssize_t Client::attachLayer(const sp<LayerBaseClient>& layer)
2290{
2291    int32_t name = android_atomic_inc(&mNameGenerator);
2292    mLayers.add(name, layer);
2293    return name;
2294}
2295
2296void Client::detachLayer(const LayerBaseClient* layer)
2297{
2298    // we do a linear search here, because this doesn't happen often
2299    const size_t count = mLayers.size();
2300    for (size_t i=0 ; i<count ; i++) {
2301        if (mLayers.valueAt(i) == layer) {
2302            mLayers.removeItemsAt(i, 1);
2303            break;
2304        }
2305    }
2306}
2307sp<LayerBaseClient> Client::getLayerUser(int32_t i) const {
2308    sp<LayerBaseClient> lbc;
2309    const wp<LayerBaseClient>& layer(mLayers.valueFor(i));
2310    if (layer != 0) {
2311        lbc = layer.promote();
2312        LOGE_IF(lbc==0, "getLayerUser(name=%d) is dead", int(i));
2313    }
2314    return lbc;
2315}
2316
2317sp<IMemoryHeap> Client::getControlBlock() const {
2318    return 0;
2319}
2320ssize_t Client::getTokenForSurface(const sp<ISurface>& sur) const {
2321    return -1;
2322}
2323sp<ISurface> Client::createSurface(
2324        ISurfaceComposerClient::surface_data_t* params, int pid,
2325        const String8& name,
2326        DisplayID display, uint32_t w, uint32_t h, PixelFormat format,
2327        uint32_t flags)
2328{
2329    return mFlinger->createSurface(this, pid, name, params,
2330            display, w, h, format, flags);
2331}
2332status_t Client::destroySurface(SurfaceID sid) {
2333    return mFlinger->removeSurface(this, sid);
2334}
2335status_t Client::setState(int32_t count, const layer_state_t* states) {
2336    return mFlinger->setClientState(this, count, states);
2337}
2338
2339// ---------------------------------------------------------------------------
2340
2341UserClient::UserClient(const sp<SurfaceFlinger>& flinger)
2342    : ctrlblk(0), mBitmap(0), mFlinger(flinger)
2343{
2344    const int pgsize = getpagesize();
2345    const int cblksize = ((sizeof(SharedClient)+(pgsize-1))&~(pgsize-1));
2346
2347    mCblkHeap = new MemoryHeapBase(cblksize, 0,
2348            "SurfaceFlinger Client control-block");
2349
2350    ctrlblk = static_cast<SharedClient *>(mCblkHeap->getBase());
2351    if (ctrlblk) { // construct the shared structure in-place.
2352        new(ctrlblk) SharedClient;
2353    }
2354}
2355
2356UserClient::~UserClient()
2357{
2358    if (ctrlblk) {
2359        ctrlblk->~SharedClient();  // destroy our shared-structure.
2360    }
2361
2362    /*
2363     * When a UserClient dies, it's unclear what to do exactly.
2364     * We could go ahead and destroy all surfaces linked to that client
2365     * however, it wouldn't be fair to the main Client
2366     * (usually the the window-manager), which might want to re-target
2367     * the layer to another UserClient.
2368     * I think the best is to do nothing, or not much; in most cases the
2369     * WM itself will go ahead and clean things up when it detects a client of
2370     * his has died.
2371     * The remaining question is what to display? currently we keep
2372     * just keep the current buffer.
2373     */
2374}
2375
2376status_t UserClient::initCheck() const {
2377    return ctrlblk == 0 ? NO_INIT : NO_ERROR;
2378}
2379
2380void UserClient::detachLayer(const Layer* layer)
2381{
2382    int32_t name = layer->getToken();
2383    if (name >= 0) {
2384        int32_t mask = 1LU<<name;
2385        if ((android_atomic_and(~mask, &mBitmap) & mask) == 0) {
2386            LOGW("token %d wasn't marked as used %08x", name, int(mBitmap));
2387        }
2388    }
2389}
2390
2391sp<IMemoryHeap> UserClient::getControlBlock() const {
2392    return mCblkHeap;
2393}
2394
2395ssize_t UserClient::getTokenForSurface(const sp<ISurface>& sur) const
2396{
2397    int32_t name = NAME_NOT_FOUND;
2398    sp<Layer> layer(mFlinger->getLayer(sur));
2399    if (layer == 0) {
2400        return name;
2401    }
2402
2403    // if this layer already has a token, just return it
2404    name = layer->getToken();
2405    if ((name >= 0) && (layer->getClient() == this)) {
2406        return name;
2407    }
2408
2409    name = 0;
2410    do {
2411        int32_t mask = 1LU<<name;
2412        if ((android_atomic_or(mask, &mBitmap) & mask) == 0) {
2413            // we found and locked that name
2414            status_t err = layer->setToken(
2415                    const_cast<UserClient*>(this), ctrlblk, name);
2416            if (err != NO_ERROR) {
2417                // free the name
2418                android_atomic_and(~mask, &mBitmap);
2419                name = err;
2420            }
2421            break;
2422        }
2423        if (++name > 31)
2424            name = NO_MEMORY;
2425    } while(name >= 0);
2426
2427    //LOGD("getTokenForSurface(%p) => %d (client=%p, bitmap=%08lx)",
2428    //        sur->asBinder().get(), name, this, mBitmap);
2429    return name;
2430}
2431
2432sp<ISurface> UserClient::createSurface(
2433        ISurfaceComposerClient::surface_data_t* params, int pid,
2434        const String8& name,
2435        DisplayID display, uint32_t w, uint32_t h, PixelFormat format,
2436        uint32_t flags) {
2437    return 0;
2438}
2439status_t UserClient::destroySurface(SurfaceID sid) {
2440    return INVALID_OPERATION;
2441}
2442status_t UserClient::setState(int32_t count, const layer_state_t* states) {
2443    return INVALID_OPERATION;
2444}
2445
2446// ---------------------------------------------------------------------------
2447
2448GraphicPlane::GraphicPlane()
2449    : mHw(0)
2450{
2451}
2452
2453GraphicPlane::~GraphicPlane() {
2454    delete mHw;
2455}
2456
2457bool GraphicPlane::initialized() const {
2458    return mHw ? true : false;
2459}
2460
2461int GraphicPlane::getWidth() const {
2462    return mWidth;
2463}
2464
2465int GraphicPlane::getHeight() const {
2466    return mHeight;
2467}
2468
2469void GraphicPlane::setDisplayHardware(DisplayHardware *hw)
2470{
2471    mHw = hw;
2472
2473    // initialize the display orientation transform.
2474    // it's a constant that should come from the display driver.
2475    int displayOrientation = ISurfaceComposer::eOrientationDefault;
2476    char property[PROPERTY_VALUE_MAX];
2477    if (property_get("ro.sf.hwrotation", property, NULL) > 0) {
2478        //displayOrientation
2479        switch (atoi(property)) {
2480        case 90:
2481            displayOrientation = ISurfaceComposer::eOrientation90;
2482            break;
2483        case 270:
2484            displayOrientation = ISurfaceComposer::eOrientation270;
2485            break;
2486        }
2487    }
2488
2489    const float w = hw->getWidth();
2490    const float h = hw->getHeight();
2491    GraphicPlane::orientationToTransfrom(displayOrientation, w, h,
2492            &mDisplayTransform);
2493    if (displayOrientation & ISurfaceComposer::eOrientationSwapMask) {
2494        mDisplayWidth = h;
2495        mDisplayHeight = w;
2496    } else {
2497        mDisplayWidth = w;
2498        mDisplayHeight = h;
2499    }
2500
2501    setOrientation(ISurfaceComposer::eOrientationDefault);
2502}
2503
2504status_t GraphicPlane::orientationToTransfrom(
2505        int orientation, int w, int h, Transform* tr)
2506{
2507    uint32_t flags = 0;
2508    switch (orientation) {
2509    case ISurfaceComposer::eOrientationDefault:
2510        flags = Transform::ROT_0;
2511        break;
2512    case ISurfaceComposer::eOrientation90:
2513        flags = Transform::ROT_90;
2514        break;
2515    case ISurfaceComposer::eOrientation180:
2516        flags = Transform::ROT_180;
2517        break;
2518    case ISurfaceComposer::eOrientation270:
2519        flags = Transform::ROT_270;
2520        break;
2521    default:
2522        return BAD_VALUE;
2523    }
2524    tr->set(flags, w, h);
2525    return NO_ERROR;
2526}
2527
2528status_t GraphicPlane::setOrientation(int orientation)
2529{
2530    // If the rotation can be handled in hardware, this is where
2531    // the magic should happen.
2532
2533    const DisplayHardware& hw(displayHardware());
2534    const float w = mDisplayWidth;
2535    const float h = mDisplayHeight;
2536    mWidth = int(w);
2537    mHeight = int(h);
2538
2539    Transform orientationTransform;
2540    GraphicPlane::orientationToTransfrom(orientation, w, h,
2541            &orientationTransform);
2542    if (orientation & ISurfaceComposer::eOrientationSwapMask) {
2543        mWidth = int(h);
2544        mHeight = int(w);
2545    }
2546
2547    mOrientation = orientation;
2548    mGlobalTransform = mDisplayTransform * orientationTransform;
2549    return NO_ERROR;
2550}
2551
2552const DisplayHardware& GraphicPlane::displayHardware() const {
2553    return *mHw;
2554}
2555
2556DisplayHardware& GraphicPlane::editDisplayHardware() {
2557    return *mHw;
2558}
2559
2560const Transform& GraphicPlane::transform() const {
2561    return mGlobalTransform;
2562}
2563
2564EGLDisplay GraphicPlane::getEGLDisplay() const {
2565    return mHw->getEGLDisplay();
2566}
2567
2568// ---------------------------------------------------------------------------
2569
2570}; // namespace android
2571