Layer.cpp revision 74c40c0a273dbfd7d10617c4cc1b0c066bfc812e 
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 <stdint.h>
19#include <sys/types.h>
20
21#include <cutils/properties.h>
22#include <cutils/native_handle.h>
23
24#include <utils/Errors.h>
25#include <utils/Log.h>
26#include <utils/StopWatch.h>
27
28#include <ui/GraphicBuffer.h>
29#include <ui/PixelFormat.h>
30
31#include <surfaceflinger/Surface.h>
32
33#include "clz.h"
34#include "GLExtensions.h"
35#include "Layer.h"
36#include "SurfaceFlinger.h"
37#include "DisplayHardware/DisplayHardware.h"
38#include "DisplayHardware/HWComposer.h"
39
40
41#define DEBUG_RESIZE    0
42
43
44namespace android {
45
46template <typename T> inline T min(T a, T b) {
47    return a<b ? a : b;
48}
49
50// ---------------------------------------------------------------------------
51
52Layer::Layer(SurfaceFlinger* flinger,
53        DisplayID display, const sp<Client>& client)
54    :   LayerBaseClient(flinger, display, client),
55        mGLExtensions(GLExtensions::getInstance()),
56        mNeedsBlending(true),
57        mNeedsDithering(false),
58        mSecure(false),
59        mTextureManager(),
60        mBufferManager(mTextureManager),
61        mWidth(0), mHeight(0), mFixedSize(false)
62{
63}
64
65Layer::~Layer()
66{
67    // FIXME: must be called from the main UI thread
68    EGLDisplay dpy(mFlinger->graphicPlane(0).getEGLDisplay());
69    mBufferManager.destroy(dpy);
70
71    // we can use getUserClientUnsafe here because we know we're
72    // single-threaded at that point.
73    sp<UserClient> ourClient(mUserClientRef.getUserClientUnsafe());
74    if (ourClient != 0) {
75        ourClient->detachLayer(this);
76    }
77}
78
79status_t Layer::setToken(const sp<UserClient>& userClient,
80        SharedClient* sharedClient, int32_t token)
81{
82    sp<SharedBufferServer> lcblk = new SharedBufferServer(
83            sharedClient, token, mBufferManager.getDefaultBufferCount(),
84            getIdentity());
85
86    status_t err = mUserClientRef.setToken(userClient, lcblk, token);
87
88    LOGE_IF(err != NO_ERROR,
89            "ClientRef::setToken(%p, %p, %u) failed",
90            userClient.get(), lcblk.get(), token);
91
92    if (err == NO_ERROR) {
93        // we need to free the buffers associated with this surface
94    }
95
96    return err;
97}
98
99int32_t Layer::getToken() const
100{
101    return mUserClientRef.getToken();
102}
103
104sp<UserClient> Layer::getClient() const
105{
106    return mUserClientRef.getClient();
107}
108
109// called with SurfaceFlinger::mStateLock as soon as the layer is entered
110// in the purgatory list
111void Layer::onRemoved()
112{
113    ClientRef::Access sharedClient(mUserClientRef);
114    SharedBufferServer* lcblk(sharedClient.get());
115    if (lcblk) {
116        // wake up the condition
117        lcblk->setStatus(NO_INIT);
118    }
119}
120
121sp<LayerBaseClient::Surface> Layer::createSurface() const
122{
123    return mSurface;
124}
125
126status_t Layer::ditch()
127{
128    // NOTE: Called from the main UI thread
129
130    // the layer is not on screen anymore. free as much resources as possible
131    mFreezeLock.clear();
132
133    EGLDisplay dpy(mFlinger->graphicPlane(0).getEGLDisplay());
134    mBufferManager.destroy(dpy);
135    mSurface.clear();
136
137    Mutex::Autolock _l(mLock);
138    mWidth = mHeight = 0;
139    return NO_ERROR;
140}
141
142status_t Layer::setBuffers( uint32_t w, uint32_t h,
143                            PixelFormat format, uint32_t flags)
144{
145    // this surfaces pixel format
146    PixelFormatInfo info;
147    status_t err = getPixelFormatInfo(format, &info);
148    if (err) return err;
149
150    // the display's pixel format
151    const DisplayHardware& hw(graphicPlane(0).displayHardware());
152    uint32_t const maxSurfaceDims = min(
153            hw.getMaxTextureSize(), hw.getMaxViewportDims());
154
155    // never allow a surface larger than what our underlying GL implementation
156    // can handle.
157    if ((uint32_t(w)>maxSurfaceDims) || (uint32_t(h)>maxSurfaceDims)) {
158        return BAD_VALUE;
159    }
160
161    PixelFormatInfo displayInfo;
162    getPixelFormatInfo(hw.getFormat(), &displayInfo);
163    const uint32_t hwFlags = hw.getFlags();
164
165    mFormat = format;
166    mWidth  = w;
167    mHeight = h;
168
169    mReqFormat = format;
170    mReqWidth = w;
171    mReqHeight = h;
172
173    mSecure = (flags & ISurfaceComposer::eSecure) ? true : false;
174    mNeedsBlending = (info.h_alpha - info.l_alpha) > 0;
175
176    // we use the red index
177    int displayRedSize = displayInfo.getSize(PixelFormatInfo::INDEX_RED);
178    int layerRedsize = info.getSize(PixelFormatInfo::INDEX_RED);
179    mNeedsDithering = layerRedsize > displayRedSize;
180
181    mSurface = new SurfaceLayer(mFlinger, this);
182    return NO_ERROR;
183}
184
185void Layer::setGeometry(hwc_layer_t* hwcl)
186{
187    hwcl->compositionType = HWC_FRAMEBUFFER;
188    hwcl->hints = 0;
189    hwcl->flags = 0;
190    hwcl->transform = 0;
191    hwcl->blending = HWC_BLENDING_NONE;
192
193    // we can't do alpha-fade with the hwc HAL
194    const State& s(drawingState());
195    if (s.alpha < 0xFF) {
196        hwcl->flags = HWC_SKIP_LAYER;
197        return;
198    }
199
200    // we can only handle simple transformation
201    if (mOrientation & Transform::ROT_INVALID) {
202        hwcl->flags = HWC_SKIP_LAYER;
203        return;
204    }
205
206    hwcl->transform = mOrientation;
207
208    if (needsBlending()) {
209        hwcl->blending = mPremultipliedAlpha ?
210                HWC_BLENDING_PREMULT : HWC_BLENDING_COVERAGE;
211    }
212
213    hwcl->displayFrame.left   = mTransformedBounds.left;
214    hwcl->displayFrame.top    = mTransformedBounds.top;
215    hwcl->displayFrame.right  = mTransformedBounds.right;
216    hwcl->displayFrame.bottom = mTransformedBounds.bottom;
217
218    hwcl->visibleRegionScreen.rects =
219            reinterpret_cast<hwc_rect_t const *>(
220                    visibleRegionScreen.getArray(
221                            &hwcl->visibleRegionScreen.numRects));
222}
223
224void Layer::setPerFrameData(hwc_layer_t* hwcl) {
225    sp<GraphicBuffer> buffer(mBufferManager.getActiveBuffer());
226    if (buffer == NULL) {
227        // this situation can happen if we ran out of memory for instance.
228        // not much we can do. continue to use whatever texture was bound
229        // to this context.
230        hwcl->handle = NULL;
231        return;
232    }
233    hwcl->handle = const_cast<native_handle_t*>(buffer->handle);
234    // TODO: set the crop value properly
235    hwcl->sourceCrop.left   = 0;
236    hwcl->sourceCrop.top    = 0;
237    hwcl->sourceCrop.right  = buffer->width;
238    hwcl->sourceCrop.bottom = buffer->height;
239}
240
241void Layer::reloadTexture(const Region& dirty)
242{
243    sp<GraphicBuffer> buffer(mBufferManager.getActiveBuffer());
244    if (buffer == NULL) {
245        // this situation can happen if we ran out of memory for instance.
246        // not much we can do. continue to use whatever texture was bound
247        // to this context.
248        return;
249    }
250
251    if (mGLExtensions.haveDirectTexture()) {
252        EGLDisplay dpy(mFlinger->graphicPlane(0).getEGLDisplay());
253        if (mBufferManager.initEglImage(dpy, buffer) != NO_ERROR) {
254            // not sure what we can do here...
255            goto slowpath;
256        }
257    } else {
258slowpath:
259        GGLSurface t;
260        if (buffer->usage & GRALLOC_USAGE_SW_READ_MASK) {
261            status_t res = buffer->lock(&t, GRALLOC_USAGE_SW_READ_OFTEN);
262            LOGE_IF(res, "error %d (%s) locking buffer %p",
263                    res, strerror(res), buffer.get());
264            if (res == NO_ERROR) {
265                mBufferManager.loadTexture(dirty, t);
266                buffer->unlock();
267            }
268        } else {
269            // we can't do anything
270        }
271    }
272}
273
274void Layer::drawForSreenShot() const
275{
276    bool currentFixedSize = mFixedSize;
277    bool currentBlending = mNeedsBlending;
278    const_cast<Layer*>(this)->mFixedSize = false;
279    const_cast<Layer*>(this)->mFixedSize = true;
280    LayerBase::drawForSreenShot();
281    const_cast<Layer*>(this)->mFixedSize = currentFixedSize;
282    const_cast<Layer*>(this)->mNeedsBlending = currentBlending;
283}
284
285void Layer::onDraw(const Region& clip) const
286{
287    Texture tex(mBufferManager.getActiveTexture());
288    if (tex.name == -1LU) {
289        // the texture has not been created yet, this Layer has
290        // in fact never been drawn into. This happens frequently with
291        // SurfaceView because the WindowManager can't know when the client
292        // has drawn the first time.
293
294        // If there is nothing under us, we paint the screen in black, otherwise
295        // we just skip this update.
296
297        // figure out if there is something below us
298        Region under;
299        const SurfaceFlinger::LayerVector& drawingLayers(mFlinger->mDrawingState.layersSortedByZ);
300        const size_t count = drawingLayers.size();
301        for (size_t i=0 ; i<count ; ++i) {
302            const sp<LayerBase>& layer(drawingLayers[i]);
303            if (layer.get() == static_cast<LayerBase const*>(this))
304                break;
305            under.orSelf(layer->visibleRegionScreen);
306        }
307        // if not everything below us is covered, we plug the holes!
308        Region holes(clip.subtract(under));
309        if (!holes.isEmpty()) {
310            clearWithOpenGL(holes, 0, 0, 0, 1);
311        }
312        return;
313    }
314    drawWithOpenGL(clip, tex);
315}
316
317bool Layer::needsFiltering() const
318{
319    if (!(mFlags & DisplayHardware::SLOW_CONFIG)) {
320        // NOTE: there is a race here, because mFixedSize is updated in a
321        // binder transaction. however, it doesn't really matter since it is
322        // evaluated each time we draw. To be perfectly correct, this flag
323        // would have to be associated with a buffer.
324        if (mFixedSize)
325            return true;
326    }
327    return LayerBase::needsFiltering();
328}
329
330
331status_t Layer::setBufferCount(int bufferCount)
332{
333    ClientRef::Access sharedClient(mUserClientRef);
334    SharedBufferServer* lcblk(sharedClient.get());
335    if (!lcblk) {
336        // oops, the client is already gone
337        return DEAD_OBJECT;
338    }
339
340    // NOTE: lcblk->resize() is protected by an internal lock
341    status_t err = lcblk->resize(bufferCount);
342    if (err == NO_ERROR)
343        mBufferManager.resize(bufferCount);
344
345    return err;
346}
347
348sp<GraphicBuffer> Layer::requestBuffer(int index,
349        uint32_t reqWidth, uint32_t reqHeight, uint32_t reqFormat,
350        uint32_t usage)
351{
352    sp<GraphicBuffer> buffer;
353
354    if (int32_t(reqWidth | reqHeight | reqFormat) < 0)
355        return buffer;
356
357    if ((!reqWidth && reqHeight) || (reqWidth && !reqHeight))
358        return buffer;
359
360    // this ensures our client doesn't go away while we're accessing
361    // the shared area.
362    ClientRef::Access sharedClient(mUserClientRef);
363    SharedBufferServer* lcblk(sharedClient.get());
364    if (!lcblk) {
365        // oops, the client is already gone
366        return buffer;
367    }
368
369    /*
370     * This is called from the client's Surface::dequeue(). This can happen
371     * at any time, especially while we're in the middle of using the
372     * buffer 'index' as our front buffer.
373     */
374
375    status_t err = NO_ERROR;
376    uint32_t w, h, f;
377    { // scope for the lock
378        Mutex::Autolock _l(mLock);
379
380        // zero means default
381        const bool fixedSize = reqWidth && reqHeight;
382        if (!reqFormat) reqFormat = mFormat;
383        if (!reqWidth)  reqWidth = mWidth;
384        if (!reqHeight) reqHeight = mHeight;
385
386        w = reqWidth;
387        h = reqHeight;
388        f = reqFormat;
389
390        if ((reqWidth != mReqWidth) || (reqHeight != mReqHeight) ||
391                (reqFormat != mReqFormat)) {
392            mReqWidth  = reqWidth;
393            mReqHeight = reqHeight;
394            mReqFormat = reqFormat;
395            mFixedSize = fixedSize;
396
397            lcblk->reallocateAllExcept(index);
398        }
399    }
400
401    // here we have to reallocate a new buffer because the buffer could be
402    // used as the front buffer, or by a client in our process
403    // (eg: status bar), and we can't release the handle under its feet.
404    const uint32_t effectiveUsage = getEffectiveUsage(usage);
405    buffer = new GraphicBuffer(w, h, f, effectiveUsage);
406    err = buffer->initCheck();
407
408    if (err || buffer->handle == 0) {
409        LOGE_IF(err || buffer->handle == 0,
410                "Layer::requestBuffer(this=%p), index=%d, w=%d, h=%d failed (%s)",
411                this, index, w, h, strerror(-err));
412    } else {
413        LOGD_IF(DEBUG_RESIZE,
414                "Layer::requestBuffer(this=%p), index=%d, w=%d, h=%d, handle=%p",
415                this, index, w, h, buffer->handle);
416    }
417
418    if (err == NO_ERROR && buffer->handle != 0) {
419        Mutex::Autolock _l(mLock);
420        mBufferManager.attachBuffer(index, buffer);
421    }
422    return buffer;
423}
424
425uint32_t Layer::getEffectiveUsage(uint32_t usage) const
426{
427    /*
428     *  buffers used for software rendering, but h/w composition
429     *  are allocated with SW_READ_OFTEN | SW_WRITE_OFTEN | HW_TEXTURE
430     *
431     *  buffers used for h/w rendering and h/w composition
432     *  are allocated with  HW_RENDER | HW_TEXTURE
433     *
434     *  buffers used with h/w rendering and either NPOT or no egl_image_ext
435     *  are allocated with SW_READ_RARELY | HW_RENDER
436     *
437     */
438
439    if (mSecure) {
440        // secure buffer, don't store it into the GPU
441        usage = GraphicBuffer::USAGE_SW_READ_OFTEN |
442                GraphicBuffer::USAGE_SW_WRITE_OFTEN;
443    } else {
444        // it's allowed to modify the usage flags here, but generally
445        // the requested flags should be honored.
446        // request EGLImage for all buffers
447        usage |= GraphicBuffer::USAGE_HW_TEXTURE;
448    }
449    return usage;
450}
451
452uint32_t Layer::doTransaction(uint32_t flags)
453{
454    const Layer::State& front(drawingState());
455    const Layer::State& temp(currentState());
456
457    const bool sizeChanged = (front.requested_w != temp.requested_w) ||
458            (front.requested_h != temp.requested_h);
459
460    if (sizeChanged) {
461        // the size changed, we need to ask our client to request a new buffer
462        LOGD_IF(DEBUG_RESIZE,
463                "resize (layer=%p), requested (%dx%d), drawing (%d,%d)",
464                this,
465                int(temp.requested_w), int(temp.requested_h),
466                int(front.requested_w), int(front.requested_h));
467
468        if (!isFixedSize()) {
469            // we're being resized and there is a freeze display request,
470            // acquire a freeze lock, so that the screen stays put
471            // until we've redrawn at the new size; this is to avoid
472            // glitches upon orientation changes.
473            if (mFlinger->hasFreezeRequest()) {
474                // if the surface is hidden, don't try to acquire the
475                // freeze lock, since hidden surfaces may never redraw
476                if (!(front.flags & ISurfaceComposer::eLayerHidden)) {
477                    mFreezeLock = mFlinger->getFreezeLock();
478                }
479            }
480
481            // this will make sure LayerBase::doTransaction doesn't update
482            // the drawing state's size
483            Layer::State& editDraw(mDrawingState);
484            editDraw.requested_w = temp.requested_w;
485            editDraw.requested_h = temp.requested_h;
486
487            // record the new size, form this point on, when the client request
488            // a buffer, it'll get the new size.
489            setBufferSize(temp.requested_w, temp.requested_h);
490
491            ClientRef::Access sharedClient(mUserClientRef);
492            SharedBufferServer* lcblk(sharedClient.get());
493            if (lcblk) {
494                // all buffers need reallocation
495                lcblk->reallocateAll();
496            }
497        } else {
498            // record the new size
499            setBufferSize(temp.requested_w, temp.requested_h);
500        }
501    }
502
503    if (temp.sequence != front.sequence) {
504        if (temp.flags & ISurfaceComposer::eLayerHidden || temp.alpha == 0) {
505            // this surface is now hidden, so it shouldn't hold a freeze lock
506            // (it may never redraw, which is fine if it is hidden)
507            mFreezeLock.clear();
508        }
509    }
510
511    return LayerBase::doTransaction(flags);
512}
513
514void Layer::setBufferSize(uint32_t w, uint32_t h) {
515    Mutex::Autolock _l(mLock);
516    mWidth = w;
517    mHeight = h;
518}
519
520bool Layer::isFixedSize() const {
521    Mutex::Autolock _l(mLock);
522    return mFixedSize;
523}
524
525// ----------------------------------------------------------------------------
526// pageflip handling...
527// ----------------------------------------------------------------------------
528
529void Layer::lockPageFlip(bool& recomputeVisibleRegions)
530{
531    ClientRef::Access sharedClient(mUserClientRef);
532    SharedBufferServer* lcblk(sharedClient.get());
533    if (!lcblk) {
534        // client died
535        recomputeVisibleRegions = true;
536        return;
537    }
538
539    ssize_t buf = lcblk->retireAndLock();
540    if (buf == NOT_ENOUGH_DATA) {
541        // NOTE: This is not an error, it simply means there is nothing to
542        // retire. The buffer is locked because we will use it
543        // for composition later in the loop
544        return;
545    }
546
547    if (buf < NO_ERROR) {
548        LOGE("retireAndLock() buffer index (%d) out of range", int(buf));
549        mPostedDirtyRegion.clear();
550        return;
551    }
552
553    // we retired a buffer, which becomes the new front buffer
554    if (mBufferManager.setActiveBufferIndex(buf) < NO_ERROR) {
555        LOGE("retireAndLock() buffer index (%d) out of range", int(buf));
556        mPostedDirtyRegion.clear();
557        return;
558    }
559
560    sp<GraphicBuffer> newFrontBuffer(getBuffer(buf));
561    if (newFrontBuffer != NULL) {
562        // get the dirty region
563        // compute the posted region
564        const Region dirty(lcblk->getDirtyRegion(buf));
565        mPostedDirtyRegion = dirty.intersect( newFrontBuffer->getBounds() );
566
567        // update the layer size and release freeze-lock
568        const Layer::State& front(drawingState());
569        if (newFrontBuffer->getWidth()  == front.requested_w &&
570            newFrontBuffer->getHeight() == front.requested_h)
571        {
572            if ((front.w != front.requested_w) ||
573                (front.h != front.requested_h))
574            {
575                // Here we pretend the transaction happened by updating the
576                // current and drawing states. Drawing state is only accessed
577                // in this thread, no need to have it locked
578                Layer::State& editDraw(mDrawingState);
579                editDraw.w = editDraw.requested_w;
580                editDraw.h = editDraw.requested_h;
581
582                // We also need to update the current state so that we don't
583                // end-up doing too much work during the next transaction.
584                // NOTE: We actually don't need hold the transaction lock here
585                // because State::w and State::h are only accessed from
586                // this thread
587                Layer::State& editTemp(currentState());
588                editTemp.w = editDraw.w;
589                editTemp.h = editDraw.h;
590
591                // recompute visible region
592                recomputeVisibleRegions = true;
593            }
594
595            // we now have the correct size, unfreeze the screen
596            mFreezeLock.clear();
597        }
598
599        // get the crop region
600        setBufferCrop( lcblk->getCrop(buf) );
601
602        // get the transformation
603        setBufferTransform( lcblk->getTransform(buf) );
604
605    } else {
606        // this should not happen unless we ran out of memory while
607        // allocating the buffer. we're hoping that things will get back
608        // to normal the next time the app tries to draw into this buffer.
609        // meanwhile, pretend the screen didn't update.
610        mPostedDirtyRegion.clear();
611    }
612
613    if (lcblk->getQueuedCount()) {
614        // signal an event if we have more buffers waiting
615        mFlinger->signalEvent();
616    }
617
618    /* a buffer was posted, so we need to call reloadTexture(), which
619     * will update our internal data structures (eg: EGLImageKHR or
620     * texture names). we need to do this even if mPostedDirtyRegion is
621     * empty -- it's orthogonal to the fact that a new buffer was posted,
622     * for instance, a degenerate case could be that the user did an empty
623     * update but repainted the buffer with appropriate content (after a
624     * resize for instance).
625     */
626    reloadTexture( mPostedDirtyRegion );
627}
628
629void Layer::unlockPageFlip(
630        const Transform& planeTransform, Region& outDirtyRegion)
631{
632    Region dirtyRegion(mPostedDirtyRegion);
633    if (!dirtyRegion.isEmpty()) {
634        mPostedDirtyRegion.clear();
635        // The dirty region is given in the layer's coordinate space
636        // transform the dirty region by the surface's transformation
637        // and the global transformation.
638        const Layer::State& s(drawingState());
639        const Transform tr(planeTransform * s.transform);
640        dirtyRegion = tr.transform(dirtyRegion);
641
642        // At this point, the dirty region is in screen space.
643        // Make sure it's constrained by the visible region (which
644        // is in screen space as well).
645        dirtyRegion.andSelf(visibleRegionScreen);
646        outDirtyRegion.orSelf(dirtyRegion);
647    }
648    if (visibleRegionScreen.isEmpty()) {
649        // an invisible layer should not hold a freeze-lock
650        // (because it may never be updated and therefore never release it)
651        mFreezeLock.clear();
652    }
653}
654
655void Layer::finishPageFlip()
656{
657    ClientRef::Access sharedClient(mUserClientRef);
658    SharedBufferServer* lcblk(sharedClient.get());
659    if (lcblk) {
660        int buf = mBufferManager.getActiveBufferIndex();
661        if (buf >= 0) {
662            status_t err = lcblk->unlock( buf );
663            LOGE_IF(err!=NO_ERROR,
664                    "layer %p, buffer=%d wasn't locked!",
665                    this, buf);
666        }
667    }
668}
669
670
671void Layer::dump(String8& result, char* buffer, size_t SIZE) const
672{
673    LayerBaseClient::dump(result, buffer, SIZE);
674
675    ClientRef::Access sharedClient(mUserClientRef);
676    SharedBufferServer* lcblk(sharedClient.get());
677    uint32_t totalTime = 0;
678    if (lcblk) {
679        SharedBufferStack::Statistics stats = lcblk->getStats();
680        totalTime= stats.totalTime;
681        result.append( lcblk->dump("      ") );
682    }
683
684    sp<const GraphicBuffer> buf0(getBuffer(0));
685    sp<const GraphicBuffer> buf1(getBuffer(1));
686    uint32_t w0=0, h0=0, s0=0;
687    uint32_t w1=0, h1=0, s1=0;
688    if (buf0 != 0) {
689        w0 = buf0->getWidth();
690        h0 = buf0->getHeight();
691        s0 = buf0->getStride();
692    }
693    if (buf1 != 0) {
694        w1 = buf1->getWidth();
695        h1 = buf1->getHeight();
696        s1 = buf1->getStride();
697    }
698    snprintf(buffer, SIZE,
699            "      "
700            "format=%2d, [%3ux%3u:%3u] [%3ux%3u:%3u],"
701            " freezeLock=%p, dq-q-time=%u us\n",
702            mFormat, w0, h0, s0, w1, h1, s1,
703            getFreezeLock().get(), totalTime);
704
705    result.append(buffer);
706}
707
708// ---------------------------------------------------------------------------
709
710Layer::ClientRef::ClientRef()
711    : mControlBlock(0), mToken(-1) {
712}
713
714Layer::ClientRef::~ClientRef() {
715}
716
717int32_t Layer::ClientRef::getToken() const {
718    Mutex::Autolock _l(mLock);
719    return mToken;
720}
721
722sp<UserClient> Layer::ClientRef::getClient() const {
723    Mutex::Autolock _l(mLock);
724    return mUserClient.promote();
725}
726
727status_t Layer::ClientRef::setToken(const sp<UserClient>& uc,
728        const sp<SharedBufferServer>& sharedClient, int32_t token) {
729    Mutex::Autolock _l(mLock);
730
731    { // scope for strong mUserClient reference
732        sp<UserClient> userClient(mUserClient.promote());
733        if (mUserClient != 0 && mControlBlock != 0) {
734            mControlBlock->setStatus(NO_INIT);
735        }
736    }
737
738    mUserClient = uc;
739    mToken = token;
740    mControlBlock = sharedClient;
741    return NO_ERROR;
742}
743
744sp<UserClient> Layer::ClientRef::getUserClientUnsafe() const {
745    return mUserClient.promote();
746}
747
748// this class gives us access to SharedBufferServer safely
749// it makes sure the UserClient (and its associated shared memory)
750// won't go away while we're accessing it.
751Layer::ClientRef::Access::Access(const ClientRef& ref)
752    : mControlBlock(0)
753{
754    Mutex::Autolock _l(ref.mLock);
755    mUserClientStrongRef = ref.mUserClient.promote();
756    if (mUserClientStrongRef != 0)
757        mControlBlock = ref.mControlBlock;
758}
759
760Layer::ClientRef::Access::~Access()
761{
762}
763
764// ---------------------------------------------------------------------------
765
766Layer::BufferManager::BufferManager(TextureManager& tm)
767    : mNumBuffers(NUM_BUFFERS), mTextureManager(tm),
768      mActiveBuffer(-1), mFailover(false)
769{
770}
771
772Layer::BufferManager::~BufferManager()
773{
774}
775
776status_t Layer::BufferManager::resize(size_t size)
777{
778    Mutex::Autolock _l(mLock);
779    mNumBuffers = size;
780    return NO_ERROR;
781}
782
783// only for debugging
784sp<GraphicBuffer> Layer::BufferManager::getBuffer(size_t index) const {
785    return mBufferData[index].buffer;
786}
787
788status_t Layer::BufferManager::setActiveBufferIndex(size_t index) {
789    mActiveBuffer = index;
790    return NO_ERROR;
791}
792
793size_t Layer::BufferManager::getActiveBufferIndex() const {
794    return mActiveBuffer;
795}
796
797Texture Layer::BufferManager::getActiveTexture() const {
798    Texture res;
799    if (mFailover || mActiveBuffer<0) {
800        res = mFailoverTexture;
801    } else {
802        static_cast<Image&>(res) = mBufferData[mActiveBuffer].texture;
803    }
804    return res;
805}
806
807sp<GraphicBuffer> Layer::BufferManager::getActiveBuffer() const {
808    sp<GraphicBuffer> result;
809    const ssize_t activeBuffer = mActiveBuffer;
810    if (activeBuffer >= 0) {
811        BufferData const * const buffers = mBufferData;
812        Mutex::Autolock _l(mLock);
813        result = buffers[activeBuffer].buffer;
814    }
815    return result;
816}
817
818sp<GraphicBuffer> Layer::BufferManager::detachBuffer(size_t index)
819{
820    BufferData* const buffers = mBufferData;
821    sp<GraphicBuffer> buffer;
822    Mutex::Autolock _l(mLock);
823    buffer = buffers[index].buffer;
824    buffers[index].buffer = 0;
825    return buffer;
826}
827
828status_t Layer::BufferManager::attachBuffer(size_t index,
829        const sp<GraphicBuffer>& buffer)
830{
831    BufferData* const buffers = mBufferData;
832    Mutex::Autolock _l(mLock);
833    buffers[index].buffer = buffer;
834    buffers[index].texture.dirty = true;
835    return NO_ERROR;
836}
837
838status_t Layer::BufferManager::destroy(EGLDisplay dpy)
839{
840    BufferData* const buffers = mBufferData;
841    size_t num;
842    { // scope for the lock
843        Mutex::Autolock _l(mLock);
844        num = mNumBuffers;
845        for (size_t i=0 ; i<num ; i++) {
846            buffers[i].buffer = 0;
847        }
848    }
849    for (size_t i=0 ; i<num ; i++) {
850        destroyTexture(&buffers[i].texture, dpy);
851    }
852    destroyTexture(&mFailoverTexture, dpy);
853    return NO_ERROR;
854}
855
856status_t Layer::BufferManager::initEglImage(EGLDisplay dpy,
857        const sp<GraphicBuffer>& buffer)
858{
859    status_t err = NO_INIT;
860    ssize_t index = mActiveBuffer;
861    if (index >= 0) {
862        if (!mFailover) {
863            Image& texture(mBufferData[index].texture);
864            err = mTextureManager.initEglImage(&texture, dpy, buffer);
865            // if EGLImage fails, we switch to regular texture mode, and we
866            // free all resources associated with using EGLImages.
867            if (err == NO_ERROR) {
868                mFailover = false;
869                destroyTexture(&mFailoverTexture, dpy);
870            } else {
871                mFailover = true;
872                const size_t num = mNumBuffers;
873                for (size_t i=0 ; i<num ; i++) {
874                    destroyTexture(&mBufferData[i].texture, dpy);
875                }
876            }
877        } else {
878            // we failed once, don't try again
879            err = BAD_VALUE;
880        }
881    }
882    return err;
883}
884
885status_t Layer::BufferManager::loadTexture(
886        const Region& dirty, const GGLSurface& t)
887{
888    return mTextureManager.loadTexture(&mFailoverTexture, dirty, t);
889}
890
891status_t Layer::BufferManager::destroyTexture(Image* tex, EGLDisplay dpy)
892{
893    if (tex->name != -1U) {
894        glDeleteTextures(1, &tex->name);
895        tex->name = -1U;
896    }
897    if (tex->image != EGL_NO_IMAGE_KHR) {
898        eglDestroyImageKHR(dpy, tex->image);
899        tex->image = EGL_NO_IMAGE_KHR;
900    }
901    return NO_ERROR;
902}
903
904// ---------------------------------------------------------------------------
905
906Layer::SurfaceLayer::SurfaceLayer(const sp<SurfaceFlinger>& flinger,
907        const sp<Layer>& owner)
908    : Surface(flinger, owner->getIdentity(), owner)
909{
910}
911
912Layer::SurfaceLayer::~SurfaceLayer()
913{
914}
915
916sp<GraphicBuffer> Layer::SurfaceLayer::requestBuffer(int index,
917        uint32_t w, uint32_t h, uint32_t format, uint32_t usage)
918{
919    sp<GraphicBuffer> buffer;
920    sp<Layer> owner(getOwner());
921    if (owner != 0) {
922        /*
923         * requestBuffer() cannot be called from the main thread
924         * as it could cause a dead-lock, since it may have to wait
925         * on conditions updated my the main thread.
926         */
927        buffer = owner->requestBuffer(index, w, h, format, usage);
928    }
929    return buffer;
930}
931
932status_t Layer::SurfaceLayer::setBufferCount(int bufferCount)
933{
934    status_t err = DEAD_OBJECT;
935    sp<Layer> owner(getOwner());
936    if (owner != 0) {
937        /*
938         * setBufferCount() cannot be called from the main thread
939         * as it could cause a dead-lock, since it may have to wait
940         * on conditions updated my the main thread.
941         */
942        err = owner->setBufferCount(bufferCount);
943    }
944    return err;
945}
946
947// ---------------------------------------------------------------------------
948
949
950}; // namespace android
951