Surface.cpp revision 697526bc9e44ce61c88614f98387ae8bbf0a187e 
1/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "Surface"
18
19#include <stdint.h>
20#include <errno.h>
21#include <sys/types.h>
22#include <sys/stat.h>
23
24#include <utils/Errors.h>
25#include <utils/threads.h>
26#include <utils/CallStack.h>
27#include <utils/Log.h>
28
29#include <binder/IPCThreadState.h>
30#include <binder/IMemory.h>
31
32#include <ui/DisplayInfo.h>
33#include <ui/GraphicBuffer.h>
34#include <ui/GraphicBufferMapper.h>
35#include <ui/GraphicLog.h>
36#include <ui/Rect.h>
37
38#include <surfaceflinger/Surface.h>
39#include <surfaceflinger/ISurface.h>
40#include <surfaceflinger/ISurfaceComposer.h>
41#include <surfaceflinger/SurfaceComposerClient.h>
42
43#include <private/surfaceflinger/SharedBufferStack.h>
44#include <private/surfaceflinger/LayerState.h>
45
46namespace android {
47
48// ----------------------------------------------------------------------
49
50static status_t copyBlt(
51        const sp<GraphicBuffer>& dst,
52        const sp<GraphicBuffer>& src,
53        const Region& reg)
54{
55    // src and dst with, height and format must be identical. no verification
56    // is done here.
57    status_t err;
58    uint8_t const * src_bits = NULL;
59    err = src->lock(GRALLOC_USAGE_SW_READ_OFTEN, reg.bounds(), (void**)&src_bits);
60    LOGE_IF(err, "error locking src buffer %s", strerror(-err));
61
62    uint8_t* dst_bits = NULL;
63    err = dst->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, reg.bounds(), (void**)&dst_bits);
64    LOGE_IF(err, "error locking dst buffer %s", strerror(-err));
65
66    Region::const_iterator head(reg.begin());
67    Region::const_iterator tail(reg.end());
68    if (head != tail && src_bits && dst_bits) {
69        const size_t bpp = bytesPerPixel(src->format);
70        const size_t dbpr = dst->stride * bpp;
71        const size_t sbpr = src->stride * bpp;
72
73        while (head != tail) {
74            const Rect& r(*head++);
75            ssize_t h = r.height();
76            if (h <= 0) continue;
77            size_t size = r.width() * bpp;
78            uint8_t const * s = src_bits + (r.left + src->stride * r.top) * bpp;
79            uint8_t       * d = dst_bits + (r.left + dst->stride * r.top) * bpp;
80            if (dbpr==sbpr && size==sbpr) {
81                size *= h;
82                h = 1;
83            }
84            do {
85                memcpy(d, s, size);
86                d += dbpr;
87                s += sbpr;
88            } while (--h > 0);
89        }
90    }
91
92    if (src_bits)
93        src->unlock();
94
95    if (dst_bits)
96        dst->unlock();
97
98    return err;
99}
100
101// ============================================================================
102//  SurfaceControl
103// ============================================================================
104
105SurfaceControl::SurfaceControl(
106        const sp<SurfaceComposerClient>& client,
107        const sp<ISurface>& surface,
108        const ISurfaceComposerClient::surface_data_t& data,
109        uint32_t w, uint32_t h, PixelFormat format, uint32_t flags)
110    : mClient(client), mSurface(surface),
111      mToken(data.token), mIdentity(data.identity),
112      mWidth(data.width), mHeight(data.height), mFormat(data.format),
113      mFlags(flags)
114{
115}
116
117SurfaceControl::~SurfaceControl()
118{
119    destroy();
120}
121
122void SurfaceControl::destroy()
123{
124    if (isValid()) {
125        mClient->destroySurface(mToken);
126    }
127
128    // clear all references and trigger an IPC now, to make sure things
129    // happen without delay, since these resources are quite heavy.
130    mClient.clear();
131    mSurface.clear();
132    IPCThreadState::self()->flushCommands();
133}
134
135void SurfaceControl::clear()
136{
137    // here, the window manager tells us explicitly that we should destroy
138    // the surface's resource. Soon after this call, it will also release
139    // its last reference (which will call the dtor); however, it is possible
140    // that a client living in the same process still holds references which
141    // would delay the call to the dtor -- that is why we need this explicit
142    // "clear()" call.
143    destroy();
144}
145
146bool SurfaceControl::isSameSurface(
147        const sp<SurfaceControl>& lhs, const sp<SurfaceControl>& rhs)
148{
149    if (lhs == 0 || rhs == 0)
150        return false;
151    return lhs->mSurface->asBinder() == rhs->mSurface->asBinder();
152}
153
154status_t SurfaceControl::setLayer(int32_t layer) {
155    status_t err = validate();
156    if (err < 0) return err;
157    const sp<SurfaceComposerClient>& client(mClient);
158    return client->setLayer(mToken, layer);
159}
160status_t SurfaceControl::setPosition(int32_t x, int32_t y) {
161    status_t err = validate();
162    if (err < 0) return err;
163    const sp<SurfaceComposerClient>& client(mClient);
164    return client->setPosition(mToken, x, y);
165}
166status_t SurfaceControl::setSize(uint32_t w, uint32_t h) {
167    status_t err = validate();
168    if (err < 0) return err;
169    const sp<SurfaceComposerClient>& client(mClient);
170    return client->setSize(mToken, w, h);
171}
172status_t SurfaceControl::hide() {
173    status_t err = validate();
174    if (err < 0) return err;
175    const sp<SurfaceComposerClient>& client(mClient);
176    return client->hide(mToken);
177}
178status_t SurfaceControl::show(int32_t layer) {
179    status_t err = validate();
180    if (err < 0) return err;
181    const sp<SurfaceComposerClient>& client(mClient);
182    return client->show(mToken, layer);
183}
184status_t SurfaceControl::freeze() {
185    status_t err = validate();
186    if (err < 0) return err;
187    const sp<SurfaceComposerClient>& client(mClient);
188    return client->freeze(mToken);
189}
190status_t SurfaceControl::unfreeze() {
191    status_t err = validate();
192    if (err < 0) return err;
193    const sp<SurfaceComposerClient>& client(mClient);
194    return client->unfreeze(mToken);
195}
196status_t SurfaceControl::setFlags(uint32_t flags, uint32_t mask) {
197    status_t err = validate();
198    if (err < 0) return err;
199    const sp<SurfaceComposerClient>& client(mClient);
200    return client->setFlags(mToken, flags, mask);
201}
202status_t SurfaceControl::setTransparentRegionHint(const Region& transparent) {
203    status_t err = validate();
204    if (err < 0) return err;
205    const sp<SurfaceComposerClient>& client(mClient);
206    return client->setTransparentRegionHint(mToken, transparent);
207}
208status_t SurfaceControl::setAlpha(float alpha) {
209    status_t err = validate();
210    if (err < 0) return err;
211    const sp<SurfaceComposerClient>& client(mClient);
212    return client->setAlpha(mToken, alpha);
213}
214status_t SurfaceControl::setMatrix(float dsdx, float dtdx, float dsdy, float dtdy) {
215    status_t err = validate();
216    if (err < 0) return err;
217    const sp<SurfaceComposerClient>& client(mClient);
218    return client->setMatrix(mToken, dsdx, dtdx, dsdy, dtdy);
219}
220status_t SurfaceControl::setFreezeTint(uint32_t tint) {
221    status_t err = validate();
222    if (err < 0) return err;
223    const sp<SurfaceComposerClient>& client(mClient);
224    return client->setFreezeTint(mToken, tint);
225}
226
227status_t SurfaceControl::validate() const
228{
229    if (mToken<0 || mClient==0) {
230        LOGE("invalid token (%d, identity=%u) or client (%p)",
231                mToken, mIdentity, mClient.get());
232        return NO_INIT;
233    }
234    return NO_ERROR;
235}
236
237status_t SurfaceControl::writeSurfaceToParcel(
238        const sp<SurfaceControl>& control, Parcel* parcel)
239{
240    sp<ISurface> sur;
241    uint32_t identity = 0;
242    uint32_t width = 0;
243    uint32_t height = 0;
244    uint32_t format = 0;
245    uint32_t flags = 0;
246    if (SurfaceControl::isValid(control)) {
247        sur      = control->mSurface;
248        identity = control->mIdentity;
249        width    = control->mWidth;
250        height   = control->mHeight;
251        format   = control->mFormat;
252        flags    = control->mFlags;
253    }
254    parcel->writeStrongBinder(sur!=0 ? sur->asBinder() : NULL);
255    parcel->writeInt32(identity);
256    parcel->writeInt32(width);
257    parcel->writeInt32(height);
258    parcel->writeInt32(format);
259    parcel->writeInt32(flags);
260    return NO_ERROR;
261}
262
263sp<Surface> SurfaceControl::getSurface() const
264{
265    Mutex::Autolock _l(mLock);
266    if (mSurfaceData == 0) {
267        mSurfaceData = new Surface(const_cast<SurfaceControl*>(this));
268    }
269    return mSurfaceData;
270}
271
272// ============================================================================
273//  Surface
274// ============================================================================
275
276class SurfaceClient : public Singleton<SurfaceClient>
277{
278    // all these attributes are constants
279    sp<ISurfaceComposer> mComposerService;
280    sp<ISurfaceComposerClient> mClient;
281    status_t mStatus;
282    SharedClient* mControl;
283    sp<IMemoryHeap> mControlMemory;
284
285    SurfaceClient()
286        : Singleton<SurfaceClient>(), mStatus(NO_INIT)
287    {
288        sp<ISurfaceComposer> sf(ComposerService::getComposerService());
289        mComposerService = sf;
290        mClient = sf->createClientConnection();
291        if (mClient != NULL) {
292            mControlMemory = mClient->getControlBlock();
293            if (mControlMemory != NULL) {
294                mControl = static_cast<SharedClient *>(
295                        mControlMemory->getBase());
296                if (mControl) {
297                    mStatus = NO_ERROR;
298                }
299            }
300        }
301    }
302    friend class Singleton<SurfaceClient>;
303public:
304    status_t initCheck() const {
305        return mStatus;
306    }
307    SharedClient* getSharedClient() const {
308        return mControl;
309    }
310    ssize_t getTokenForSurface(const sp<ISurface>& sur) const {
311        // TODO: we could cache a few tokens here to avoid an IPC
312        return mClient->getTokenForSurface(sur);
313    }
314    void signalServer() const {
315        mComposerService->signal();
316    }
317};
318
319ANDROID_SINGLETON_STATIC_INSTANCE(SurfaceClient);
320
321// ---------------------------------------------------------------------------
322
323Surface::Surface(const sp<SurfaceControl>& surface)
324    : mBufferMapper(GraphicBufferMapper::get()),
325      mClient(SurfaceClient::getInstance()),
326      mSharedBufferClient(NULL),
327      mInitCheck(NO_INIT),
328      mSurface(surface->mSurface),
329      mIdentity(surface->mIdentity),
330      mFormat(surface->mFormat), mFlags(surface->mFlags),
331      mWidth(surface->mWidth), mHeight(surface->mHeight)
332{
333    init();
334}
335
336Surface::Surface(const Parcel& parcel, const sp<IBinder>& ref)
337    : mBufferMapper(GraphicBufferMapper::get()),
338      mClient(SurfaceClient::getInstance()),
339      mSharedBufferClient(NULL),
340      mInitCheck(NO_INIT)
341{
342    mSurface    = interface_cast<ISurface>(ref);
343    mIdentity   = parcel.readInt32();
344    mWidth      = parcel.readInt32();
345    mHeight     = parcel.readInt32();
346    mFormat     = parcel.readInt32();
347    mFlags      = parcel.readInt32();
348    init();
349}
350
351status_t Surface::writeToParcel(
352        const sp<Surface>& surface, Parcel* parcel)
353{
354    sp<ISurface> sur;
355    uint32_t identity = 0;
356    uint32_t width = 0;
357    uint32_t height = 0;
358    uint32_t format = 0;
359    uint32_t flags = 0;
360    if (Surface::isValid(surface)) {
361        sur      = surface->mSurface;
362        identity = surface->mIdentity;
363        width    = surface->mWidth;
364        height   = surface->mHeight;
365        format   = surface->mFormat;
366        flags    = surface->mFlags;
367    } else if (surface != 0 && surface->mSurface != 0) {
368        LOGW("Parceling invalid surface with non-NULL ISurface as NULL: "
369             "mSurface = %p, mIdentity = %d, mWidth = %d, mHeight = %d, "
370             "mFormat = %d, mFlags = 0x%08x, mInitCheck = %d",
371             surface->mSurface.get(), surface->mIdentity, surface->mWidth,
372             surface->mHeight, surface->mFormat, surface->mFlags,
373             surface->mInitCheck);
374    }
375    parcel->writeStrongBinder(sur!=0 ? sur->asBinder() : NULL);
376    parcel->writeInt32(identity);
377    parcel->writeInt32(width);
378    parcel->writeInt32(height);
379    parcel->writeInt32(format);
380    parcel->writeInt32(flags);
381    return NO_ERROR;
382
383}
384
385
386Mutex Surface::sCachedSurfacesLock;
387DefaultKeyedVector<wp<IBinder>, wp<Surface> > Surface::sCachedSurfaces;
388
389sp<Surface> Surface::readFromParcel(const Parcel& data) {
390    Mutex::Autolock _l(sCachedSurfacesLock);
391    sp<IBinder> binder(data.readStrongBinder());
392    sp<Surface> surface = sCachedSurfaces.valueFor(binder).promote();
393    if (surface == 0) {
394       surface = new Surface(data, binder);
395       sCachedSurfaces.add(binder, surface);
396    }
397    if (surface->mSurface == 0) {
398      surface = 0;
399    }
400    cleanCachedSurfacesLocked();
401    return surface;
402}
403
404// Remove the stale entries from the surface cache.  This should only be called
405// with sCachedSurfacesLock held.
406void Surface::cleanCachedSurfacesLocked() {
407    for (int i = sCachedSurfaces.size()-1; i >= 0; --i) {
408        wp<Surface> s(sCachedSurfaces.valueAt(i));
409        if (s == 0 || s.promote() == 0) {
410            sCachedSurfaces.removeItemsAt(i);
411        }
412    }
413}
414
415void Surface::init()
416{
417    ANativeWindow::setSwapInterval  = setSwapInterval;
418    ANativeWindow::dequeueBuffer    = dequeueBuffer;
419    ANativeWindow::cancelBuffer     = cancelBuffer;
420    ANativeWindow::lockBuffer       = lockBuffer;
421    ANativeWindow::queueBuffer      = queueBuffer;
422    ANativeWindow::query            = query;
423    ANativeWindow::perform          = perform;
424
425    DisplayInfo dinfo;
426    SurfaceComposerClient::getDisplayInfo(0, &dinfo);
427    const_cast<float&>(ANativeWindow::xdpi) = dinfo.xdpi;
428    const_cast<float&>(ANativeWindow::ydpi) = dinfo.ydpi;
429    // FIXME: set real values here
430    const_cast<int&>(ANativeWindow::minSwapInterval) = 1;
431    const_cast<int&>(ANativeWindow::maxSwapInterval) = 1;
432    const_cast<uint32_t&>(ANativeWindow::flags) = 0;
433
434    mNextBufferTransform = 0;
435    mConnected = 0;
436    mSwapRectangle.makeInvalid();
437    mNextBufferCrop = Rect(0,0);
438    // two buffers by default
439    mBuffers.setCapacity(2);
440    mBuffers.insertAt(0, 2);
441
442    if (mSurface != 0 && mClient.initCheck() == NO_ERROR) {
443        int32_t token = mClient.getTokenForSurface(mSurface);
444        if (token >= 0) {
445            mSharedBufferClient = new SharedBufferClient(
446                    mClient.getSharedClient(), token, 2, mIdentity);
447            mInitCheck = mClient.getSharedClient()->validate(token);
448        } else {
449            LOGW("Not initializing the shared buffer client because token = %d",
450                    token);
451        }
452    }
453}
454
455Surface::~Surface()
456{
457    // clear all references and trigger an IPC now, to make sure things
458    // happen without delay, since these resources are quite heavy.
459    mBuffers.clear();
460    mSurface.clear();
461    delete mSharedBufferClient;
462    IPCThreadState::self()->flushCommands();
463}
464
465bool Surface::isValid() {
466    return mInitCheck == NO_ERROR;
467}
468
469status_t Surface::validate(bool inCancelBuffer) const
470{
471    // check that we initialized ourself properly
472    if (mInitCheck != NO_ERROR) {
473        LOGE("invalid token (identity=%u)", mIdentity);
474        return mInitCheck;
475    }
476
477    // verify the identity of this surface
478    uint32_t identity = mSharedBufferClient->getIdentity();
479    if (mIdentity != identity) {
480        LOGE("[Surface] using an invalid surface, "
481                "identity=%u should be %d",
482                mIdentity, identity);
483        CallStack stack;
484        stack.update();
485        stack.dump("Surface");
486        return BAD_INDEX;
487    }
488
489    // check the surface didn't become invalid
490    status_t err = mSharedBufferClient->getStatus();
491    if (err != NO_ERROR) {
492        if (!inCancelBuffer) {
493            LOGE("surface (identity=%u) is invalid, err=%d (%s)",
494                    mIdentity, err, strerror(-err));
495            CallStack stack;
496            stack.update();
497            stack.dump("Surface");
498        }
499        return err;
500    }
501
502    return NO_ERROR;
503}
504
505sp<IBinder> Surface::asBinder() const {
506    return mSurface!=0 ? mSurface->asBinder() : 0;
507}
508
509// ----------------------------------------------------------------------------
510
511int Surface::setSwapInterval(ANativeWindow* window, int interval) {
512    return 0;
513}
514
515int Surface::dequeueBuffer(ANativeWindow* window,
516        ANativeWindowBuffer** buffer) {
517    Surface* self = getSelf(window);
518    return self->dequeueBuffer(buffer);
519}
520
521int Surface::cancelBuffer(ANativeWindow* window,
522        ANativeWindowBuffer* buffer) {
523    Surface* self = getSelf(window);
524    return self->cancelBuffer(buffer);
525}
526
527int Surface::lockBuffer(ANativeWindow* window,
528        ANativeWindowBuffer* buffer) {
529    Surface* self = getSelf(window);
530    return self->lockBuffer(buffer);
531}
532
533int Surface::queueBuffer(ANativeWindow* window,
534        ANativeWindowBuffer* buffer) {
535    Surface* self = getSelf(window);
536    return self->queueBuffer(buffer);
537}
538
539int Surface::query(const ANativeWindow* window,
540        int what, int* value) {
541    const Surface* self = getSelf(window);
542    return self->query(what, value);
543}
544
545int Surface::perform(ANativeWindow* window,
546        int operation, ...) {
547    va_list args;
548    va_start(args, operation);
549    Surface* self = getSelf(window);
550    int res = self->perform(operation, args);
551    va_end(args);
552    return res;
553}
554
555// ----------------------------------------------------------------------------
556
557bool Surface::needNewBuffer(int bufIdx,
558        uint32_t *pWidth, uint32_t *pHeight,
559        uint32_t *pFormat, uint32_t *pUsage) const
560{
561    Mutex::Autolock _l(mSurfaceLock);
562
563    // Always call needNewBuffer(), since it clears the needed buffers flags
564    bool needNewBuffer = mSharedBufferClient->needNewBuffer(bufIdx);
565    bool validBuffer = mBufferInfo.validateBuffer(mBuffers[bufIdx]);
566    bool newNeewBuffer = needNewBuffer || !validBuffer;
567    if (newNeewBuffer) {
568        mBufferInfo.get(pWidth, pHeight, pFormat, pUsage);
569    }
570    return newNeewBuffer;
571}
572
573int Surface::dequeueBuffer(ANativeWindowBuffer** buffer)
574{
575    status_t err = validate();
576    if (err != NO_ERROR)
577        return err;
578
579    GraphicLog& logger(GraphicLog::getInstance());
580    logger.log(GraphicLog::SF_APP_DEQUEUE_BEFORE, mIdentity, -1);
581
582    ssize_t bufIdx = mSharedBufferClient->dequeue();
583
584    logger.log(GraphicLog::SF_APP_DEQUEUE_AFTER, mIdentity, bufIdx);
585
586    if (bufIdx < 0) {
587        LOGE("error dequeuing a buffer (%s)", strerror(bufIdx));
588        return bufIdx;
589    }
590
591    // grow the buffer array if needed
592    const size_t size = mBuffers.size();
593    const size_t needed = bufIdx+1;
594    if (size < needed) {
595        mBuffers.insertAt(size, needed-size);
596    }
597
598    uint32_t w, h, format, usage;
599    if (needNewBuffer(bufIdx, &w, &h, &format, &usage)) {
600        err = getBufferLocked(bufIdx, w, h, format, usage);
601        LOGE_IF(err, "getBufferLocked(%ld, %u, %u, %u, %08x) failed (%s)",
602                bufIdx, w, h, format, usage, strerror(-err));
603        if (err == NO_ERROR) {
604            // reset the width/height with the what we get from the buffer
605            const sp<GraphicBuffer>& backBuffer(mBuffers[bufIdx]);
606            mWidth  = uint32_t(backBuffer->width);
607            mHeight = uint32_t(backBuffer->height);
608        }
609    }
610
611    // if we still don't have a buffer here, we probably ran out of memory
612    const sp<GraphicBuffer>& backBuffer(mBuffers[bufIdx]);
613    if (!err && backBuffer==0) {
614        err = NO_MEMORY;
615    }
616
617    if (err == NO_ERROR) {
618        mDirtyRegion.set(backBuffer->width, backBuffer->height);
619        *buffer = backBuffer.get();
620    } else {
621        mSharedBufferClient->undoDequeue(bufIdx);
622    }
623
624    return err;
625}
626
627int Surface::cancelBuffer(ANativeWindowBuffer* buffer)
628{
629    status_t err = validate(true);
630    switch (err) {
631    case NO_ERROR:
632        // no error, common case
633        break;
634    case BAD_INDEX:
635        // legitimate errors here
636        return err;
637    default:
638        // other errors happen because the surface is now invalid,
639        // for instance because it has been destroyed. In this case,
640        // we just fail silently (canceling a buffer is not technically
641        // an error at this point)
642        return NO_ERROR;
643    }
644
645    int32_t bufIdx = getBufferIndex(GraphicBuffer::getSelf(buffer));
646
647    err = mSharedBufferClient->cancel(bufIdx);
648
649    LOGE_IF(err, "error canceling buffer %d (%s)", bufIdx, strerror(-err));
650    return err;
651}
652
653
654int Surface::lockBuffer(ANativeWindowBuffer* buffer)
655{
656    status_t err = validate();
657    if (err != NO_ERROR)
658        return err;
659
660    int32_t bufIdx = getBufferIndex(GraphicBuffer::getSelf(buffer));
661
662    GraphicLog& logger(GraphicLog::getInstance());
663    logger.log(GraphicLog::SF_APP_LOCK_BEFORE, mIdentity, bufIdx);
664
665    err = mSharedBufferClient->lock(bufIdx);
666
667    logger.log(GraphicLog::SF_APP_LOCK_AFTER, mIdentity, bufIdx);
668
669    LOGE_IF(err, "error locking buffer %d (%s)", bufIdx, strerror(-err));
670    return err;
671}
672
673int Surface::queueBuffer(ANativeWindowBuffer* buffer)
674{
675    status_t err = validate();
676    if (err != NO_ERROR)
677        return err;
678
679    if (mSwapRectangle.isValid()) {
680        mDirtyRegion.set(mSwapRectangle);
681    }
682
683    int32_t bufIdx = getBufferIndex(GraphicBuffer::getSelf(buffer));
684
685    GraphicLog::getInstance().log(GraphicLog::SF_APP_QUEUE, mIdentity, bufIdx);
686
687    mSharedBufferClient->setTransform(bufIdx, mNextBufferTransform);
688    mSharedBufferClient->setCrop(bufIdx, mNextBufferCrop);
689    mSharedBufferClient->setDirtyRegion(bufIdx, mDirtyRegion);
690    err = mSharedBufferClient->queue(bufIdx);
691    LOGE_IF(err, "error queuing buffer %d (%s)", bufIdx, strerror(-err));
692
693    if (err == NO_ERROR) {
694        // TODO: can we avoid this IPC if we know there is one pending?
695        mClient.signalServer();
696    }
697    return err;
698}
699
700int Surface::query(int what, int* value) const
701{
702    switch (what) {
703    case NATIVE_WINDOW_WIDTH:
704        *value = int(mWidth);
705        return NO_ERROR;
706    case NATIVE_WINDOW_HEIGHT:
707        *value = int(mHeight);
708        return NO_ERROR;
709    case NATIVE_WINDOW_FORMAT:
710        *value = int(mFormat);
711        return NO_ERROR;
712    case NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS:
713        *value = MIN_UNDEQUEUED_BUFFERS;
714        return NO_ERROR;
715    case NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER: {
716        sp<ISurfaceComposer> sf(ComposerService::getComposerService());
717        *value = sf->authenticateSurface(mSurface) ? 1 : 0;
718        return NO_ERROR;
719    }
720    case NATIVE_WINDOW_CONCRETE_TYPE:
721        *value = NATIVE_WINDOW_SURFACE;
722        return NO_ERROR;
723    }
724    return BAD_VALUE;
725}
726
727int Surface::perform(int operation, va_list args)
728{
729    status_t err = validate();
730    if (err != NO_ERROR)
731        return err;
732
733    int res = NO_ERROR;
734    switch (operation) {
735    case NATIVE_WINDOW_SET_USAGE:
736        dispatch_setUsage( args );
737        break;
738    case NATIVE_WINDOW_CONNECT:
739        res = dispatch_connect( args );
740        break;
741    case NATIVE_WINDOW_DISCONNECT:
742        res = dispatch_disconnect( args );
743        break;
744    case NATIVE_WINDOW_SET_CROP:
745        res = dispatch_crop( args );
746        break;
747    case NATIVE_WINDOW_SET_BUFFER_COUNT:
748        res = dispatch_set_buffer_count( args );
749        break;
750    case NATIVE_WINDOW_SET_BUFFERS_GEOMETRY:
751        res = dispatch_set_buffers_geometry( args );
752        break;
753    case NATIVE_WINDOW_SET_BUFFERS_TRANSFORM:
754        res = dispatch_set_buffers_transform( args );
755        break;
756    case NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP:
757        res = dispatch_set_buffers_timestamp( args );
758        break;
759    default:
760        res = NAME_NOT_FOUND;
761        break;
762    }
763    return res;
764}
765
766void Surface::dispatch_setUsage(va_list args) {
767    int usage = va_arg(args, int);
768    setUsage( usage );
769}
770int Surface::dispatch_connect(va_list args) {
771    int api = va_arg(args, int);
772    return connect( api );
773}
774int Surface::dispatch_disconnect(va_list args) {
775    int api = va_arg(args, int);
776    return disconnect( api );
777}
778int Surface::dispatch_crop(va_list args) {
779    android_native_rect_t const* rect = va_arg(args, android_native_rect_t*);
780    return crop( reinterpret_cast<Rect const*>(rect) );
781}
782int Surface::dispatch_set_buffer_count(va_list args) {
783    size_t bufferCount = va_arg(args, size_t);
784    return setBufferCount(bufferCount);
785}
786int Surface::dispatch_set_buffers_geometry(va_list args) {
787    int w = va_arg(args, int);
788    int h = va_arg(args, int);
789    int f = va_arg(args, int);
790    return setBuffersGeometry(w, h, f);
791}
792
793int Surface::dispatch_set_buffers_transform(va_list args) {
794    int transform = va_arg(args, int);
795    return setBuffersTransform(transform);
796}
797
798int Surface::dispatch_set_buffers_timestamp(va_list args) {
799    int64_t timestamp = va_arg(args, int64_t);
800    return setBuffersTimestamp(timestamp);
801}
802
803void Surface::setUsage(uint32_t reqUsage)
804{
805    Mutex::Autolock _l(mSurfaceLock);
806    mBufferInfo.set(reqUsage);
807}
808
809int Surface::connect(int api)
810{
811    Mutex::Autolock _l(mSurfaceLock);
812    int err = NO_ERROR;
813    switch (api) {
814        case NATIVE_WINDOW_API_EGL:
815            if (mConnected) {
816                err = -EINVAL;
817            } else {
818                mConnected = api;
819            }
820            break;
821        default:
822            err = -EINVAL;
823            break;
824    }
825    return err;
826}
827
828int Surface::disconnect(int api)
829{
830    Mutex::Autolock _l(mSurfaceLock);
831    int err = NO_ERROR;
832    switch (api) {
833        case NATIVE_WINDOW_API_EGL:
834            if (mConnected == api) {
835                mConnected = 0;
836            } else {
837                err = -EINVAL;
838            }
839            break;
840        default:
841            err = -EINVAL;
842            break;
843    }
844    return err;
845}
846
847int Surface::crop(Rect const* rect)
848{
849    Mutex::Autolock _l(mSurfaceLock);
850    // TODO: validate rect size
851
852    if (rect == NULL || rect->isEmpty()) {
853        mNextBufferCrop = Rect(0,0);
854    } else {
855        mNextBufferCrop = *rect;
856    }
857
858    return NO_ERROR;
859}
860
861int Surface::setBufferCount(int bufferCount)
862{
863    sp<ISurface> s(mSurface);
864    if (s == 0) return NO_INIT;
865
866    class SetBufferCountIPC : public SharedBufferClient::SetBufferCountCallback {
867        sp<ISurface> surface;
868        virtual status_t operator()(int bufferCount) const {
869            return surface->setBufferCount(bufferCount);
870        }
871    public:
872        SetBufferCountIPC(const sp<ISurface>& surface) : surface(surface) { }
873    } ipc(s);
874
875    status_t err = mSharedBufferClient->setBufferCount(bufferCount, ipc);
876    LOGE_IF(err, "ISurface::setBufferCount(%d) returned %s",
877            bufferCount, strerror(-err));
878
879    if (err == NO_ERROR) {
880        // Clear out any references to the old buffers.
881        mBuffers.clear();
882    }
883
884    return err;
885}
886
887int Surface::setBuffersGeometry(int w, int h, int format)
888{
889    if (w<0 || h<0 || format<0)
890        return BAD_VALUE;
891
892    if ((w && !h) || (!w && h))
893        return BAD_VALUE;
894
895    Mutex::Autolock _l(mSurfaceLock);
896    if (mConnected == NATIVE_WINDOW_API_EGL) {
897        return INVALID_OPERATION;
898    }
899
900    mBufferInfo.set(w, h, format);
901    if (format != 0) {
902        // we update the format of the surface as reported by query().
903        // this is to allow applications to change the format of a surface's
904        // buffer, and have it reflected in EGL; which is needed for
905        // EGLConfig validation.
906        mFormat = format;
907    }
908
909    mNextBufferCrop = Rect(0,0);
910
911    return NO_ERROR;
912}
913
914int Surface::setBuffersTransform(int transform)
915{
916    Mutex::Autolock _l(mSurfaceLock);
917    mNextBufferTransform = transform;
918    return NO_ERROR;
919}
920
921int Surface::setBuffersTimestamp(int64_t timestamp)
922{
923    // Surface doesn't really have anything meaningful to do with timestamps
924    // so they'll just be dropped here.
925    return NO_ERROR;
926}
927
928// ----------------------------------------------------------------------------
929
930int Surface::getConnectedApi() const
931{
932    Mutex::Autolock _l(mSurfaceLock);
933    return mConnected;
934}
935
936// ----------------------------------------------------------------------------
937
938status_t Surface::lock(SurfaceInfo* info, bool blocking) {
939    return Surface::lock(info, NULL, blocking);
940}
941
942status_t Surface::lock(SurfaceInfo* other, Region* dirtyIn, bool blocking)
943{
944    if (getConnectedApi()) {
945        LOGE("Surface::lock(%p) failed. Already connected to another API",
946                (ANativeWindow*)this);
947        CallStack stack;
948        stack.update();
949        stack.dump("");
950        return INVALID_OPERATION;
951    }
952
953    if (mApiLock.tryLock() != NO_ERROR) {
954        LOGE("calling Surface::lock from different threads!");
955        CallStack stack;
956        stack.update();
957        stack.dump("");
958        return WOULD_BLOCK;
959    }
960
961    /* Here we're holding mApiLock */
962
963    if (mLockedBuffer != 0) {
964        LOGE("Surface::lock failed, already locked");
965        mApiLock.unlock();
966        return INVALID_OPERATION;
967    }
968
969    // we're intending to do software rendering from this point
970    setUsage(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);
971
972    ANativeWindowBuffer* out;
973    status_t err = dequeueBuffer(&out);
974    LOGE_IF(err, "dequeueBuffer failed (%s)", strerror(-err));
975    if (err == NO_ERROR) {
976        sp<GraphicBuffer> backBuffer(GraphicBuffer::getSelf(out));
977        err = lockBuffer(backBuffer.get());
978        LOGE_IF(err, "lockBuffer (idx=%d) failed (%s)",
979                getBufferIndex(backBuffer), strerror(-err));
980        if (err == NO_ERROR) {
981            const Rect bounds(backBuffer->width, backBuffer->height);
982            const Region boundsRegion(bounds);
983            Region scratch(boundsRegion);
984            Region& newDirtyRegion(dirtyIn ? *dirtyIn : scratch);
985            newDirtyRegion &= boundsRegion;
986
987            // figure out if we can copy the frontbuffer back
988            const sp<GraphicBuffer>& frontBuffer(mPostedBuffer);
989            const bool canCopyBack = (frontBuffer != 0 &&
990                    backBuffer->width  == frontBuffer->width &&
991                    backBuffer->height == frontBuffer->height &&
992                    backBuffer->format == frontBuffer->format &&
993                    !(mFlags & ISurfaceComposer::eDestroyBackbuffer));
994
995            // the dirty region we report to surfaceflinger is the one
996            // given by the user (as opposed to the one *we* return to the
997            // user).
998            mDirtyRegion = newDirtyRegion;
999
1000            if (canCopyBack) {
1001                // copy the area that is invalid and not repainted this round
1002                const Region copyback(mOldDirtyRegion.subtract(newDirtyRegion));
1003                if (!copyback.isEmpty())
1004                    copyBlt(backBuffer, frontBuffer, copyback);
1005            } else {
1006                // if we can't copy-back anything, modify the user's dirty
1007                // region to make sure they redraw the whole buffer
1008                newDirtyRegion = boundsRegion;
1009            }
1010
1011            // keep track of the are of the buffer that is "clean"
1012            // (ie: that will be redrawn)
1013            mOldDirtyRegion = newDirtyRegion;
1014
1015            void* vaddr;
1016            status_t res = backBuffer->lock(
1017                    GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
1018                    newDirtyRegion.bounds(), &vaddr);
1019
1020            LOGW_IF(res, "failed locking buffer (handle = %p)",
1021                    backBuffer->handle);
1022
1023            mLockedBuffer = backBuffer;
1024            other->w      = backBuffer->width;
1025            other->h      = backBuffer->height;
1026            other->s      = backBuffer->stride;
1027            other->usage  = backBuffer->usage;
1028            other->format = backBuffer->format;
1029            other->bits   = vaddr;
1030        }
1031    }
1032    mApiLock.unlock();
1033    return err;
1034}
1035
1036status_t Surface::unlockAndPost()
1037{
1038    if (mLockedBuffer == 0) {
1039        LOGE("Surface::unlockAndPost failed, no locked buffer");
1040        return INVALID_OPERATION;
1041    }
1042
1043    status_t err = mLockedBuffer->unlock();
1044    LOGE_IF(err, "failed unlocking buffer (%p)", mLockedBuffer->handle);
1045
1046    err = queueBuffer(mLockedBuffer.get());
1047    LOGE_IF(err, "queueBuffer (idx=%d) failed (%s)",
1048            getBufferIndex(mLockedBuffer), strerror(-err));
1049
1050    mPostedBuffer = mLockedBuffer;
1051    mLockedBuffer = 0;
1052    return err;
1053}
1054
1055void Surface::setSwapRectangle(const Rect& r) {
1056    Mutex::Autolock _l(mSurfaceLock);
1057    mSwapRectangle = r;
1058}
1059
1060int Surface::getBufferIndex(const sp<GraphicBuffer>& buffer) const
1061{
1062    int idx = buffer->getIndex();
1063    if (idx < 0) {
1064        // The buffer doesn't have an index set.  See if the handle the same as
1065        // one of the buffers for which we do know the index.  This can happen
1066        // e.g. if GraphicBuffer is used to wrap an ANativeWindowBuffer that
1067        // was dequeued from an ANativeWindow.
1068        for (size_t i = 0; i < mBuffers.size(); i++) {
1069            if (mBuffers[i] != 0 && buffer->handle == mBuffers[i]->handle) {
1070                idx = mBuffers[i]->getIndex();
1071                break;
1072            }
1073        }
1074    }
1075    return idx;
1076}
1077
1078status_t Surface::getBufferLocked(int index,
1079        uint32_t w, uint32_t h, uint32_t format, uint32_t usage)
1080{
1081    sp<ISurface> s(mSurface);
1082    if (s == 0) return NO_INIT;
1083
1084    status_t err = NO_MEMORY;
1085
1086    // free the current buffer
1087    sp<GraphicBuffer>& currentBuffer(mBuffers.editItemAt(index));
1088    if (currentBuffer != 0) {
1089        currentBuffer.clear();
1090    }
1091
1092    sp<GraphicBuffer> buffer = s->requestBuffer(index, w, h, format, usage);
1093    LOGE_IF(buffer==0,
1094            "ISurface::getBuffer(%d, %08x) returned NULL",
1095            index, usage);
1096    if (buffer != 0) { // this should always happen by construction
1097        LOGE_IF(buffer->handle == NULL,
1098                "Surface (identity=%d) requestBuffer(%d, %u, %u, %u, %08x) "
1099                "returned a buffer with a null handle",
1100                mIdentity, index, w, h, format, usage);
1101        err = mSharedBufferClient->getStatus();
1102        LOGE_IF(err,  "Surface (identity=%d) state = %d", mIdentity, err);
1103        if (!err && buffer->handle != NULL) {
1104            currentBuffer = buffer;
1105            currentBuffer->setIndex(index);
1106        } else {
1107            err = err<0 ? err : status_t(NO_MEMORY);
1108        }
1109    }
1110    return err;
1111}
1112
1113// ----------------------------------------------------------------------------
1114Surface::BufferInfo::BufferInfo()
1115    : mWidth(0), mHeight(0), mFormat(0),
1116      mUsage(GRALLOC_USAGE_HW_RENDER), mDirty(0)
1117{
1118}
1119
1120void Surface::BufferInfo::set(uint32_t w, uint32_t h, uint32_t format) {
1121    if ((mWidth != w) || (mHeight != h) || (mFormat != format)) {
1122        mWidth = w;
1123        mHeight = h;
1124        mFormat = format;
1125        mDirty |= GEOMETRY;
1126    }
1127}
1128
1129void Surface::BufferInfo::set(uint32_t usage) {
1130    mUsage = usage;
1131}
1132
1133void Surface::BufferInfo::get(uint32_t *pWidth, uint32_t *pHeight,
1134        uint32_t *pFormat, uint32_t *pUsage) const {
1135    *pWidth  = mWidth;
1136    *pHeight = mHeight;
1137    *pFormat = mFormat;
1138    *pUsage  = mUsage;
1139}
1140
1141bool Surface::BufferInfo::validateBuffer(const sp<GraphicBuffer>& buffer) const {
1142    // make sure we AT LEAST have the usage flags we want
1143    if (mDirty || buffer==0 ||
1144            ((buffer->usage & mUsage) != mUsage)) {
1145        mDirty = 0;
1146        return false;
1147    }
1148    return true;
1149}
1150
1151// ----------------------------------------------------------------------------
1152}; // namespace android
1153