SurfaceFlinger.cpp revision ae957658688ce174a8d58434b4567d022c22a6cf 
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/PixelFormat.h>
42
43#include <pixelflinger/pixelflinger.h>
44#include <GLES/gl.h>
45
46#include "clz.h"
47#include "GLExtensions.h"
48#include "Layer.h"
49#include "LayerBlur.h"
50#include "LayerBuffer.h"
51#include "LayerDim.h"
52#include "SurfaceFlinger.h"
53
54#include "DisplayHardware/DisplayHardware.h"
55#include "DisplayHardware/HWComposer.h"
56
57/* ideally AID_GRAPHICS would be in a semi-public header
58 * or there would be a way to map a user/group name to its id
59 */
60#ifndef AID_GRAPHICS
61#define AID_GRAPHICS 1003
62#endif
63
64#define DISPLAY_COUNT       1
65
66namespace android {
67// ---------------------------------------------------------------------------
68
69SurfaceFlinger::SurfaceFlinger()
70    :   BnSurfaceComposer(), Thread(false),
71        mTransactionFlags(0),
72        mTransactionCount(0),
73        mResizeTransationPending(false),
74        mLayersRemoved(false),
75        mBootTime(systemTime()),
76        mHardwareTest("android.permission.HARDWARE_TEST"),
77        mAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER"),
78        mDump("android.permission.DUMP"),
79        mVisibleRegionsDirty(false),
80        mHwWorkListDirty(false),
81        mDeferReleaseConsole(false),
82        mFreezeDisplay(false),
83        mFreezeCount(0),
84        mFreezeDisplayTime(0),
85        mDebugRegion(0),
86        mDebugBackground(0),
87        mDebugInSwapBuffers(0),
88        mLastSwapBufferTime(0),
89        mDebugInTransaction(0),
90        mLastTransactionTime(0),
91        mBootFinished(false),
92        mConsoleSignals(0),
93        mSecureFrameBuffer(0)
94{
95    init();
96}
97
98void SurfaceFlinger::init()
99{
100    LOGI("SurfaceFlinger is starting");
101
102    // debugging stuff...
103    char value[PROPERTY_VALUE_MAX];
104    property_get("debug.sf.showupdates", value, "0");
105    mDebugRegion = atoi(value);
106    property_get("debug.sf.showbackground", value, "0");
107    mDebugBackground = atoi(value);
108
109    LOGI_IF(mDebugRegion,       "showupdates enabled");
110    LOGI_IF(mDebugBackground,   "showbackground enabled");
111}
112
113SurfaceFlinger::~SurfaceFlinger()
114{
115    glDeleteTextures(1, &mWormholeTexName);
116}
117
118overlay_control_device_t* SurfaceFlinger::getOverlayEngine() const
119{
120    return graphicPlane(0).displayHardware().getOverlayEngine();
121}
122
123sp<IMemoryHeap> SurfaceFlinger::getCblk() const
124{
125    return mServerHeap;
126}
127
128sp<ISurfaceComposerClient> SurfaceFlinger::createConnection()
129{
130    sp<ISurfaceComposerClient> bclient;
131    sp<Client> client(new Client(this));
132    status_t err = client->initCheck();
133    if (err == NO_ERROR) {
134        bclient = client;
135    }
136    return bclient;
137}
138
139sp<ISurfaceComposerClient> SurfaceFlinger::createClientConnection()
140{
141    sp<ISurfaceComposerClient> bclient;
142    sp<UserClient> client(new UserClient(this));
143    status_t err = client->initCheck();
144    if (err == NO_ERROR) {
145        bclient = client;
146    }
147    return bclient;
148}
149
150
151const GraphicPlane& SurfaceFlinger::graphicPlane(int dpy) const
152{
153    LOGE_IF(uint32_t(dpy) >= DISPLAY_COUNT, "Invalid DisplayID %d", dpy);
154    const GraphicPlane& plane(mGraphicPlanes[dpy]);
155    return plane;
156}
157
158GraphicPlane& SurfaceFlinger::graphicPlane(int dpy)
159{
160    return const_cast<GraphicPlane&>(
161        const_cast<SurfaceFlinger const *>(this)->graphicPlane(dpy));
162}
163
164void SurfaceFlinger::bootFinished()
165{
166    const nsecs_t now = systemTime();
167    const nsecs_t duration = now - mBootTime;
168    LOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
169    mBootFinished = true;
170    property_set("ctl.stop", "bootanim");
171}
172
173void SurfaceFlinger::onFirstRef()
174{
175    run("SurfaceFlinger", PRIORITY_URGENT_DISPLAY);
176
177    // Wait for the main thread to be done with its initialization
178    mReadyToRunBarrier.wait();
179}
180
181static inline uint16_t pack565(int r, int g, int b) {
182    return (r<<11)|(g<<5)|b;
183}
184
185status_t SurfaceFlinger::readyToRun()
186{
187    LOGI(   "SurfaceFlinger's main thread ready to run. "
188            "Initializing graphics H/W...");
189
190    // we only support one display currently
191    int dpy = 0;
192
193    {
194        // initialize the main display
195        GraphicPlane& plane(graphicPlane(dpy));
196        DisplayHardware* const hw = new DisplayHardware(this, dpy);
197        plane.setDisplayHardware(hw);
198    }
199
200    // create the shared control-block
201    mServerHeap = new MemoryHeapBase(4096,
202            MemoryHeapBase::READ_ONLY, "SurfaceFlinger read-only heap");
203    LOGE_IF(mServerHeap==0, "can't create shared memory dealer");
204
205    mServerCblk = static_cast<surface_flinger_cblk_t*>(mServerHeap->getBase());
206    LOGE_IF(mServerCblk==0, "can't get to shared control block's address");
207
208    new(mServerCblk) surface_flinger_cblk_t;
209
210    // initialize primary screen
211    // (other display should be initialized in the same manner, but
212    // asynchronously, as they could come and go. None of this is supported
213    // yet).
214    const GraphicPlane& plane(graphicPlane(dpy));
215    const DisplayHardware& hw = plane.displayHardware();
216    const uint32_t w = hw.getWidth();
217    const uint32_t h = hw.getHeight();
218    const uint32_t f = hw.getFormat();
219    hw.makeCurrent();
220
221    // initialize the shared control block
222    mServerCblk->connected |= 1<<dpy;
223    display_cblk_t* dcblk = mServerCblk->displays + dpy;
224    memset(dcblk, 0, sizeof(display_cblk_t));
225    dcblk->w            = plane.getWidth();
226    dcblk->h            = plane.getHeight();
227    dcblk->format       = f;
228    dcblk->orientation  = ISurfaceComposer::eOrientationDefault;
229    dcblk->xdpi         = hw.getDpiX();
230    dcblk->ydpi         = hw.getDpiY();
231    dcblk->fps          = hw.getRefreshRate();
232    dcblk->density      = hw.getDensity();
233
234    // Initialize OpenGL|ES
235    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
236    glPixelStorei(GL_PACK_ALIGNMENT, 4);
237    glEnableClientState(GL_VERTEX_ARRAY);
238    glEnable(GL_SCISSOR_TEST);
239    glShadeModel(GL_FLAT);
240    glDisable(GL_DITHER);
241    glDisable(GL_CULL_FACE);
242
243    const uint16_t g0 = pack565(0x0F,0x1F,0x0F);
244    const uint16_t g1 = pack565(0x17,0x2f,0x17);
245    const uint16_t textureData[4] = { g0, g1, g1, g0 };
246    glGenTextures(1, &mWormholeTexName);
247    glBindTexture(GL_TEXTURE_2D, mWormholeTexName);
248    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
249    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
250    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
251    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
252    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 2, 2, 0,
253            GL_RGB, GL_UNSIGNED_SHORT_5_6_5, textureData);
254
255    glViewport(0, 0, w, h);
256    glMatrixMode(GL_PROJECTION);
257    glLoadIdentity();
258    glOrthof(0, w, h, 0, 0, 1);
259
260   LayerDim::initDimmer(this, w, h);
261
262    mReadyToRunBarrier.open();
263
264    /*
265     *  We're now ready to accept clients...
266     */
267
268    // start boot animation
269    property_set("ctl.start", "bootanim");
270
271    return NO_ERROR;
272}
273
274// ----------------------------------------------------------------------------
275#if 0
276#pragma mark -
277#pragma mark Events Handler
278#endif
279
280void SurfaceFlinger::waitForEvent()
281{
282    while (true) {
283        nsecs_t timeout = -1;
284        const nsecs_t freezeDisplayTimeout = ms2ns(5000);
285        if (UNLIKELY(isFrozen())) {
286            // wait 5 seconds
287            const nsecs_t now = systemTime();
288            if (mFreezeDisplayTime == 0) {
289                mFreezeDisplayTime = now;
290            }
291            nsecs_t waitTime = freezeDisplayTimeout - (now - mFreezeDisplayTime);
292            timeout = waitTime>0 ? waitTime : 0;
293        }
294
295        sp<MessageBase> msg = mEventQueue.waitMessage(timeout);
296
297        // see if we timed out
298        if (isFrozen()) {
299            const nsecs_t now = systemTime();
300            nsecs_t frozenTime = (now - mFreezeDisplayTime);
301            if (frozenTime >= freezeDisplayTimeout) {
302                // we timed out and are still frozen
303                LOGW("timeout expired mFreezeDisplay=%d, mFreezeCount=%d",
304                        mFreezeDisplay, mFreezeCount);
305                mFreezeDisplayTime = 0;
306                mFreezeCount = 0;
307                mFreezeDisplay = false;
308            }
309        }
310
311        if (msg != 0) {
312            switch (msg->what) {
313                case MessageQueue::INVALIDATE:
314                    // invalidate message, just return to the main loop
315                    return;
316            }
317        }
318    }
319}
320
321void SurfaceFlinger::signalEvent() {
322    mEventQueue.invalidate();
323}
324
325void SurfaceFlinger::signal() const {
326    // this is the IPC call
327    const_cast<SurfaceFlinger*>(this)->signalEvent();
328}
329
330status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,
331        nsecs_t reltime, uint32_t flags)
332{
333    return mEventQueue.postMessage(msg, reltime, flags);
334}
335
336status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
337        nsecs_t reltime, uint32_t flags)
338{
339    status_t res = mEventQueue.postMessage(msg, reltime, flags);
340    if (res == NO_ERROR) {
341        msg->wait();
342    }
343    return res;
344}
345
346// ----------------------------------------------------------------------------
347#if 0
348#pragma mark -
349#pragma mark Main loop
350#endif
351
352bool SurfaceFlinger::threadLoop()
353{
354    waitForEvent();
355
356    // check for transactions
357    if (UNLIKELY(mConsoleSignals)) {
358        handleConsoleEvents();
359    }
360
361    if (LIKELY(mTransactionCount == 0)) {
362        // if we're in a global transaction, don't do anything.
363        const uint32_t mask = eTransactionNeeded | eTraversalNeeded;
364        uint32_t transactionFlags = getTransactionFlags(mask);
365        if (LIKELY(transactionFlags)) {
366            handleTransaction(transactionFlags);
367        }
368    }
369
370    // post surfaces (if needed)
371    handlePageFlip();
372
373    if (UNLIKELY(mHwWorkListDirty)) {
374        // build the h/w work list
375        handleWorkList();
376    }
377
378    const DisplayHardware& hw(graphicPlane(0).displayHardware());
379    if (LIKELY(hw.canDraw() && !isFrozen())) {
380        // repaint the framebuffer (if needed)
381        handleRepaint();
382
383        // inform the h/w that we're done compositing
384        hw.compositionComplete();
385
386        // release the clients before we flip ('cause flip might block)
387        unlockClients();
388
389        postFramebuffer();
390    } else {
391        // pretend we did the post
392        unlockClients();
393        usleep(16667); // 60 fps period
394    }
395    return true;
396}
397
398void SurfaceFlinger::postFramebuffer()
399{
400    if (!mInvalidRegion.isEmpty()) {
401        const DisplayHardware& hw(graphicPlane(0).displayHardware());
402        const nsecs_t now = systemTime();
403        mDebugInSwapBuffers = now;
404        hw.flip(mInvalidRegion);
405        mLastSwapBufferTime = systemTime() - now;
406        mDebugInSwapBuffers = 0;
407        mInvalidRegion.clear();
408    }
409}
410
411void SurfaceFlinger::handleConsoleEvents()
412{
413    // something to do with the console
414    const DisplayHardware& hw = graphicPlane(0).displayHardware();
415
416    int what = android_atomic_and(0, &mConsoleSignals);
417    if (what & eConsoleAcquired) {
418        hw.acquireScreen();
419    }
420
421    if (mDeferReleaseConsole && hw.canDraw()) {
422        // We got the release signal before the acquire signal
423        mDeferReleaseConsole = false;
424        hw.releaseScreen();
425    }
426
427    if (what & eConsoleReleased) {
428        if (hw.canDraw()) {
429            hw.releaseScreen();
430        } else {
431            mDeferReleaseConsole = true;
432        }
433    }
434
435    mDirtyRegion.set(hw.bounds());
436}
437
438void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
439{
440    Vector< sp<LayerBase> > ditchedLayers;
441
442    /*
443     * Perform and commit the transaction
444     */
445
446    { // scope for the lock
447        Mutex::Autolock _l(mStateLock);
448        const nsecs_t now = systemTime();
449        mDebugInTransaction = now;
450        handleTransactionLocked(transactionFlags, ditchedLayers);
451        mLastTransactionTime = systemTime() - now;
452        mDebugInTransaction = 0;
453        mHwWorkListDirty = true;
454        // here the transaction has been committed
455    }
456
457    /*
458     * Clean-up all layers that went away
459     * (do this without the lock held)
460     */
461
462    const size_t count = ditchedLayers.size();
463    for (size_t i=0 ; i<count ; i++) {
464        if (ditchedLayers[i] != 0) {
465            //LOGD("ditching layer %p", ditchedLayers[i].get());
466            ditchedLayers[i]->ditch();
467        }
468    }
469}
470
471void SurfaceFlinger::handleTransactionLocked(
472        uint32_t transactionFlags, Vector< sp<LayerBase> >& ditchedLayers)
473{
474    const LayerVector& currentLayers(mCurrentState.layersSortedByZ);
475    const size_t count = currentLayers.size();
476
477    /*
478     * Traversal of the children
479     * (perform the transaction for each of them if needed)
480     */
481
482    const bool layersNeedTransaction = transactionFlags & eTraversalNeeded;
483    if (layersNeedTransaction) {
484        for (size_t i=0 ; i<count ; i++) {
485            const sp<LayerBase>& layer = currentLayers[i];
486            uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
487            if (!trFlags) continue;
488
489            const uint32_t flags = layer->doTransaction(0);
490            if (flags & Layer::eVisibleRegion)
491                mVisibleRegionsDirty = true;
492        }
493    }
494
495    /*
496     * Perform our own transaction if needed
497     */
498
499    if (transactionFlags & eTransactionNeeded) {
500        if (mCurrentState.orientation != mDrawingState.orientation) {
501            // the orientation has changed, recompute all visible regions
502            // and invalidate everything.
503
504            const int dpy = 0;
505            const int orientation = mCurrentState.orientation;
506            const uint32_t type = mCurrentState.orientationType;
507            GraphicPlane& plane(graphicPlane(dpy));
508            plane.setOrientation(orientation);
509
510            // update the shared control block
511            const DisplayHardware& hw(plane.displayHardware());
512            volatile display_cblk_t* dcblk = mServerCblk->displays + dpy;
513            dcblk->orientation = orientation;
514            dcblk->w = plane.getWidth();
515            dcblk->h = plane.getHeight();
516
517            mVisibleRegionsDirty = true;
518            mDirtyRegion.set(hw.bounds());
519        }
520
521        if (mCurrentState.freezeDisplay != mDrawingState.freezeDisplay) {
522            // freezing or unfreezing the display -> trigger animation if needed
523            mFreezeDisplay = mCurrentState.freezeDisplay;
524            if (mFreezeDisplay)
525                 mFreezeDisplayTime = 0;
526        }
527
528        if (currentLayers.size() > mDrawingState.layersSortedByZ.size()) {
529            // layers have been added
530            mVisibleRegionsDirty = true;
531        }
532
533        // some layers might have been removed, so
534        // we need to update the regions they're exposing.
535        if (mLayersRemoved) {
536            mLayersRemoved = false;
537            mVisibleRegionsDirty = true;
538            const LayerVector& previousLayers(mDrawingState.layersSortedByZ);
539            const size_t count = previousLayers.size();
540            for (size_t i=0 ; i<count ; i++) {
541                const sp<LayerBase>& layer(previousLayers[i]);
542                if (currentLayers.indexOf( layer ) < 0) {
543                    // this layer is not visible anymore
544                    ditchedLayers.add(layer);
545                    mDirtyRegionRemovedLayer.orSelf(layer->visibleRegionScreen);
546                }
547            }
548        }
549    }
550
551    commitTransaction();
552}
553
554sp<FreezeLock> SurfaceFlinger::getFreezeLock() const
555{
556    return new FreezeLock(const_cast<SurfaceFlinger *>(this));
557}
558
559void SurfaceFlinger::computeVisibleRegions(
560    LayerVector& currentLayers, Region& dirtyRegion, Region& opaqueRegion)
561{
562    const GraphicPlane& plane(graphicPlane(0));
563    const Transform& planeTransform(plane.transform());
564    const DisplayHardware& hw(plane.displayHardware());
565    const Region screenRegion(hw.bounds());
566
567    Region aboveOpaqueLayers;
568    Region aboveCoveredLayers;
569    Region dirty;
570
571    bool secureFrameBuffer = false;
572
573    size_t i = currentLayers.size();
574    while (i--) {
575        const sp<LayerBase>& layer = currentLayers[i];
576        layer->validateVisibility(planeTransform);
577
578        // start with the whole surface at its current location
579        const Layer::State& s(layer->drawingState());
580
581        /*
582         * opaqueRegion: area of a surface that is fully opaque.
583         */
584        Region opaqueRegion;
585
586        /*
587         * visibleRegion: area of a surface that is visible on screen
588         * and not fully transparent. This is essentially the layer's
589         * footprint minus the opaque regions above it.
590         * Areas covered by a translucent surface are considered visible.
591         */
592        Region visibleRegion;
593
594        /*
595         * coveredRegion: area of a surface that is covered by all
596         * visible regions above it (which includes the translucent areas).
597         */
598        Region coveredRegion;
599
600
601        // handle hidden surfaces by setting the visible region to empty
602        if (LIKELY(!(s.flags & ISurfaceComposer::eLayerHidden) && s.alpha)) {
603            const bool translucent = layer->needsBlending();
604            const Rect bounds(layer->visibleBounds());
605            visibleRegion.set(bounds);
606            visibleRegion.andSelf(screenRegion);
607            if (!visibleRegion.isEmpty()) {
608                // Remove the transparent area from the visible region
609                if (translucent) {
610                    visibleRegion.subtractSelf(layer->transparentRegionScreen);
611                }
612
613                // compute the opaque region
614                const int32_t layerOrientation = layer->getOrientation();
615                if (s.alpha==255 && !translucent &&
616                        ((layerOrientation & Transform::ROT_INVALID) == false)) {
617                    // the opaque region is the layer's footprint
618                    opaqueRegion = visibleRegion;
619                }
620            }
621        }
622
623        // Clip the covered region to the visible region
624        coveredRegion = aboveCoveredLayers.intersect(visibleRegion);
625
626        // Update aboveCoveredLayers for next (lower) layer
627        aboveCoveredLayers.orSelf(visibleRegion);
628
629        // subtract the opaque region covered by the layers above us
630        visibleRegion.subtractSelf(aboveOpaqueLayers);
631
632        // compute this layer's dirty region
633        if (layer->contentDirty) {
634            // we need to invalidate the whole region
635            dirty = visibleRegion;
636            // as well, as the old visible region
637            dirty.orSelf(layer->visibleRegionScreen);
638            layer->contentDirty = false;
639        } else {
640            /* compute the exposed region:
641             *   the exposed region consists of two components:
642             *   1) what's VISIBLE now and was COVERED before
643             *   2) what's EXPOSED now less what was EXPOSED before
644             *
645             * note that (1) is conservative, we start with the whole
646             * visible region but only keep what used to be covered by
647             * something -- which mean it may have been exposed.
648             *
649             * (2) handles areas that were not covered by anything but got
650             * exposed because of a resize.
651             */
652            const Region newExposed = visibleRegion - coveredRegion;
653            const Region oldVisibleRegion = layer->visibleRegionScreen;
654            const Region oldCoveredRegion = layer->coveredRegionScreen;
655            const Region oldExposed = oldVisibleRegion - oldCoveredRegion;
656            dirty = (visibleRegion&oldCoveredRegion) | (newExposed-oldExposed);
657        }
658        dirty.subtractSelf(aboveOpaqueLayers);
659
660        // accumulate to the screen dirty region
661        dirtyRegion.orSelf(dirty);
662
663        // Update aboveOpaqueLayers for next (lower) layer
664        aboveOpaqueLayers.orSelf(opaqueRegion);
665
666        // Store the visible region is screen space
667        layer->setVisibleRegion(visibleRegion);
668        layer->setCoveredRegion(coveredRegion);
669
670        // If a secure layer is partially visible, lock-down the screen!
671        if (layer->isSecure() && !visibleRegion.isEmpty()) {
672            secureFrameBuffer = true;
673        }
674    }
675
676    // invalidate the areas where a layer was removed
677    dirtyRegion.orSelf(mDirtyRegionRemovedLayer);
678    mDirtyRegionRemovedLayer.clear();
679
680    mSecureFrameBuffer = secureFrameBuffer;
681    opaqueRegion = aboveOpaqueLayers;
682}
683
684
685void SurfaceFlinger::commitTransaction()
686{
687    mDrawingState = mCurrentState;
688    mResizeTransationPending = false;
689    mTransactionCV.broadcast();
690}
691
692void SurfaceFlinger::handlePageFlip()
693{
694    bool visibleRegions = mVisibleRegionsDirty;
695    LayerVector& currentLayers(
696            const_cast<LayerVector&>(mDrawingState.layersSortedByZ));
697    visibleRegions |= lockPageFlip(currentLayers);
698
699        const DisplayHardware& hw = graphicPlane(0).displayHardware();
700        const Region screenRegion(hw.bounds());
701        if (visibleRegions) {
702            Region opaqueRegion;
703            computeVisibleRegions(currentLayers, mDirtyRegion, opaqueRegion);
704
705            /*
706             *  rebuild the visible layer list
707             */
708            mVisibleLayersSortedByZ.clear();
709            const LayerVector& currentLayers(mDrawingState.layersSortedByZ);
710            size_t count = currentLayers.size();
711            mVisibleLayersSortedByZ.setCapacity(count);
712            for (size_t i=0 ; i<count ; i++) {
713                if (!currentLayers[i]->visibleRegionScreen.isEmpty())
714                    mVisibleLayersSortedByZ.add(currentLayers[i]);
715            }
716
717            mWormholeRegion = screenRegion.subtract(opaqueRegion);
718            mVisibleRegionsDirty = false;
719            mHwWorkListDirty = true;
720        }
721
722    unlockPageFlip(currentLayers);
723    mDirtyRegion.andSelf(screenRegion);
724}
725
726bool SurfaceFlinger::lockPageFlip(const LayerVector& currentLayers)
727{
728    bool recomputeVisibleRegions = false;
729    size_t count = currentLayers.size();
730    sp<LayerBase> const* layers = currentLayers.array();
731    for (size_t i=0 ; i<count ; i++) {
732        const sp<LayerBase>& layer(layers[i]);
733        layer->lockPageFlip(recomputeVisibleRegions);
734    }
735    return recomputeVisibleRegions;
736}
737
738void SurfaceFlinger::unlockPageFlip(const LayerVector& currentLayers)
739{
740    const GraphicPlane& plane(graphicPlane(0));
741    const Transform& planeTransform(plane.transform());
742    size_t count = currentLayers.size();
743    sp<LayerBase> const* layers = currentLayers.array();
744    for (size_t i=0 ; i<count ; i++) {
745        const sp<LayerBase>& layer(layers[i]);
746        layer->unlockPageFlip(planeTransform, mDirtyRegion);
747    }
748}
749
750void SurfaceFlinger::handleWorkList()
751{
752    mHwWorkListDirty = false;
753    HWComposer& hwc(graphicPlane(0).displayHardware().getHwComposer());
754    if (hwc.initCheck() == NO_ERROR) {
755        const Vector< sp<LayerBase> >& currentLayers(mVisibleLayersSortedByZ);
756        const size_t count = currentLayers.size();
757        hwc.createWorkList(count);
758        hwc_layer_t* const cur(hwc.getLayers());
759        for (size_t i=0 ; cur && i<count ; i++) {
760            currentLayers[i]->setGeometry(&cur[i]);
761        }
762    }
763}
764
765void SurfaceFlinger::handleRepaint()
766{
767    // compute the invalid region
768    mInvalidRegion.orSelf(mDirtyRegion);
769    if (mInvalidRegion.isEmpty()) {
770        // nothing to do
771        return;
772    }
773
774    if (UNLIKELY(mDebugRegion)) {
775        debugFlashRegions();
776    }
777
778    // set the frame buffer
779    const DisplayHardware& hw(graphicPlane(0).displayHardware());
780    glMatrixMode(GL_MODELVIEW);
781    glLoadIdentity();
782
783    uint32_t flags = hw.getFlags();
784    if ((flags & DisplayHardware::SWAP_RECTANGLE) ||
785        (flags & DisplayHardware::BUFFER_PRESERVED))
786    {
787        // we can redraw only what's dirty, but since SWAP_RECTANGLE only
788        // takes a rectangle, we must make sure to update that whole
789        // rectangle in that case
790        if (flags & DisplayHardware::SWAP_RECTANGLE) {
791            // TODO: we really should be able to pass a region to
792            // SWAP_RECTANGLE so that we don't have to redraw all this.
793            mDirtyRegion.set(mInvalidRegion.bounds());
794        } else {
795            // in the BUFFER_PRESERVED case, obviously, we can update only
796            // what's needed and nothing more.
797            // NOTE: this is NOT a common case, as preserving the backbuffer
798            // is costly and usually involves copying the whole update back.
799        }
800    } else {
801        if (flags & DisplayHardware::PARTIAL_UPDATES) {
802            // We need to redraw the rectangle that will be updated
803            // (pushed to the framebuffer).
804            // This is needed because PARTIAL_UPDATES only takes one
805            // rectangle instead of a region (see DisplayHardware::flip())
806            mDirtyRegion.set(mInvalidRegion.bounds());
807        } else {
808            // we need to redraw everything (the whole screen)
809            mDirtyRegion.set(hw.bounds());
810            mInvalidRegion = mDirtyRegion;
811        }
812    }
813
814    // compose all surfaces
815    composeSurfaces(mDirtyRegion);
816
817    // clear the dirty regions
818    mDirtyRegion.clear();
819}
820
821void SurfaceFlinger::composeSurfaces(const Region& dirty)
822{
823    if (UNLIKELY(!mWormholeRegion.isEmpty())) {
824        // should never happen unless the window manager has a bug
825        // draw something...
826        drawWormhole();
827    }
828
829    status_t err = NO_ERROR;
830    const Vector< sp<LayerBase> >& layers(mVisibleLayersSortedByZ);
831    size_t count = layers.size();
832
833    const DisplayHardware& hw(graphicPlane(0).displayHardware());
834    HWComposer& hwc(hw.getHwComposer());
835    hwc_layer_t* const cur(hwc.getLayers());
836
837    LOGE_IF(cur && hwc.getNumLayers() != count,
838            "HAL number of layers (%d) doesn't match surfaceflinger (%d)",
839            hwc.getNumLayers(), count);
840
841    // just to be extra-safe, use the smallest count
842    if (hwc.initCheck() == NO_ERROR) {
843        count = count < hwc.getNumLayers() ? count : hwc.getNumLayers();
844    }
845
846    /*
847     *  update the per-frame h/w composer data for each layer
848     *  and build the transparent region of the FB
849     */
850    Region transparent;
851    if (cur) {
852        for (size_t i=0 ; i<count ; i++) {
853            const sp<LayerBase>& layer(layers[i]);
854            layer->setPerFrameData(&cur[i]);
855            if (cur[i].hints & HWC_HINT_CLEAR_FB) {
856                if (!(layer->needsBlending())) {
857                    transparent.orSelf(layer->visibleRegionScreen);
858                }
859            }
860        }
861        err = hwc.prepare();
862        LOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
863    }
864
865    /*
866     *  clear the area of the FB that need to be transparent
867     */
868    transparent.andSelf(dirty);
869    if (!transparent.isEmpty()) {
870        glClearColor(0,0,0,0);
871        Region::const_iterator it = transparent.begin();
872        Region::const_iterator const end = transparent.end();
873        const int32_t height = hw.getHeight();
874        while (it != end) {
875            const Rect& r(*it++);
876            const GLint sy = height - (r.top + r.height());
877            glScissor(r.left, sy, r.width(), r.height());
878            glClear(GL_COLOR_BUFFER_BIT);
879        }
880    }
881
882
883    /*
884     * and then, render the layers targeted at the framebuffer
885     */
886    for (size_t i=0 ; i<count ; i++) {
887        if (cur) {
888            if (!(cur[i].compositionType == HWC_FRAMEBUFFER) ||
889                    cur[i].flags & HWC_SKIP_LAYER) {
890                // skip layers handled by the HAL
891                continue;
892            }
893        }
894        const sp<LayerBase>& layer(layers[i]);
895        const Region clip(dirty.intersect(layer->visibleRegionScreen));
896        if (!clip.isEmpty()) {
897            layer->draw(clip);
898        }
899    }
900}
901
902void SurfaceFlinger::unlockClients()
903{
904    const LayerVector& drawingLayers(mDrawingState.layersSortedByZ);
905    const size_t count = drawingLayers.size();
906    sp<LayerBase> const* const layers = drawingLayers.array();
907    for (size_t i=0 ; i<count ; ++i) {
908        const sp<LayerBase>& layer = layers[i];
909        layer->finishPageFlip();
910    }
911}
912
913void SurfaceFlinger::debugFlashRegions()
914{
915    const DisplayHardware& hw(graphicPlane(0).displayHardware());
916    const uint32_t flags = hw.getFlags();
917
918    if (!((flags & DisplayHardware::SWAP_RECTANGLE) ||
919            (flags & DisplayHardware::BUFFER_PRESERVED))) {
920        const Region repaint((flags & DisplayHardware::PARTIAL_UPDATES) ?
921                mDirtyRegion.bounds() : hw.bounds());
922        composeSurfaces(repaint);
923    }
924
925    TextureManager::deactivateTextures();
926
927    glDisable(GL_BLEND);
928    glDisable(GL_DITHER);
929    glDisable(GL_SCISSOR_TEST);
930
931    static int toggle = 0;
932    toggle = 1 - toggle;
933    if (toggle) {
934        glColor4f(1, 0, 1, 1);
935    } else {
936        glColor4f(1, 1, 0, 1);
937    }
938
939    Region::const_iterator it = mDirtyRegion.begin();
940    Region::const_iterator const end = mDirtyRegion.end();
941    while (it != end) {
942        const Rect& r = *it++;
943        GLfloat vertices[][2] = {
944                { r.left,  r.top },
945                { r.left,  r.bottom },
946                { r.right, r.bottom },
947                { r.right, r.top }
948        };
949        glVertexPointer(2, GL_FLOAT, 0, vertices);
950        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
951    }
952
953    if (mInvalidRegion.isEmpty()) {
954        mDirtyRegion.dump("mDirtyRegion");
955        mInvalidRegion.dump("mInvalidRegion");
956    }
957    hw.flip(mInvalidRegion);
958
959    if (mDebugRegion > 1)
960        usleep(mDebugRegion * 1000);
961
962    glEnable(GL_SCISSOR_TEST);
963    //mDirtyRegion.dump("mDirtyRegion");
964}
965
966void SurfaceFlinger::drawWormhole() const
967{
968    const Region region(mWormholeRegion.intersect(mDirtyRegion));
969    if (region.isEmpty())
970        return;
971
972    const DisplayHardware& hw(graphicPlane(0).displayHardware());
973    const int32_t width = hw.getWidth();
974    const int32_t height = hw.getHeight();
975
976    glDisable(GL_BLEND);
977    glDisable(GL_DITHER);
978
979    if (LIKELY(!mDebugBackground)) {
980        glClearColor(0,0,0,0);
981        Region::const_iterator it = region.begin();
982        Region::const_iterator const end = region.end();
983        while (it != end) {
984            const Rect& r = *it++;
985            const GLint sy = height - (r.top + r.height());
986            glScissor(r.left, sy, r.width(), r.height());
987            glClear(GL_COLOR_BUFFER_BIT);
988        }
989    } else {
990        const GLshort vertices[][2] = { { 0, 0 }, { width, 0 },
991                { width, height }, { 0, height }  };
992        const GLshort tcoords[][2] = { { 0, 0 }, { 1, 0 },  { 1, 1 }, { 0, 1 } };
993        glVertexPointer(2, GL_SHORT, 0, vertices);
994        glTexCoordPointer(2, GL_SHORT, 0, tcoords);
995        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
996#if defined(GL_OES_texture_external)
997        if (GLExtensions::getInstance().haveTextureExternal()) {
998            glDisable(GL_TEXTURE_EXTERNAL_OES);
999        }
1000#endif
1001        glEnable(GL_TEXTURE_2D);
1002        glBindTexture(GL_TEXTURE_2D, mWormholeTexName);
1003        glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1004        glMatrixMode(GL_TEXTURE);
1005        glLoadIdentity();
1006        glScalef(width*(1.0f/32.0f), height*(1.0f/32.0f), 1);
1007        Region::const_iterator it = region.begin();
1008        Region::const_iterator const end = region.end();
1009        while (it != end) {
1010            const Rect& r = *it++;
1011            const GLint sy = height - (r.top + r.height());
1012            glScissor(r.left, sy, r.width(), r.height());
1013            glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1014        }
1015        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1016    }
1017}
1018
1019void SurfaceFlinger::debugShowFPS() const
1020{
1021    static int mFrameCount;
1022    static int mLastFrameCount = 0;
1023    static nsecs_t mLastFpsTime = 0;
1024    static float mFps = 0;
1025    mFrameCount++;
1026    nsecs_t now = systemTime();
1027    nsecs_t diff = now - mLastFpsTime;
1028    if (diff > ms2ns(250)) {
1029        mFps =  ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
1030        mLastFpsTime = now;
1031        mLastFrameCount = mFrameCount;
1032    }
1033    // XXX: mFPS has the value we want
1034 }
1035
1036status_t SurfaceFlinger::addLayer(const sp<LayerBase>& layer)
1037{
1038    Mutex::Autolock _l(mStateLock);
1039    addLayer_l(layer);
1040    setTransactionFlags(eTransactionNeeded|eTraversalNeeded);
1041    return NO_ERROR;
1042}
1043
1044status_t SurfaceFlinger::addLayer_l(const sp<LayerBase>& layer)
1045{
1046    ssize_t i = mCurrentState.layersSortedByZ.add(layer);
1047    return (i < 0) ? status_t(i) : status_t(NO_ERROR);
1048}
1049
1050ssize_t SurfaceFlinger::addClientLayer(const sp<Client>& client,
1051        const sp<LayerBaseClient>& lbc)
1052{
1053    Mutex::Autolock _l(mStateLock);
1054
1055    // attach this layer to the client
1056    ssize_t name = client->attachLayer(lbc);
1057
1058    // add this layer to the current state list
1059    addLayer_l(lbc);
1060
1061    return name;
1062}
1063
1064status_t SurfaceFlinger::removeLayer(const sp<LayerBase>& layer)
1065{
1066    Mutex::Autolock _l(mStateLock);
1067    status_t err = purgatorizeLayer_l(layer);
1068    if (err == NO_ERROR)
1069        setTransactionFlags(eTransactionNeeded);
1070    return err;
1071}
1072
1073status_t SurfaceFlinger::removeLayer_l(const sp<LayerBase>& layerBase)
1074{
1075    sp<LayerBaseClient> lbc(layerBase->getLayerBaseClient());
1076    if (lbc != 0) {
1077        mLayerMap.removeItem( lbc->getSurface()->asBinder() );
1078    }
1079    ssize_t index = mCurrentState.layersSortedByZ.remove(layerBase);
1080    if (index >= 0) {
1081        mLayersRemoved = true;
1082        return NO_ERROR;
1083    }
1084    return status_t(index);
1085}
1086
1087status_t SurfaceFlinger::purgatorizeLayer_l(const sp<LayerBase>& layerBase)
1088{
1089    // remove the layer from the main list (through a transaction).
1090    ssize_t err = removeLayer_l(layerBase);
1091
1092    layerBase->onRemoved();
1093
1094    // it's possible that we don't find a layer, because it might
1095    // have been destroyed already -- this is not technically an error
1096    // from the user because there is a race between Client::destroySurface(),
1097    // ~Client() and ~ISurface().
1098    return (err == NAME_NOT_FOUND) ? status_t(NO_ERROR) : err;
1099}
1100
1101status_t SurfaceFlinger::invalidateLayerVisibility(const sp<LayerBase>& layer)
1102{
1103    layer->forceVisibilityTransaction();
1104    setTransactionFlags(eTraversalNeeded);
1105    return NO_ERROR;
1106}
1107
1108uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags)
1109{
1110    return android_atomic_and(~flags, &mTransactionFlags) & flags;
1111}
1112
1113uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags)
1114{
1115    uint32_t old = android_atomic_or(flags, &mTransactionFlags);
1116    if ((old & flags)==0) { // wake the server up
1117        signalEvent();
1118    }
1119    return old;
1120}
1121
1122void SurfaceFlinger::openGlobalTransaction()
1123{
1124    android_atomic_inc(&mTransactionCount);
1125}
1126
1127void SurfaceFlinger::closeGlobalTransaction()
1128{
1129    if (android_atomic_dec(&mTransactionCount) == 1) {
1130        signalEvent();
1131
1132        // if there is a transaction with a resize, wait for it to
1133        // take effect before returning.
1134        Mutex::Autolock _l(mStateLock);
1135        while (mResizeTransationPending) {
1136            status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
1137            if (CC_UNLIKELY(err != NO_ERROR)) {
1138                // just in case something goes wrong in SF, return to the
1139                // called after a few seconds.
1140                LOGW_IF(err == TIMED_OUT, "closeGlobalTransaction timed out!");
1141                mResizeTransationPending = false;
1142                break;
1143            }
1144        }
1145    }
1146}
1147
1148status_t SurfaceFlinger::freezeDisplay(DisplayID dpy, uint32_t flags)
1149{
1150    if (UNLIKELY(uint32_t(dpy) >= DISPLAY_COUNT))
1151        return BAD_VALUE;
1152
1153    Mutex::Autolock _l(mStateLock);
1154    mCurrentState.freezeDisplay = 1;
1155    setTransactionFlags(eTransactionNeeded);
1156
1157    // flags is intended to communicate some sort of animation behavior
1158    // (for instance fading)
1159    return NO_ERROR;
1160}
1161
1162status_t SurfaceFlinger::unfreezeDisplay(DisplayID dpy, uint32_t flags)
1163{
1164    if (UNLIKELY(uint32_t(dpy) >= DISPLAY_COUNT))
1165        return BAD_VALUE;
1166
1167    Mutex::Autolock _l(mStateLock);
1168    mCurrentState.freezeDisplay = 0;
1169    setTransactionFlags(eTransactionNeeded);
1170
1171    // flags is intended to communicate some sort of animation behavior
1172    // (for instance fading)
1173    return NO_ERROR;
1174}
1175
1176int SurfaceFlinger::setOrientation(DisplayID dpy,
1177        int orientation, uint32_t flags)
1178{
1179    if (UNLIKELY(uint32_t(dpy) >= DISPLAY_COUNT))
1180        return BAD_VALUE;
1181
1182    Mutex::Autolock _l(mStateLock);
1183    if (mCurrentState.orientation != orientation) {
1184        if (uint32_t(orientation)<=eOrientation270 || orientation==42) {
1185            mCurrentState.orientationType = flags;
1186            mCurrentState.orientation = orientation;
1187            setTransactionFlags(eTransactionNeeded);
1188            mTransactionCV.wait(mStateLock);
1189        } else {
1190            orientation = BAD_VALUE;
1191        }
1192    }
1193    return orientation;
1194}
1195
1196sp<ISurface> SurfaceFlinger::createSurface(const sp<Client>& client, int pid,
1197        const String8& name, ISurfaceComposerClient::surface_data_t* params,
1198        DisplayID d, uint32_t w, uint32_t h, PixelFormat format,
1199        uint32_t flags)
1200{
1201    sp<LayerBaseClient> layer;
1202    sp<LayerBaseClient::Surface> surfaceHandle;
1203
1204    if (int32_t(w|h) < 0) {
1205        LOGE("createSurface() failed, w or h is negative (w=%d, h=%d)",
1206                int(w), int(h));
1207        return surfaceHandle;
1208    }
1209
1210    //LOGD("createSurface for pid %d (%d x %d)", pid, w, h);
1211    sp<Layer> normalLayer;
1212    switch (flags & eFXSurfaceMask) {
1213        case eFXSurfaceNormal:
1214            if (UNLIKELY(flags & ePushBuffers)) {
1215                layer = createPushBuffersSurface(client, d, w, h, flags);
1216            } else {
1217                normalLayer = createNormalSurface(client, d, w, h, flags, format);
1218                layer = normalLayer;
1219            }
1220            break;
1221        case eFXSurfaceBlur:
1222            layer = createBlurSurface(client, d, w, h, flags);
1223            break;
1224        case eFXSurfaceDim:
1225            layer = createDimSurface(client, d, w, h, flags);
1226            break;
1227    }
1228
1229    if (layer != 0) {
1230        layer->initStates(w, h, flags);
1231        layer->setName(name);
1232        ssize_t token = addClientLayer(client, layer);
1233
1234        surfaceHandle = layer->getSurface();
1235        if (surfaceHandle != 0) {
1236            params->token = token;
1237            params->identity = surfaceHandle->getIdentity();
1238            params->width = w;
1239            params->height = h;
1240            params->format = format;
1241            if (normalLayer != 0) {
1242                Mutex::Autolock _l(mStateLock);
1243                mLayerMap.add(surfaceHandle->asBinder(), normalLayer);
1244            }
1245        }
1246
1247        setTransactionFlags(eTransactionNeeded);
1248    }
1249
1250    return surfaceHandle;
1251}
1252
1253sp<Layer> SurfaceFlinger::createNormalSurface(
1254        const sp<Client>& client, DisplayID display,
1255        uint32_t w, uint32_t h, uint32_t flags,
1256        PixelFormat& format)
1257{
1258    // initialize the surfaces
1259    switch (format) { // TODO: take h/w into account
1260    case PIXEL_FORMAT_TRANSPARENT:
1261    case PIXEL_FORMAT_TRANSLUCENT:
1262        format = PIXEL_FORMAT_RGBA_8888;
1263        break;
1264    case PIXEL_FORMAT_OPAQUE:
1265#ifdef NO_RGBX_8888
1266        format = PIXEL_FORMAT_RGB_565;
1267#else
1268        format = PIXEL_FORMAT_RGBX_8888;
1269#endif
1270        break;
1271    }
1272
1273#ifdef NO_RGBX_8888
1274    if (format == PIXEL_FORMAT_RGBX_8888)
1275        format = PIXEL_FORMAT_RGBA_8888;
1276#endif
1277
1278    sp<Layer> layer = new Layer(this, display, client);
1279    status_t err = layer->setBuffers(w, h, format, flags);
1280    if (LIKELY(err != NO_ERROR)) {
1281        LOGE("createNormalSurfaceLocked() failed (%s)", strerror(-err));
1282        layer.clear();
1283    }
1284    return layer;
1285}
1286
1287sp<LayerBlur> SurfaceFlinger::createBlurSurface(
1288        const sp<Client>& client, DisplayID display,
1289        uint32_t w, uint32_t h, uint32_t flags)
1290{
1291    sp<LayerBlur> layer = new LayerBlur(this, display, client);
1292    layer->initStates(w, h, flags);
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
1305sp<LayerBuffer> SurfaceFlinger::createPushBuffersSurface(
1306        const sp<Client>& client, DisplayID display,
1307        uint32_t w, uint32_t h, uint32_t flags)
1308{
1309    sp<LayerBuffer> layer = new LayerBuffer(this, display, client);
1310    layer->initStates(w, h, flags);
1311    return layer;
1312}
1313
1314status_t SurfaceFlinger::removeSurface(const sp<Client>& client, SurfaceID sid)
1315{
1316    /*
1317     * called by the window manager, when a surface should be marked for
1318     * destruction.
1319     *
1320     * The surface is removed from the current and drawing lists, but placed
1321     * in the purgatory queue, so it's not destroyed right-away (we need
1322     * to wait for all client's references to go away first).
1323     */
1324
1325    status_t err = NAME_NOT_FOUND;
1326    Mutex::Autolock _l(mStateLock);
1327    sp<LayerBaseClient> layer = client->getLayerUser(sid);
1328    if (layer != 0) {
1329        err = purgatorizeLayer_l(layer);
1330        if (err == NO_ERROR) {
1331            setTransactionFlags(eTransactionNeeded);
1332        }
1333    }
1334    return err;
1335}
1336
1337status_t SurfaceFlinger::destroySurface(const sp<LayerBaseClient>& layer)
1338{
1339    // called by ~ISurface() when all references are gone
1340
1341    class MessageDestroySurface : public MessageBase {
1342        SurfaceFlinger* flinger;
1343        sp<LayerBaseClient> layer;
1344    public:
1345        MessageDestroySurface(
1346                SurfaceFlinger* flinger, const sp<LayerBaseClient>& layer)
1347            : flinger(flinger), layer(layer) { }
1348        virtual bool handler() {
1349            sp<LayerBaseClient> l(layer);
1350            layer.clear(); // clear it outside of the lock;
1351            Mutex::Autolock _l(flinger->mStateLock);
1352            /*
1353             * remove the layer from the current list -- chances are that it's
1354             * not in the list anyway, because it should have been removed
1355             * already upon request of the client (eg: window manager).
1356             * However, a buggy client could have not done that.
1357             * Since we know we don't have any more clients, we don't need
1358             * to use the purgatory.
1359             */
1360            status_t err = flinger->removeLayer_l(l);
1361            LOGE_IF(err<0 && err != NAME_NOT_FOUND,
1362                    "error removing layer=%p (%s)", l.get(), strerror(-err));
1363            return true;
1364        }
1365    };
1366
1367    postMessageAsync( new MessageDestroySurface(this, layer) );
1368    return NO_ERROR;
1369}
1370
1371status_t SurfaceFlinger::setClientState(
1372        const sp<Client>& client,
1373        int32_t count,
1374        const layer_state_t* states)
1375{
1376    Mutex::Autolock _l(mStateLock);
1377    uint32_t flags = 0;
1378    for (int i=0 ; i<count ; i++) {
1379        const layer_state_t& s(states[i]);
1380        sp<LayerBaseClient> layer(client->getLayerUser(s.surface));
1381        if (layer != 0) {
1382            const uint32_t what = s.what;
1383            if (what & ePositionChanged) {
1384                if (layer->setPosition(s.x, s.y))
1385                    flags |= eTraversalNeeded;
1386            }
1387            if (what & eLayerChanged) {
1388                ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
1389                if (layer->setLayer(s.z)) {
1390                    mCurrentState.layersSortedByZ.removeAt(idx);
1391                    mCurrentState.layersSortedByZ.add(layer);
1392                    // we need traversal (state changed)
1393                    // AND transaction (list changed)
1394                    flags |= eTransactionNeeded|eTraversalNeeded;
1395                }
1396            }
1397            if (what & eSizeChanged) {
1398                if (layer->setSize(s.w, s.h)) {
1399                    flags |= eTraversalNeeded;
1400                    mResizeTransationPending = true;
1401                }
1402            }
1403            if (what & eAlphaChanged) {
1404                if (layer->setAlpha(uint8_t(255.0f*s.alpha+0.5f)))
1405                    flags |= eTraversalNeeded;
1406            }
1407            if (what & eMatrixChanged) {
1408                if (layer->setMatrix(s.matrix))
1409                    flags |= eTraversalNeeded;
1410            }
1411            if (what & eTransparentRegionChanged) {
1412                if (layer->setTransparentRegionHint(s.transparentRegion))
1413                    flags |= eTraversalNeeded;
1414            }
1415            if (what & eVisibilityChanged) {
1416                if (layer->setFlags(s.flags, s.mask))
1417                    flags |= eTraversalNeeded;
1418            }
1419        }
1420    }
1421    if (flags) {
1422        setTransactionFlags(flags);
1423    }
1424    return NO_ERROR;
1425}
1426
1427void SurfaceFlinger::screenReleased(int dpy)
1428{
1429    // this may be called by a signal handler, we can't do too much in here
1430    android_atomic_or(eConsoleReleased, &mConsoleSignals);
1431    signalEvent();
1432}
1433
1434void SurfaceFlinger::screenAcquired(int dpy)
1435{
1436    // this may be called by a signal handler, we can't do too much in here
1437    android_atomic_or(eConsoleAcquired, &mConsoleSignals);
1438    signalEvent();
1439}
1440
1441status_t SurfaceFlinger::dump(int fd, const Vector<String16>& args)
1442{
1443    const size_t SIZE = 1024;
1444    char buffer[SIZE];
1445    String8 result;
1446    if (!mDump.checkCalling()) {
1447        snprintf(buffer, SIZE, "Permission Denial: "
1448                "can't dump SurfaceFlinger from pid=%d, uid=%d\n",
1449                IPCThreadState::self()->getCallingPid(),
1450                IPCThreadState::self()->getCallingUid());
1451        result.append(buffer);
1452    } else {
1453
1454        // figure out if we're stuck somewhere
1455        const nsecs_t now = systemTime();
1456        const nsecs_t inSwapBuffers(mDebugInSwapBuffers);
1457        const nsecs_t inTransaction(mDebugInTransaction);
1458        nsecs_t inSwapBuffersDuration = (inSwapBuffers) ? now-inSwapBuffers : 0;
1459        nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
1460
1461        // Try to get the main lock, but don't insist if we can't
1462        // (this would indicate SF is stuck, but we want to be able to
1463        // print something in dumpsys).
1464        int retry = 3;
1465        while (mStateLock.tryLock()<0 && --retry>=0) {
1466            usleep(1000000);
1467        }
1468        const bool locked(retry >= 0);
1469        if (!locked) {
1470            snprintf(buffer, SIZE,
1471                    "SurfaceFlinger appears to be unresponsive, "
1472                    "dumping anyways (no locks held)\n");
1473            result.append(buffer);
1474        }
1475
1476        const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
1477        const size_t count = currentLayers.size();
1478        for (size_t i=0 ; i<count ; i++) {
1479            const sp<LayerBase>& layer(currentLayers[i]);
1480            layer->dump(result, buffer, SIZE);
1481            const Layer::State& s(layer->drawingState());
1482            s.transparentRegion.dump(result, "transparentRegion");
1483            layer->transparentRegionScreen.dump(result, "transparentRegionScreen");
1484            layer->visibleRegionScreen.dump(result, "visibleRegionScreen");
1485        }
1486
1487        mWormholeRegion.dump(result, "WormholeRegion");
1488        const DisplayHardware& hw(graphicPlane(0).displayHardware());
1489        snprintf(buffer, SIZE,
1490                "  display frozen: %s, freezeCount=%d, orientation=%d, canDraw=%d\n",
1491                mFreezeDisplay?"yes":"no", mFreezeCount,
1492                mCurrentState.orientation, hw.canDraw());
1493        result.append(buffer);
1494        snprintf(buffer, SIZE,
1495                "  last eglSwapBuffers() time: %f us\n"
1496                "  last transaction time     : %f us\n",
1497                mLastSwapBufferTime/1000.0, mLastTransactionTime/1000.0);
1498        result.append(buffer);
1499
1500        if (inSwapBuffersDuration || !locked) {
1501            snprintf(buffer, SIZE, "  eglSwapBuffers time: %f us\n",
1502                    inSwapBuffersDuration/1000.0);
1503            result.append(buffer);
1504        }
1505
1506        if (inTransactionDuration || !locked) {
1507            snprintf(buffer, SIZE, "  transaction time: %f us\n",
1508                    inTransactionDuration/1000.0);
1509            result.append(buffer);
1510        }
1511
1512        const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
1513        alloc.dump(result);
1514
1515        if (locked) {
1516            mStateLock.unlock();
1517        }
1518    }
1519    write(fd, result.string(), result.size());
1520    return NO_ERROR;
1521}
1522
1523status_t SurfaceFlinger::onTransact(
1524    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
1525{
1526    switch (code) {
1527        case CREATE_CONNECTION:
1528        case OPEN_GLOBAL_TRANSACTION:
1529        case CLOSE_GLOBAL_TRANSACTION:
1530        case SET_ORIENTATION:
1531        case FREEZE_DISPLAY:
1532        case UNFREEZE_DISPLAY:
1533        case BOOT_FINISHED:
1534        {
1535            // codes that require permission check
1536            IPCThreadState* ipc = IPCThreadState::self();
1537            const int pid = ipc->getCallingPid();
1538            const int uid = ipc->getCallingUid();
1539            if ((uid != AID_GRAPHICS) && !mAccessSurfaceFlinger.check(pid, uid)) {
1540                LOGE("Permission Denial: "
1541                        "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
1542                return PERMISSION_DENIED;
1543            }
1544        }
1545    }
1546    status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
1547    if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
1548        CHECK_INTERFACE(ISurfaceComposer, data, reply);
1549        if (UNLIKELY(!mHardwareTest.checkCalling())) {
1550            IPCThreadState* ipc = IPCThreadState::self();
1551            const int pid = ipc->getCallingPid();
1552            const int uid = ipc->getCallingUid();
1553            LOGE("Permission Denial: "
1554                    "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
1555            return PERMISSION_DENIED;
1556        }
1557        int n;
1558        switch (code) {
1559            case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
1560                return NO_ERROR;
1561            case 1001:  // SHOW_FPS, NOT SUPPORTED ANYMORE
1562                return NO_ERROR;
1563            case 1002:  // SHOW_UPDATES
1564                n = data.readInt32();
1565                mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
1566                return NO_ERROR;
1567            case 1003:  // SHOW_BACKGROUND
1568                n = data.readInt32();
1569                mDebugBackground = n ? 1 : 0;
1570                return NO_ERROR;
1571            case 1004:{ // repaint everything
1572                Mutex::Autolock _l(mStateLock);
1573                const DisplayHardware& hw(graphicPlane(0).displayHardware());
1574                mDirtyRegion.set(hw.bounds()); // careful that's not thread-safe
1575                signalEvent();
1576                return NO_ERROR;
1577            }
1578            case 1005:{ // force transaction
1579                setTransactionFlags(eTransactionNeeded|eTraversalNeeded);
1580                return NO_ERROR;
1581            }
1582            case 1007: // set mFreezeCount
1583                mFreezeCount = data.readInt32();
1584                mFreezeDisplayTime = 0;
1585                return NO_ERROR;
1586            case 1010:  // interrogate.
1587                reply->writeInt32(0);
1588                reply->writeInt32(0);
1589                reply->writeInt32(mDebugRegion);
1590                reply->writeInt32(mDebugBackground);
1591                return NO_ERROR;
1592            case 1013: {
1593                Mutex::Autolock _l(mStateLock);
1594                const DisplayHardware& hw(graphicPlane(0).displayHardware());
1595                reply->writeInt32(hw.getPageFlipCount());
1596            }
1597            return NO_ERROR;
1598        }
1599    }
1600    return err;
1601}
1602
1603// ---------------------------------------------------------------------------
1604
1605sp<Layer> SurfaceFlinger::getLayer(const sp<ISurface>& sur) const
1606{
1607    sp<Layer> result;
1608    Mutex::Autolock _l(mStateLock);
1609    result = mLayerMap.valueFor( sur->asBinder() ).promote();
1610    return result;
1611}
1612
1613// ---------------------------------------------------------------------------
1614
1615Client::Client(const sp<SurfaceFlinger>& flinger)
1616    : mFlinger(flinger), mNameGenerator(1)
1617{
1618}
1619
1620Client::~Client()
1621{
1622    const size_t count = mLayers.size();
1623    for (size_t i=0 ; i<count ; i++) {
1624        sp<LayerBaseClient> layer(mLayers.valueAt(i).promote());
1625        if (layer != 0) {
1626            mFlinger->removeLayer(layer);
1627        }
1628    }
1629}
1630
1631status_t Client::initCheck() const {
1632    return NO_ERROR;
1633}
1634
1635ssize_t Client::attachLayer(const sp<LayerBaseClient>& layer)
1636{
1637    int32_t name = android_atomic_inc(&mNameGenerator);
1638    mLayers.add(name, layer);
1639    return name;
1640}
1641
1642void Client::detachLayer(const LayerBaseClient* layer)
1643{
1644    // we do a linear search here, because this doesn't happen often
1645    const size_t count = mLayers.size();
1646    for (size_t i=0 ; i<count ; i++) {
1647        if (mLayers.valueAt(i) == layer) {
1648            mLayers.removeItemsAt(i, 1);
1649            break;
1650        }
1651    }
1652}
1653sp<LayerBaseClient> Client::getLayerUser(int32_t i) const {
1654    sp<LayerBaseClient> lbc;
1655    const wp<LayerBaseClient>& layer(mLayers.valueFor(i));
1656    if (layer != 0) {
1657        lbc = layer.promote();
1658        LOGE_IF(lbc==0, "getLayerUser(name=%d) is dead", int(i));
1659    }
1660    return lbc;
1661}
1662
1663sp<IMemoryHeap> Client::getControlBlock() const {
1664    return 0;
1665}
1666ssize_t Client::getTokenForSurface(const sp<ISurface>& sur) const {
1667    return -1;
1668}
1669sp<ISurface> Client::createSurface(
1670        ISurfaceComposerClient::surface_data_t* params, int pid,
1671        const String8& name,
1672        DisplayID display, uint32_t w, uint32_t h, PixelFormat format,
1673        uint32_t flags)
1674{
1675    return mFlinger->createSurface(this, pid, name, params,
1676            display, w, h, format, flags);
1677}
1678status_t Client::destroySurface(SurfaceID sid) {
1679    return mFlinger->removeSurface(this, sid);
1680}
1681status_t Client::setState(int32_t count, const layer_state_t* states) {
1682    return mFlinger->setClientState(this, count, states);
1683}
1684
1685// ---------------------------------------------------------------------------
1686
1687UserClient::UserClient(const sp<SurfaceFlinger>& flinger)
1688    : ctrlblk(0), mBitmap(0), mFlinger(flinger)
1689{
1690    const int pgsize = getpagesize();
1691    const int cblksize = ((sizeof(SharedClient)+(pgsize-1))&~(pgsize-1));
1692
1693    mCblkHeap = new MemoryHeapBase(cblksize, 0,
1694            "SurfaceFlinger Client control-block");
1695
1696    ctrlblk = static_cast<SharedClient *>(mCblkHeap->getBase());
1697    if (ctrlblk) { // construct the shared structure in-place.
1698        new(ctrlblk) SharedClient;
1699    }
1700}
1701
1702UserClient::~UserClient()
1703{
1704    if (ctrlblk) {
1705        ctrlblk->~SharedClient();  // destroy our shared-structure.
1706    }
1707
1708    /*
1709     * When a UserClient dies, it's unclear what to do exactly.
1710     * We could go ahead and destroy all surfaces linked to that client
1711     * however, it wouldn't be fair to the main Client
1712     * (usually the the window-manager), which might want to re-target
1713     * the layer to another UserClient.
1714     * I think the best is to do nothing, or not much; in most cases the
1715     * WM itself will go ahead and clean things up when it detects a client of
1716     * his has died.
1717     * The remaining question is what to display? currently we keep
1718     * just keep the current buffer.
1719     */
1720}
1721
1722status_t UserClient::initCheck() const {
1723    return ctrlblk == 0 ? NO_INIT : NO_ERROR;
1724}
1725
1726void UserClient::detachLayer(const Layer* layer)
1727{
1728    int32_t name = layer->getToken();
1729    if (name >= 0) {
1730        int32_t mask = 1LU<<name;
1731        if ((android_atomic_and(~mask, &mBitmap) & mask) == 0) {
1732            LOGW("token %d wasn't marked as used %08x", name, int(mBitmap));
1733        }
1734    }
1735}
1736
1737sp<IMemoryHeap> UserClient::getControlBlock() const {
1738    return mCblkHeap;
1739}
1740
1741ssize_t UserClient::getTokenForSurface(const sp<ISurface>& sur) const
1742{
1743    int32_t name = NAME_NOT_FOUND;
1744    sp<Layer> layer(mFlinger->getLayer(sur));
1745    if (layer == 0) return name;
1746
1747    // if this layer already has a token, just return it
1748    name = layer->getToken();
1749    if ((name >= 0) && (layer->getClient() == this))
1750        return name;
1751
1752    name = 0;
1753    do {
1754        int32_t mask = 1LU<<name;
1755        if ((android_atomic_or(mask, &mBitmap) & mask) == 0) {
1756            // we found and locked that name
1757            status_t err = layer->setToken(
1758                    const_cast<UserClient*>(this), ctrlblk, name);
1759            if (err != NO_ERROR) {
1760                // free the name
1761                android_atomic_and(~mask, &mBitmap);
1762                name = err;
1763            }
1764            break;
1765        }
1766        if (++name > 31)
1767            name = NO_MEMORY;
1768    } while(name >= 0);
1769
1770    //LOGD("getTokenForSurface(%p) => %d (client=%p, bitmap=%08lx)",
1771    //        sur->asBinder().get(), name, this, mBitmap);
1772    return name;
1773}
1774
1775sp<ISurface> UserClient::createSurface(
1776        ISurfaceComposerClient::surface_data_t* params, int pid,
1777        const String8& name,
1778        DisplayID display, uint32_t w, uint32_t h, PixelFormat format,
1779        uint32_t flags) {
1780    return 0;
1781}
1782status_t UserClient::destroySurface(SurfaceID sid) {
1783    return INVALID_OPERATION;
1784}
1785status_t UserClient::setState(int32_t count, const layer_state_t* states) {
1786    return INVALID_OPERATION;
1787}
1788
1789// ---------------------------------------------------------------------------
1790
1791GraphicPlane::GraphicPlane()
1792    : mHw(0)
1793{
1794}
1795
1796GraphicPlane::~GraphicPlane() {
1797    delete mHw;
1798}
1799
1800bool GraphicPlane::initialized() const {
1801    return mHw ? true : false;
1802}
1803
1804int GraphicPlane::getWidth() const {
1805    return mWidth;
1806}
1807
1808int GraphicPlane::getHeight() const {
1809    return mHeight;
1810}
1811
1812void GraphicPlane::setDisplayHardware(DisplayHardware *hw)
1813{
1814    mHw = hw;
1815
1816    // initialize the display orientation transform.
1817    // it's a constant that should come from the display driver.
1818    int displayOrientation = ISurfaceComposer::eOrientationDefault;
1819    char property[PROPERTY_VALUE_MAX];
1820    if (property_get("ro.sf.hwrotation", property, NULL) > 0) {
1821        //displayOrientation
1822        switch (atoi(property)) {
1823        case 90:
1824            displayOrientation = ISurfaceComposer::eOrientation90;
1825            break;
1826        case 270:
1827            displayOrientation = ISurfaceComposer::eOrientation270;
1828            break;
1829        }
1830    }
1831
1832    const float w = hw->getWidth();
1833    const float h = hw->getHeight();
1834    GraphicPlane::orientationToTransfrom(displayOrientation, w, h,
1835            &mDisplayTransform);
1836    if (displayOrientation & ISurfaceComposer::eOrientationSwapMask) {
1837        mDisplayWidth = h;
1838        mDisplayHeight = w;
1839    } else {
1840        mDisplayWidth = w;
1841        mDisplayHeight = h;
1842    }
1843
1844    setOrientation(ISurfaceComposer::eOrientationDefault);
1845}
1846
1847status_t GraphicPlane::orientationToTransfrom(
1848        int orientation, int w, int h, Transform* tr)
1849{
1850    uint32_t flags = 0;
1851    switch (orientation) {
1852    case ISurfaceComposer::eOrientationDefault:
1853        flags = Transform::ROT_0;
1854        break;
1855    case ISurfaceComposer::eOrientation90:
1856        flags = Transform::ROT_90;
1857        break;
1858    case ISurfaceComposer::eOrientation180:
1859        flags = Transform::ROT_180;
1860        break;
1861    case ISurfaceComposer::eOrientation270:
1862        flags = Transform::ROT_270;
1863        break;
1864    default:
1865        return BAD_VALUE;
1866    }
1867    tr->set(flags, w, h);
1868    return NO_ERROR;
1869}
1870
1871status_t GraphicPlane::setOrientation(int orientation)
1872{
1873    // If the rotation can be handled in hardware, this is where
1874    // the magic should happen.
1875
1876    const DisplayHardware& hw(displayHardware());
1877    const float w = mDisplayWidth;
1878    const float h = mDisplayHeight;
1879    mWidth = int(w);
1880    mHeight = int(h);
1881
1882    Transform orientationTransform;
1883    GraphicPlane::orientationToTransfrom(orientation, w, h,
1884            &orientationTransform);
1885    if (orientation & ISurfaceComposer::eOrientationSwapMask) {
1886        mWidth = int(h);
1887        mHeight = int(w);
1888    }
1889
1890    mOrientation = orientation;
1891    mGlobalTransform = mDisplayTransform * orientationTransform;
1892    return NO_ERROR;
1893}
1894
1895const DisplayHardware& GraphicPlane::displayHardware() const {
1896    return *mHw;
1897}
1898
1899const Transform& GraphicPlane::transform() const {
1900    return mGlobalTransform;
1901}
1902
1903EGLDisplay GraphicPlane::getEGLDisplay() const {
1904    return mHw->getEGLDisplay();
1905}
1906
1907// ---------------------------------------------------------------------------
1908
1909}; // namespace android
1910