From 1473f46cbc82aa6f0ba744cc896a36923823d55b Mon Sep 17 00:00:00 2001 From: Mathias Agopian Date: Fri, 10 Apr 2009 14:24:30 -0700 Subject: Integrate from //sandbox/mathias/donut/...@145728 SurfaceFlinger rework for new EGL driver model support. --- libs/ui/SurfaceComposerClient.cpp | 283 +++----------------------------------- 1 file changed, 16 insertions(+), 267 deletions(-) (limited to 'libs/ui/SurfaceComposerClient.cpp') diff --git a/libs/ui/SurfaceComposerClient.cpp b/libs/ui/SurfaceComposerClient.cpp index fe803ff24964..e1b13c7b8eed 100644 --- a/libs/ui/SurfaceComposerClient.cpp +++ b/libs/ui/SurfaceComposerClient.cpp @@ -29,27 +29,21 @@ #include #include #include -#include #include #include #include +#include #include #include #include #include -#include #include -#include #include #include #include -#include - -#include - #define VERBOSE(...) ((void)0) //#define VERBOSE LOGD @@ -109,50 +103,8 @@ static volatile surface_flinger_cblk_t const * get_cblk() // --------------------------------------------------------------------------- -static void copyBlt(const GGLSurface& dst, - const GGLSurface& src, const Region& reg) -{ - Region::iterator iterator(reg); - if (iterator) { - // NOTE: dst and src must be the same format - Rect r; - const size_t bpp = bytesPerPixel(src.format); - const size_t dbpr = dst.stride * bpp; - const size_t sbpr = src.stride * bpp; - while (iterator.iterate(&r)) { - ssize_t h = r.bottom - r.top; - if (h) { - size_t size = (r.right - r.left) * bpp; - uint8_t* s = src.data + (r.left + src.stride * r.top) * bpp; - uint8_t* d = dst.data + (r.left + dst.stride * r.top) * bpp; - if (dbpr==sbpr && size==sbpr) { - size *= h; - h = 1; - } - do { - memcpy(d, s, size); - d += dbpr; - s += sbpr; - } while (--h > 0); - } - } - } -} - -// --------------------------------------------------------------------------- - -surface_flinger_cblk_t::surface_flinger_cblk_t() -{ -} - -// --------------------------------------------------------------------------- - -per_client_cblk_t::per_client_cblk_t() -{ -} - // these functions are used by the clients -inline status_t per_client_cblk_t::validate(size_t i) const { +status_t per_client_cblk_t::validate(size_t i) const { if (uint32_t(i) >= NUM_LAYERS_MAX) return BAD_INDEX; if (layers[i].swapState & eInvalidSurface) @@ -248,8 +200,9 @@ int32_t per_client_cblk_t::lock_layer(size_t i, uint32_t flags) index = (state&eIndex) ^ ((state&eFlipRequested)>>1); // make sure this buffer is valid - if (layer->surface[index].bits_offset < 0) { - return status_t(layer->surface[index].bits_offset); + status_t err = layer->surface[index].status; + if (err < 0) { + return err; } if (inspect) { @@ -273,7 +226,7 @@ done: uint32_t per_client_cblk_t::unlock_layer_and_post(size_t i) { - // atomically set eFlipRequested and clear eLocked and optionnaly + // atomically set eFlipRequested and clear eLocked and optionally // set eNextFlipPending if eFlipRequested was already set layer_cblk_t * const layer = layers + i; @@ -290,7 +243,7 @@ uint32_t per_client_cblk_t::unlock_layer_and_post(size_t i) if (oldvalue & eFlipRequested) newvalue |= eNextFlipPending; - // if eFlipRequested was alread set, set eNextFlipPending + // if eFlipRequested was already set, set eNextFlipPending } while (android_atomic_cmpxchg(oldvalue, newvalue, &(layer->swapState))); @@ -298,9 +251,9 @@ uint32_t per_client_cblk_t::unlock_layer_and_post(size_t i) int(i), int((layer->flags & eBufferIndex) >> eBufferIndexShift), int(newvalue)); - // from this point, the server can kick in at anytime and use the first + // from this point, the server can kick in at any time and use the first // buffer, so we cannot use it anymore, and we must use the 'other' - // buffer instead (or wait if it is not availlable yet, see lock_layer). + // buffer instead (or wait if it is not available yet, see lock_layer). return newvalue; } @@ -376,32 +329,6 @@ status_t SurfaceComposerClient::initCheck() const return mStatus; } -status_t SurfaceComposerClient::validateSurface( - per_client_cblk_t const* cblk, Surface const * surface) -{ - SurfaceID index = surface->ID(); - if (cblk == 0) { - LOGE("cblk is null (surface id=%d, identity=%u)", - index, surface->getIdentity()); - return NO_INIT; - } - - status_t err = cblk->validate(index); - if (err != NO_ERROR) { - LOGE("surface (id=%d, identity=%u) is invalid, err=%d (%s)", - index, surface->getIdentity(), err, strerror(-err)); - return err; - } - - if (surface->getIdentity() != uint32_t(cblk->layers[index].identity)) { - LOGE("using an invalid surface id=%d, identity=%u should be %d", - index, surface->getIdentity(), cblk->layers[index].identity); - return NO_INIT; - } - - return NO_ERROR; -} - sp SurfaceComposerClient::connection() const { return (mClient != 0) ? mClient->asBinder() : 0; @@ -439,7 +366,6 @@ void SurfaceComposerClient::dispose() sp controlMemory; sp client; - sp surfaceHeap; { Mutex::Autolock _lg(gLock); @@ -462,9 +388,7 @@ void SurfaceComposerClient::dispose() delete mPrebuiltLayerState; mPrebuiltLayerState = 0; controlMemory = mControlMemory; - surfaceHeap = mSurfaceHeap; mControlMemory.clear(); - mSurfaceHeap.clear(); mControl = 0; mStatus = NO_INIT; } @@ -528,6 +452,12 @@ ssize_t SurfaceComposerClient::getNumberOfDisplays() return n; } + +void SurfaceComposerClient::signalServer() +{ + mSignalServer->signal(); +} + sp SurfaceComposerClient::createSurface( int pid, DisplayID display, @@ -568,186 +498,6 @@ status_t SurfaceComposerClient::destroySurface(SurfaceID sid) return err; } -status_t SurfaceComposerClient::nextBuffer(Surface* surface, - Surface::SurfaceInfo* info) -{ - SurfaceID index = surface->ID(); - per_client_cblk_t* const cblk = mControl; - status_t err = validateSurface(cblk, surface); - if (err != NO_ERROR) - return err; - - int32_t backIdx = surface->mBackbufferIndex; - layer_cblk_t* const lcblk = &(cblk->layers[index]); - const surface_info_t* const front = lcblk->surface + (1-backIdx); - info->w = front->w; - info->h = front->h; - info->format = front->format; - info->base = surface->heapBase(1-backIdx); - info->bits = reinterpret_cast(intptr_t(info->base) + front->bits_offset); - info->bpr = front->bpr; - - return 0; -} - -status_t SurfaceComposerClient::lockSurface( - Surface* surface, - Surface::SurfaceInfo* other, - Region* dirty, - bool blocking) -{ - Mutex::Autolock _l(surface->getLock()); - - SurfaceID index = surface->ID(); - per_client_cblk_t* const cblk = mControl; - status_t err = validateSurface(cblk, surface); - if (err != NO_ERROR) - return err; - - int32_t backIdx = cblk->lock_layer(size_t(index), - per_client_cblk_t::BLOCKING); - if (backIdx >= 0) { - surface->mBackbufferIndex = backIdx; - layer_cblk_t* const lcblk = &(cblk->layers[index]); - const surface_info_t* const back = lcblk->surface + backIdx; - const surface_info_t* const front = lcblk->surface + (1-backIdx); - other->w = back->w; - other->h = back->h; - other->format = back->format; - other->base = surface->heapBase(backIdx); - other->bits = reinterpret_cast(intptr_t(other->base) + back->bits_offset); - other->bpr = back->bpr; - - const Rect bounds(other->w, other->h); - Region newDirtyRegion; - - if (back->flags & surface_info_t::eBufferDirty) { - /* it is safe to write *back here, because we're guaranteed - * SurfaceFlinger is not touching it (since it just granted - * access to us) */ - const_cast(back)->flags &= - ~surface_info_t::eBufferDirty; - - // content is meaningless in this case and the whole surface - // needs to be redrawn. - - newDirtyRegion.set(bounds); - if (dirty) { - *dirty = newDirtyRegion; - } - - //if (bytesPerPixel(other->format) == 4) { - // android_memset32( - // (uint32_t*)other->bits, 0xFF00FF00, other->h * other->bpr); - //} else { - // android_memset16( // fill with green - // (uint16_t*)other->bits, 0x7E0, other->h * other->bpr); - //} - } - else - { - if (dirty) { - dirty->andSelf(Region(bounds)); - newDirtyRegion = *dirty; - } else { - newDirtyRegion.set(bounds); - } - - Region copyback; - if (!(lcblk->flags & eNoCopyBack)) { - const Region previousDirtyRegion(surface->dirtyRegion()); - copyback = previousDirtyRegion.subtract(newDirtyRegion); - } - - if (!copyback.isEmpty()) { - // copy front to back - GGLSurface cb; - cb.version = sizeof(GGLSurface); - cb.width = back->w; - cb.height = back->h; - cb.stride = back->stride; - cb.data = (GGLubyte*)surface->heapBase(backIdx); - cb.data += back->bits_offset; - cb.format = back->format; - - GGLSurface t; - t.version = sizeof(GGLSurface); - t.width = front->w; - t.height = front->h; - t.stride = front->stride; - t.data = (GGLubyte*)surface->heapBase(1-backIdx); - t.data += front->bits_offset; - t.format = front->format; - - //const Region copyback(lcblk->region + 1-backIdx); - copyBlt(cb, t, copyback); - } - } - - // update dirty region - surface->setDirtyRegion(newDirtyRegion); - } - return (backIdx < 0) ? status_t(backIdx) : status_t(NO_ERROR); -} - -void SurfaceComposerClient::_signal_server() -{ - mSignalServer->signal(); -} - -void SurfaceComposerClient::_send_dirty_region( - layer_cblk_t* lcblk, const Region& dirty) -{ - const int32_t index = (lcblk->flags & eBufferIndex) >> eBufferIndexShift; - flat_region_t* flat_region = lcblk->region + index; - status_t err = dirty.write(flat_region, sizeof(flat_region_t)); - if (err < NO_ERROR) { - // region doesn't fit, use the bounds - const Region reg(dirty.bounds()); - reg.write(flat_region, sizeof(flat_region_t)); - } -} - -status_t SurfaceComposerClient::unlockAndPostSurface(Surface* surface) -{ - Mutex::Autolock _l(surface->getLock()); - - SurfaceID index = surface->ID(); - per_client_cblk_t* const cblk = mControl; - status_t err = validateSurface(cblk, surface); - if (err != NO_ERROR) - return err; - - Region dirty(surface->dirtyRegion()); - const Rect& swapRect(surface->swapRectangle()); - if (swapRect.isValid()) { - dirty.set(swapRect); - } - - // transmit the dirty region - layer_cblk_t* const lcblk = &(cblk->layers[index]); - _send_dirty_region(lcblk, dirty); - uint32_t newstate = cblk->unlock_layer_and_post(size_t(index)); - if (!(newstate & eNextFlipPending)) - _signal_server(); - return NO_ERROR; -} - -status_t SurfaceComposerClient::unlockSurface(Surface* surface) -{ - Mutex::Autolock _l(surface->getLock()); - - SurfaceID index = surface->ID(); - per_client_cblk_t* const cblk = mControl; - status_t err = validateSurface(cblk, surface); - if (err != NO_ERROR) - return err; - - layer_cblk_t* const lcblk = &(cblk->layers[index]); - cblk->unlock_layer(size_t(index)); - return NO_ERROR; -} - void SurfaceComposerClient::openGlobalTransaction() { Mutex::Autolock _l(gLock); @@ -870,7 +620,7 @@ layer_state_t* SurfaceComposerClient::_get_state_l(const sp& surface) { SurfaceID index = surface->ID(); per_client_cblk_t* const cblk = mControl; - status_t err = validateSurface(cblk, surface.get()); + status_t err = surface->validate(cblk); if (err != NO_ERROR) return 0; @@ -973,7 +723,6 @@ status_t SurfaceComposerClient::setFlags(Surface* surface, return NO_ERROR; } - status_t SurfaceComposerClient::setTransparentRegionHint( Surface* surface, const Region& transparentRegion) { -- cgit v1.2.3-59-g8ed1b From 6d2c0bc7bfe10a9b70ca608baf626c47a228fa6b Mon Sep 17 00:00:00 2001 From: Mathias Agopian Date: Thu, 16 Apr 2009 16:19:50 -0700 Subject: split Surface.cpp into Surface and SurfaceControl SurfaceControl is used for controling the geometry of the surface (for the WM), while Surface is used to access the buffers (for SF's clients). SurfaceFlingerClient now uses the SurfaceID instead of Surface*. Currently Surface still has the SurfaceControl API and is implemented by calling into SurfaceControl. --- include/ui/Surface.h | 72 +++++++++ include/ui/SurfaceComposerClient.h | 29 ++-- libs/ui/Surface.cpp | 313 ++++++++++++++++++++++++++++++------- libs/ui/SurfaceComposerClient.cpp | 60 ++++--- 4 files changed, 369 insertions(+), 105 deletions(-) (limited to 'libs/ui/SurfaceComposerClient.cpp') diff --git a/include/ui/Surface.h b/include/ui/Surface.h index 1637961b6af8..87a11c2824f2 100644 --- a/include/ui/Surface.h +++ b/include/ui/Surface.h @@ -76,6 +76,76 @@ private: // --------------------------------------------------------------------------- +class SurfaceControl : public RefBase +{ +public: + static bool isValid(const sp& surface) { + return (surface != 0) && surface->mToken>=0 && surface->mClient!=0; + } + + SurfaceID ID() const { return mToken; } + uint32_t getFlags() const { return mFlags; } + uint32_t getIdentity() const { return mIdentity; } + + // release surface data from java + void clear(); + + static sp readFromParcel(Parcel* parcel); + static status_t writeToParcel(const sp& surface, Parcel* parcel); + static bool isSameSurface(const sp& lhs, const sp& rhs); + + status_t setLayer(int32_t layer); + status_t setPosition(int32_t x, int32_t y); + status_t setSize(uint32_t w, uint32_t h); + status_t hide(); + status_t show(int32_t layer = -1); + status_t freeze(); + status_t unfreeze(); + status_t setFlags(uint32_t flags, uint32_t mask); + status_t setTransparentRegionHint(const Region& transparent); + status_t setAlpha(float alpha=1.0f); + status_t setMatrix(float dsdx, float dtdx, float dsdy, float dtdy); + status_t setFreezeTint(uint32_t tint); + +private: + friend class SurfaceComposerClient; + + // camera and camcorder need access to the ISurface binder interface for preview + friend class Camera; + friend class MediaRecorder; + // mediaplayer needs access to ISurface for display + friend class MediaPlayer; + friend class Test; + const sp& getISurface() const { return mSurface; } + + // can't be copied + SurfaceControl& operator = (SurfaceControl& rhs); + SurfaceControl(const SurfaceControl& rhs); + + friend class Surface; + SurfaceControl(const sp& client, + const sp& surface, + const ISurfaceFlingerClient::surface_data_t& data, + uint32_t w, uint32_t h, PixelFormat format, uint32_t flags, + bool owner = true); + + ~SurfaceControl(); + + status_t validate(per_client_cblk_t const* cblk) const; + void destroy(); + + sp mClient; + sp mSurface; + SurfaceID mToken; + uint32_t mIdentity; + PixelFormat mFormat; + uint32_t mFlags; + const bool mOwner; + mutable Mutex mLock; +}; + +// --------------------------------------------------------------------------- + class Surface : public EGLNativeBase { @@ -192,6 +262,8 @@ private: mutable Rect mSwapRectangle; mutable uint8_t mBackbufferIndex; mutable Mutex mSurfaceLock; + + sp mSurfaceControl; }; }; // namespace android diff --git a/include/ui/SurfaceComposerClient.h b/include/ui/SurfaceComposerClient.h index 86de6ea34393..a175a18a0dc3 100644 --- a/include/ui/SurfaceComposerClient.h +++ b/include/ui/SurfaceComposerClient.h @@ -111,22 +111,23 @@ public: private: friend class Surface; + friend class SurfaceControl; SurfaceComposerClient(const sp& sm, const sp& conn); - status_t hide(Surface* surface); - status_t show(Surface* surface, int32_t layer = -1); - status_t freeze(Surface* surface); - status_t unfreeze(Surface* surface); - status_t setFlags(Surface* surface, uint32_t flags, uint32_t mask); - status_t setTransparentRegionHint(Surface* surface, const Region& transparent); - status_t setLayer(Surface* surface, int32_t layer); - status_t setAlpha(Surface* surface, float alpha=1.0f); - status_t setFreezeTint(Surface* surface, uint32_t tint); - status_t setMatrix(Surface* surface, float dsdx, float dtdx, float dsdy, float dtdy); - status_t setPosition(Surface* surface, int32_t x, int32_t y); - status_t setSize(Surface* surface, uint32_t w, uint32_t h); + status_t hide(SurfaceID id); + status_t show(SurfaceID id, int32_t layer = -1); + status_t freeze(SurfaceID id); + status_t unfreeze(SurfaceID id); + status_t setFlags(SurfaceID id, uint32_t flags, uint32_t mask); + status_t setTransparentRegionHint(SurfaceID id, const Region& transparent); + status_t setLayer(SurfaceID id, int32_t layer); + status_t setAlpha(SurfaceID id, float alpha=1.0f); + status_t setFreezeTint(SurfaceID id, uint32_t tint); + status_t setMatrix(SurfaceID id, float dsdx, float dtdx, float dsdy, float dtdy); + status_t setPosition(SurfaceID id, int32_t x, int32_t y); + status_t setSize(SurfaceID id, uint32_t w, uint32_t h); void signalServer(); @@ -135,8 +136,8 @@ private: void _init(const sp& sm, const sp& conn); - inline layer_state_t* _get_state_l(const sp& surface); - layer_state_t* _lockLayerState(const sp& surface); + inline layer_state_t* _get_state_l(SurfaceID id); + layer_state_t* _lockLayerState(SurfaceID id); inline void _unlockLayerState(); mutable Mutex mLock; diff --git a/libs/ui/Surface.cpp b/libs/ui/Surface.cpp index 51abd95faa05..63699c7fd7b1 100644 --- a/libs/ui/Surface.cpp +++ b/libs/ui/Surface.cpp @@ -143,6 +143,216 @@ static void copyBlt(const android_native_buffer_t* dst, } } + +// ============================================================================ +// SurfaceControl +// ============================================================================ + + +SurfaceControl::SurfaceControl(const sp& client, + const sp& surface, + const ISurfaceFlingerClient::surface_data_t& data, + uint32_t w, uint32_t h, PixelFormat format, uint32_t flags, + bool owner) + : mClient(client), mSurface(surface), + mToken(data.token), mIdentity(data.identity), + mFormat(format), mFlags(flags), mOwner(owner) +{ +} + +SurfaceControl::~SurfaceControl() +{ + destroy(); +} + +void SurfaceControl::destroy() +{ + // Destroy the surface in SurfaceFlinger if we were the owner + // (in any case, a client won't be able to, because it won't have the + // right permission). + if (mOwner && mToken>=0 && mClient!=0) { + mClient->destroySurface(mToken); + } + + // clear all references and trigger an IPC now, to make sure things + // happen without delay, since these resources are quite heavy. + mClient.clear(); + mSurface.clear(); + IPCThreadState::self()->flushCommands(); +} + +void SurfaceControl::clear() +{ + // here, the window manager tells us explicitly that we should destroy + // the surface's resource. Soon after this call, it will also release + // its last reference (which will call the dtor); however, it is possible + // that a client living in the same process still holds references which + // would delay the call to the dtor -- that is why we need this explicit + // "clear()" call. + destroy(); +} + +status_t SurfaceControl::setLayer(int32_t layer) { + const sp& client(mClient); + if (client == 0) return INVALID_OPERATION; + status_t err = validate(client->mControl); + if (err < 0) return err; + return client->setLayer(mToken, layer); +} +status_t SurfaceControl::setPosition(int32_t x, int32_t y) { + const sp& client(mClient); + if (client == 0) return INVALID_OPERATION; + status_t err = validate(client->mControl); + if (err < 0) return err; + return client->setPosition(mToken, x, y); +} +status_t SurfaceControl::setSize(uint32_t w, uint32_t h) { + const sp& client(mClient); + if (client == 0) return INVALID_OPERATION; + status_t err = validate(client->mControl); + if (err < 0) return err; + return client->setSize(mToken, w, h); +} +status_t SurfaceControl::hide() { + const sp& client(mClient); + if (client == 0) return INVALID_OPERATION; + status_t err = validate(client->mControl); + if (err < 0) return err; + return client->hide(mToken); +} +status_t SurfaceControl::show(int32_t layer) { + const sp& client(mClient); + if (client == 0) return INVALID_OPERATION; + status_t err = validate(client->mControl); + if (err < 0) return err; + return client->show(mToken, layer); +} +status_t SurfaceControl::freeze() { + const sp& client(mClient); + if (client == 0) return INVALID_OPERATION; + status_t err = validate(client->mControl); + if (err < 0) return err; + return client->freeze(mToken); +} +status_t SurfaceControl::unfreeze() { + const sp& client(mClient); + if (client == 0) return INVALID_OPERATION; + status_t err = validate(client->mControl); + if (err < 0) return err; + return client->unfreeze(mToken); +} +status_t SurfaceControl::setFlags(uint32_t flags, uint32_t mask) { + const sp& client(mClient); + if (client == 0) return INVALID_OPERATION; + status_t err = validate(client->mControl); + if (err < 0) return err; + return client->setFlags(mToken, flags, mask); +} +status_t SurfaceControl::setTransparentRegionHint(const Region& transparent) { + const sp& client(mClient); + if (client == 0) return INVALID_OPERATION; + status_t err = validate(client->mControl); + if (err < 0) return err; + return client->setTransparentRegionHint(mToken, transparent); +} +status_t SurfaceControl::setAlpha(float alpha) { + const sp& client(mClient); + if (client == 0) return INVALID_OPERATION; + status_t err = validate(client->mControl); + if (err < 0) return err; + return client->setAlpha(mToken, alpha); +} +status_t SurfaceControl::setMatrix(float dsdx, float dtdx, float dsdy, float dtdy) { + const sp& client(mClient); + if (client == 0) return INVALID_OPERATION; + status_t err = validate(client->mControl); + if (err < 0) return err; + return client->setMatrix(mToken, dsdx, dtdx, dsdy, dtdy); +} +status_t SurfaceControl::setFreezeTint(uint32_t tint) { + const sp& client(mClient); + if (client == 0) return INVALID_OPERATION; + status_t err = validate(client->mControl); + if (err < 0) return err; + return client->setFreezeTint(mToken, tint); +} + +sp SurfaceControl::readFromParcel(Parcel* parcel) +{ + sp client; + ISurfaceFlingerClient::surface_data_t data; + sp clientBinder= parcel->readStrongBinder(); + sp surface = interface_cast(parcel->readStrongBinder()); + data.token = parcel->readInt32(); + data.identity = parcel->readInt32(); + PixelFormat format = parcel->readInt32(); + uint32_t flags = parcel->readInt32(); + + if (clientBinder != NULL) + client = SurfaceComposerClient::clientForConnection(clientBinder); + + return new SurfaceControl(client, surface, data, 0, 0, format, flags, false); +} + +status_t SurfaceControl::writeToParcel(const sp& surface, Parcel* parcel) +{ + uint32_t flags=0; + uint32_t format=0; + SurfaceID token = -1; + uint32_t identity = 0; + sp client; + sp sur; + if (SurfaceControl::isValid(surface)) { + token = surface->mToken; + identity = surface->mIdentity; + client = surface->mClient; + sur = surface->mSurface; + format = surface->mFormat; + flags = surface->mFlags; + } + parcel->writeStrongBinder(client!=0 ? client->connection() : NULL); + parcel->writeStrongBinder(sur!=0 ? sur->asBinder() : NULL); + parcel->writeInt32(token); + parcel->writeInt32(identity); + parcel->writeInt32(format); + parcel->writeInt32(flags); + return NO_ERROR; +} + +bool SurfaceControl::isSameSurface( + const sp& lhs, const sp& rhs) +{ + if (lhs == 0 || rhs == 0) + return false; + return lhs->mSurface->asBinder() == rhs->mSurface->asBinder(); +} + + +status_t SurfaceControl::validate(per_client_cblk_t const* cblk) const +{ + if (mToken<0 || mClient==0) { + LOGE("invalid token (%d, identity=%u) or client (%p)", + mToken, mIdentity, mClient.get()); + return NO_INIT; + } + if (cblk == 0) { + LOGE("cblk is null (surface id=%d, identity=%u)", mToken, mIdentity); + return NO_INIT; + } + status_t err = cblk->validate(mToken); + if (err != NO_ERROR) { + LOGE("surface (id=%d, identity=%u) is invalid, err=%d (%s)", + mToken, mIdentity, err, strerror(-err)); + return err; + } + if (mIdentity != uint32_t(cblk->layers[mToken].identity)) { + LOGE("using an invalid surface id=%d, identity=%u should be %d", + mToken, mIdentity, cblk->layers[mToken].identity); + return NO_INIT; + } + return NO_ERROR; +} + // ============================================================================ // Surface // ============================================================================ @@ -156,6 +366,9 @@ Surface::Surface(const sp& client, mToken(data.token), mIdentity(data.identity), mFormat(format), mFlags(flags), mOwner(owner) { + mSurfaceControl = new SurfaceControl( + client, surface, data, w, h, format, flags, owner); + android_native_window_t::connect = connect; android_native_window_t::disconnect = disconnect; android_native_window_t::setSwapInterval = setSwapInterval; @@ -191,12 +404,7 @@ Surface::~Surface() void Surface::destroy() { - // Destroy the surface in SurfaceFlinger if we were the owner - // (in any case, a client won't be able to, because it won't have the - // right permission). - if (mOwner && mToken>=0 && mClient!=0) { - mClient->destroySurface(mToken); - } + mSurfaceControl->destroy(); // clear all references and trigger an IPC now, to make sure things // happen without delay, since these resources are quite heavy. @@ -207,20 +415,7 @@ void Surface::destroy() void Surface::clear() { - // here, the window manager tells us explicitly that we should destroy - // the surface's resource. Soon after this call, it will also release - // its last reference (which will call the dtor); however, it is possible - // that a client living in the same process still holds references which - // would delay the call to the dtor -- that is why we need this explicit - // "clear()" call. - - // FIXME: we should probably unmap the buffers here. The problem is that - // the app could be in the middle of using them, and if we don't unmap now - // and we're in the system process, the mapping will be lost (because - // the buffer will be freed, and the handles destroyed) - - Mutex::Autolock _l(mSurfaceLock); - destroy(); + mSurfaceControl->clear(); } status_t Surface::validate(per_client_cblk_t const* cblk) const @@ -473,44 +668,6 @@ void Surface::_send_dirty_region( } } - -status_t Surface::setLayer(int32_t layer) { - return mClient->setLayer(this, layer); -} -status_t Surface::setPosition(int32_t x, int32_t y) { - return mClient->setPosition(this, x, y); -} -status_t Surface::setSize(uint32_t w, uint32_t h) { - return mClient->setSize(this, w, h); -} -status_t Surface::hide() { - return mClient->hide(this); -} -status_t Surface::show(int32_t layer) { - return mClient->show(this, layer); -} -status_t Surface::freeze() { - return mClient->freeze(this); -} -status_t Surface::unfreeze() { - return mClient->unfreeze(this); -} -status_t Surface::setFlags(uint32_t flags, uint32_t mask) { - return mClient->setFlags(this, flags, mask); -} -status_t Surface::setTransparentRegionHint(const Region& transparent) { - return mClient->setTransparentRegionHint(this, transparent); -} -status_t Surface::setAlpha(float alpha) { - return mClient->setAlpha(this, alpha); -} -status_t Surface::setMatrix(float dsdx, float dtdx, float dsdy, float dtdy) { - return mClient->setMatrix(this, dsdx, dtdx, dsdy, dtdy); -} -status_t Surface::setFreezeTint(uint32_t tint) { - return mClient->setFreezeTint(this, tint); -} - Region Surface::dirtyRegion() const { return mDirtyRegion; } @@ -593,5 +750,45 @@ status_t Surface::getBufferLocked(int index) return err; } + + +status_t Surface::setLayer(int32_t layer) { + return mSurfaceControl->setLayer(layer); +} +status_t Surface::setPosition(int32_t x, int32_t y) { + return mSurfaceControl->setPosition(x, y); +} +status_t Surface::setSize(uint32_t w, uint32_t h) { + return mSurfaceControl->setSize(w, h); +} +status_t Surface::hide() { + return mSurfaceControl->hide(); +} +status_t Surface::show(int32_t layer) { + return mSurfaceControl->show(layer); +} +status_t Surface::freeze() { + return mSurfaceControl->freeze(); +} +status_t Surface::unfreeze() { + return mSurfaceControl->unfreeze(); +} +status_t Surface::setFlags(uint32_t flags, uint32_t mask) { + return mSurfaceControl->setFlags(flags, mask); +} +status_t Surface::setTransparentRegionHint(const Region& transparent) { + return mSurfaceControl->setTransparentRegionHint(transparent); +} +status_t Surface::setAlpha(float alpha) { + return mSurfaceControl->setAlpha(alpha); +} +status_t Surface::setMatrix(float dsdx, float dtdx, float dsdy, float dtdy) { + return mSurfaceControl->setMatrix(dsdx, dtdx, dsdy, dtdy); +} +status_t Surface::setFreezeTint(uint32_t tint) { + return mSurfaceControl->setFreezeTint(tint); +} + + }; // namespace android diff --git a/libs/ui/SurfaceComposerClient.cpp b/libs/ui/SurfaceComposerClient.cpp index e1b13c7b8eed..4ccd3965c35f 100644 --- a/libs/ui/SurfaceComposerClient.cpp +++ b/libs/ui/SurfaceComposerClient.cpp @@ -616,14 +616,8 @@ status_t SurfaceComposerClient::closeTransaction() return NO_ERROR; } -layer_state_t* SurfaceComposerClient::_get_state_l(const sp& surface) +layer_state_t* SurfaceComposerClient::_get_state_l(SurfaceID index) { - SurfaceID index = surface->ID(); - per_client_cblk_t* const cblk = mControl; - status_t err = surface->validate(cblk); - if (err != NO_ERROR) - return 0; - // API usage error, do nothing. if (mTransactionOpen<=0) { LOGE("Not in transaction (client=%p, SurfaceID=%d, mTransactionOpen=%d", @@ -642,11 +636,11 @@ layer_state_t* SurfaceComposerClient::_get_state_l(const sp& surface) return mStates.editArray() + i; } -layer_state_t* SurfaceComposerClient::_lockLayerState(const sp& surface) +layer_state_t* SurfaceComposerClient::_lockLayerState(SurfaceID id) { layer_state_t* s; mLock.lock(); - s = _get_state_l(surface); + s = _get_state_l(id); if (!s) mLock.unlock(); return s; } @@ -656,9 +650,9 @@ void SurfaceComposerClient::_unlockLayerState() mLock.unlock(); } -status_t SurfaceComposerClient::setPosition(Surface* surface, int32_t x, int32_t y) +status_t SurfaceComposerClient::setPosition(SurfaceID id, int32_t x, int32_t y) { - layer_state_t* s = _lockLayerState(surface); + layer_state_t* s = _lockLayerState(id); if (!s) return BAD_INDEX; s->what |= ISurfaceComposer::ePositionChanged; s->x = x; @@ -667,9 +661,9 @@ status_t SurfaceComposerClient::setPosition(Surface* surface, int32_t x, int32_t return NO_ERROR; } -status_t SurfaceComposerClient::setSize(Surface* surface, uint32_t w, uint32_t h) +status_t SurfaceComposerClient::setSize(SurfaceID id, uint32_t w, uint32_t h) { - layer_state_t* s = _lockLayerState(surface); + layer_state_t* s = _lockLayerState(id); if (!s) return BAD_INDEX; s->what |= ISurfaceComposer::eSizeChanged; s->w = w; @@ -678,9 +672,9 @@ status_t SurfaceComposerClient::setSize(Surface* surface, uint32_t w, uint32_t h return NO_ERROR; } -status_t SurfaceComposerClient::setLayer(Surface* surface, int32_t z) +status_t SurfaceComposerClient::setLayer(SurfaceID id, int32_t z) { - layer_state_t* s = _lockLayerState(surface); + layer_state_t* s = _lockLayerState(id); if (!s) return BAD_INDEX; s->what |= ISurfaceComposer::eLayerChanged; s->z = z; @@ -688,32 +682,32 @@ status_t SurfaceComposerClient::setLayer(Surface* surface, int32_t z) return NO_ERROR; } -status_t SurfaceComposerClient::hide(Surface* surface) +status_t SurfaceComposerClient::hide(SurfaceID id) { - return setFlags(surface, ISurfaceComposer::eLayerHidden, + return setFlags(id, ISurfaceComposer::eLayerHidden, ISurfaceComposer::eLayerHidden); } -status_t SurfaceComposerClient::show(Surface* surface, int32_t) +status_t SurfaceComposerClient::show(SurfaceID id, int32_t) { - return setFlags(surface, 0, ISurfaceComposer::eLayerHidden); + return setFlags(id, 0, ISurfaceComposer::eLayerHidden); } -status_t SurfaceComposerClient::freeze(Surface* surface) +status_t SurfaceComposerClient::freeze(SurfaceID id) { - return setFlags(surface, ISurfaceComposer::eLayerFrozen, + return setFlags(id, ISurfaceComposer::eLayerFrozen, ISurfaceComposer::eLayerFrozen); } -status_t SurfaceComposerClient::unfreeze(Surface* surface) +status_t SurfaceComposerClient::unfreeze(SurfaceID id) { - return setFlags(surface, 0, ISurfaceComposer::eLayerFrozen); + return setFlags(id, 0, ISurfaceComposer::eLayerFrozen); } -status_t SurfaceComposerClient::setFlags(Surface* surface, +status_t SurfaceComposerClient::setFlags(SurfaceID id, uint32_t flags, uint32_t mask) { - layer_state_t* s = _lockLayerState(surface); + layer_state_t* s = _lockLayerState(id); if (!s) return BAD_INDEX; s->what |= ISurfaceComposer::eVisibilityChanged; s->flags &= ~mask; @@ -724,9 +718,9 @@ status_t SurfaceComposerClient::setFlags(Surface* surface, } status_t SurfaceComposerClient::setTransparentRegionHint( - Surface* surface, const Region& transparentRegion) + SurfaceID id, const Region& transparentRegion) { - layer_state_t* s = _lockLayerState(surface); + layer_state_t* s = _lockLayerState(id); if (!s) return BAD_INDEX; s->what |= ISurfaceComposer::eTransparentRegionChanged; s->transparentRegion = transparentRegion; @@ -734,9 +728,9 @@ status_t SurfaceComposerClient::setTransparentRegionHint( return NO_ERROR; } -status_t SurfaceComposerClient::setAlpha(Surface* surface, float alpha) +status_t SurfaceComposerClient::setAlpha(SurfaceID id, float alpha) { - layer_state_t* s = _lockLayerState(surface); + layer_state_t* s = _lockLayerState(id); if (!s) return BAD_INDEX; s->what |= ISurfaceComposer::eAlphaChanged; s->alpha = alpha; @@ -745,11 +739,11 @@ status_t SurfaceComposerClient::setAlpha(Surface* surface, float alpha) } status_t SurfaceComposerClient::setMatrix( - Surface* surface, + SurfaceID id, float dsdx, float dtdx, float dsdy, float dtdy ) { - layer_state_t* s = _lockLayerState(surface); + layer_state_t* s = _lockLayerState(id); if (!s) return BAD_INDEX; s->what |= ISurfaceComposer::eMatrixChanged; layer_state_t::matrix22_t matrix; @@ -762,9 +756,9 @@ status_t SurfaceComposerClient::setMatrix( return NO_ERROR; } -status_t SurfaceComposerClient::setFreezeTint(Surface* surface, uint32_t tint) +status_t SurfaceComposerClient::setFreezeTint(SurfaceID id, uint32_t tint) { - layer_state_t* s = _lockLayerState(surface); + layer_state_t* s = _lockLayerState(id); if (!s) return BAD_INDEX; s->what |= ISurfaceComposer::eFreezeTintChanged; s->tint = tint; -- cgit v1.2.3-59-g8ed1b From 17f638b39f2e8b610ecfa1290e5bc42ab7700c98 Mon Sep 17 00:00:00 2001 From: Mathias Agopian Date: Thu, 16 Apr 2009 20:04:08 -0700 Subject: more splitting of Surface/SurfaceControl. Surface.java is now implemented in terms of Surface and SurfaceControl. The WindowManager side of Surface.java holds a SurfaceControl, while the client-side holds a Surface. When the client is in the system process, Surface.java holds both (which is a problem we'll try to fix later). --- core/java/android/view/Surface.java | 4 +- core/jni/android_view_Surface.cpp | 210 ++++++++++++++----------- include/ui/Surface.h | 95 ++++++------ include/ui/SurfaceComposerClient.h | 2 +- libs/surfaceflinger/Android.mk | 1 - libs/surfaceflinger/BootAnimation.cpp | 11 +- libs/surfaceflinger/BootAnimation.h | 1 + libs/surfaceflinger/CPUGauge.cpp | 169 --------------------- libs/surfaceflinger/CPUGauge.h | 74 --------- libs/surfaceflinger/SurfaceFlinger.cpp | 38 +---- libs/surfaceflinger/SurfaceFlinger.h | 7 - libs/ui/Surface.cpp | 269 +++++++++++---------------------- libs/ui/SurfaceComposerClient.cpp | 6 +- 13 files changed, 271 insertions(+), 616 deletions(-) delete mode 100644 libs/surfaceflinger/CPUGauge.cpp delete mode 100644 libs/surfaceflinger/CPUGauge.h (limited to 'libs/ui/SurfaceComposerClient.cpp') diff --git a/core/java/android/view/Surface.java b/core/java/android/view/Surface.java index f82cedce4c08..a87c622ed484 100644 --- a/core/java/android/view/Surface.java +++ b/core/java/android/view/Surface.java @@ -127,6 +127,8 @@ public class Surface implements Parcelable { @SuppressWarnings("unused") private int mSurface; @SuppressWarnings("unused") + private int mSurfaceControl; + @SuppressWarnings("unused") private int mSaveCount; @SuppressWarnings("unused") private Canvas mCanvas; @@ -270,7 +272,7 @@ public class Surface implements Parcelable { @Override public String toString() { - return "Surface(native-token=" + mSurface + ")"; + return "Surface(native-token=" + mSurfaceControl + ")"; } private Surface(Parcel source) throws OutOfResourcesException { diff --git a/core/jni/android_view_Surface.cpp b/core/jni/android_view_Surface.cpp index 5b675e53defc..c2eb5e83fda1 100644 --- a/core/jni/android_view_Surface.cpp +++ b/core/jni/android_view_Surface.cpp @@ -45,6 +45,7 @@ struct sso_t { static sso_t sso; struct so_t { + jfieldID surfaceControl; jfieldID surface; jfieldID saveCount; jfieldID canvas; @@ -121,6 +122,27 @@ static void SurfaceSession_kill(JNIEnv* env, jobject clazz) // ---------------------------------------------------------------------------- +static sp getSurfaceControl(JNIEnv* env, jobject clazz) +{ + SurfaceControl* const p = + (SurfaceControl*)env->GetIntField(clazz, so.surfaceControl); + return sp(p); +} + +static void setSurfaceControl(JNIEnv* env, jobject clazz, + const sp& surface) +{ + SurfaceControl* const p = + (SurfaceControl*)env->GetIntField(clazz, so.surfaceControl); + if (surface.get()) { + surface->incStrong(clazz); + } + if (p) { + p->decStrong(clazz); + } + env->SetIntField(clazz, so.surfaceControl, (int)surface.get()); +} + static sp getSurface(JNIEnv* env, jobject clazz) { Surface* const p = (Surface*)env->GetIntField(clazz, so.surface); @@ -153,12 +175,12 @@ static void Surface_init( SurfaceComposerClient* client = (SurfaceComposerClient*)env->GetIntField(session, sso.client); - sp surface(client->createSurface(pid, dpy, w, h, format, flags)); + sp surface(client->createSurface(pid, dpy, w, h, format, flags)); if (surface == 0) { doThrow(env, OutOfResourcesException); return; } - setSurface(env, clazz, surface); + setSurfaceControl(env, clazz, surface); } static void Surface_initParcel(JNIEnv* env, jobject clazz, jobject argParcel) @@ -168,27 +190,33 @@ static void Surface_initParcel(JNIEnv* env, jobject clazz, jobject argParcel) doThrow(env, "java/lang/NullPointerException", NULL); return; } - const sp& rhs = Surface::readFromParcel(parcel); + sp rhs = new Surface(*parcel); setSurface(env, clazz, rhs); } static void Surface_clear(JNIEnv* env, jobject clazz, uintptr_t *ostack) { - const sp& surface = getSurface(env, clazz); - if (Surface::isValid(surface)) { + const sp& surface(getSurfaceControl(env, clazz)); + if (SurfaceControl::isValid(surface)) { surface->clear(); } + setSurfaceControl(env, clazz, 0); setSurface(env, clazz, 0); } static void Surface_release(JNIEnv* env, jobject clazz, uintptr_t *ostack) { + setSurfaceControl(env, clazz, 0); setSurface(env, clazz, 0); } static jboolean Surface_isValid(JNIEnv* env, jobject clazz) { - const sp& surface = getSurface(env, clazz); + const sp& surfaceControl(getSurfaceControl(env, clazz)); + if (surfaceControl != 0) { + return SurfaceControl::isValid(surfaceControl) ? JNI_TRUE : JNI_FALSE; + } + const sp& surface(getSurface(env, clazz)); return Surface::isValid(surface) ? JNI_TRUE : JNI_FALSE; } @@ -209,7 +237,7 @@ static inline SkBitmap::Config convertPixelFormat(PixelFormat format) static jobject Surface_lockCanvas(JNIEnv* env, jobject clazz, jobject dirtyRect) { - const sp& surface = getSurface(env, clazz); + const sp& surface(getSurface(env, clazz)); if (!Surface::isValid(surface)) return 0; @@ -278,7 +306,7 @@ static void Surface_unlockCanvasAndPost( return; } - const sp& surface = getSurface(env, clazz); + const sp& surface(getSurface(env, clazz)); if (!Surface::isValid(surface)) return; @@ -345,138 +373,128 @@ static void Surface_unfreezeDisplay( static void Surface_setLayer( JNIEnv* env, jobject clazz, jint zorder) { - const sp& surface = getSurface(env, clazz); - if (Surface::isValid(surface)) { - if (surface->setLayer(zorder) < 0) { - doThrow(env, "java/lang/IllegalArgumentException", NULL); - } - } + const sp& surface(getSurfaceControl(env, clazz)); + if (surface == 0) return; + status_t err = surface->setLayer(zorder); + if (err<0 && err!=NO_INIT) + doThrow(env, "java/lang/IllegalArgumentException", NULL); } static void Surface_setPosition( JNIEnv* env, jobject clazz, jint x, jint y) { - const sp& surface = getSurface(env, clazz); - if (Surface::isValid(surface)) { - if (surface->setPosition(x, y) < 0) { - doThrow(env, "java/lang/IllegalArgumentException", NULL); - } - } + const sp& surface(getSurfaceControl(env, clazz)); + if (surface == 0) return; + status_t err = surface->setPosition(x, y); + if (err<0 && err!=NO_INIT) + doThrow(env, "java/lang/IllegalArgumentException", NULL); } static void Surface_setSize( JNIEnv* env, jobject clazz, jint w, jint h) { - const sp& surface = getSurface(env, clazz); - if (Surface::isValid(surface)) { - if (surface->setSize(w, h) < 0) { - doThrow(env, "java/lang/IllegalArgumentException", NULL); - } - } + const sp& surface(getSurfaceControl(env, clazz)); + if (surface == 0) return; + status_t err = surface->setSize(w, h); + if (err<0 && err!=NO_INIT) + doThrow(env, "java/lang/IllegalArgumentException", NULL); } static void Surface_hide( JNIEnv* env, jobject clazz) { - const sp& surface = getSurface(env, clazz); - if (Surface::isValid(surface)) { - if (surface->hide() < 0) { - doThrow(env, "java/lang/IllegalArgumentException", NULL); - } - } + const sp& surface(getSurfaceControl(env, clazz)); + if (surface == 0) return; + status_t err = surface->hide(); + if (err<0 && err!=NO_INIT) + doThrow(env, "java/lang/IllegalArgumentException", NULL); } static void Surface_show( JNIEnv* env, jobject clazz) { - const sp& surface = getSurface(env, clazz); - if (Surface::isValid(surface)) { - if (surface->show() < 0) { - doThrow(env, "java/lang/IllegalArgumentException", NULL); - } - } + const sp& surface(getSurfaceControl(env, clazz)); + if (surface == 0) return; + status_t err = surface->show(); + if (err<0 && err!=NO_INIT) + doThrow(env, "java/lang/IllegalArgumentException", NULL); } static void Surface_freeze( JNIEnv* env, jobject clazz) { - const sp& surface = getSurface(env, clazz); - if (Surface::isValid(surface)) { - if (surface->freeze() < 0) { - doThrow(env, "java/lang/IllegalArgumentException", NULL); - } - } + const sp& surface(getSurfaceControl(env, clazz)); + if (surface == 0) return; + status_t err = surface->freeze(); + if (err<0 && err!=NO_INIT) + doThrow(env, "java/lang/IllegalArgumentException", NULL); } static void Surface_unfreeze( JNIEnv* env, jobject clazz) { - const sp& surface = getSurface(env, clazz); - if (Surface::isValid(surface)) { - if (surface->unfreeze() < 0) { - doThrow(env, "java/lang/IllegalArgumentException", NULL); - } - } + const sp& surface(getSurfaceControl(env, clazz)); + if (surface == 0) return; + status_t err = surface->unfreeze(); + if (err<0 && err!=NO_INIT) + doThrow(env, "java/lang/IllegalArgumentException", NULL); } static void Surface_setFlags( JNIEnv* env, jobject clazz, jint flags, jint mask) { - const sp& surface = getSurface(env, clazz); - if (Surface::isValid(surface)) { - if (surface->setFlags(flags, mask) < 0) { - doThrow(env, "java/lang/IllegalArgumentException", NULL); - } - } + const sp& surface(getSurfaceControl(env, clazz)); + if (surface == 0) return; + status_t err = surface->setFlags(flags, mask); + if (err<0 && err!=NO_INIT) + doThrow(env, "java/lang/IllegalArgumentException", NULL); } static void Surface_setTransparentRegion( JNIEnv* env, jobject clazz, jobject argRegion) { - const sp& surface = getSurface(env, clazz); - if (Surface::isValid(surface)) { - SkRegion* nativeRegion = (SkRegion*)env->GetIntField(argRegion, no.native_region); - if (surface->setTransparentRegionHint(Region(*nativeRegion)) < 0) { - doThrow(env, "java/lang/IllegalArgumentException", NULL); - } - } + const sp& surface(getSurfaceControl(env, clazz)); + if (surface == 0) return; + SkRegion* nativeRegion = (SkRegion*)env->GetIntField(argRegion, no.native_region); + status_t err = surface->setTransparentRegionHint(Region(*nativeRegion)); + if (err<0 && err!=NO_INIT) + doThrow(env, "java/lang/IllegalArgumentException", NULL); } static void Surface_setAlpha( JNIEnv* env, jobject clazz, jfloat alpha) { - const sp& surface = getSurface(env, clazz); - if (Surface::isValid(surface)) { - if (surface->setAlpha(alpha) < 0) { - doThrow(env, "java/lang/IllegalArgumentException", NULL); - } - } + const sp& surface(getSurfaceControl(env, clazz)); + if (surface == 0) return; + status_t err = surface->setAlpha(alpha); + if (err<0 && err!=NO_INIT) + doThrow(env, "java/lang/IllegalArgumentException", NULL); } static void Surface_setMatrix( JNIEnv* env, jobject clazz, jfloat dsdx, jfloat dtdx, jfloat dsdy, jfloat dtdy) { - const sp& surface = getSurface(env, clazz); - if (Surface::isValid(surface)) { - if (surface->setMatrix(dsdx, dtdx, dsdy, dtdy) < 0) { - doThrow(env, "java/lang/IllegalArgumentException", NULL); - } - } + const sp& surface(getSurfaceControl(env, clazz)); + if (surface == 0) return; + status_t err = surface->setMatrix(dsdx, dtdx, dsdy, dtdy); + if (err<0 && err!=NO_INIT) + doThrow(env, "java/lang/IllegalArgumentException", NULL); } static void Surface_setFreezeTint( JNIEnv* env, jobject clazz, jint tint) { - const sp& surface = getSurface(env, clazz); - if (Surface::isValid(surface)) { - if (surface->setFreezeTint(tint) < 0) { - doThrow(env, "java/lang/IllegalArgumentException", NULL); - } - } + const sp& surface(getSurfaceControl(env, clazz)); + if (surface == 0) return; + status_t err = surface->setFreezeTint(tint); + if (err<0 && err!=NO_INIT) + doThrow(env, "java/lang/IllegalArgumentException", NULL); } +// ---------------------------------------------------------------------------- + static void Surface_copyFrom( JNIEnv* env, jobject clazz, jobject other) { @@ -488,16 +506,23 @@ static void Surface_copyFrom( return; } - const sp& surface = getSurface(env, clazz); - const sp& rhs = getSurface(env, other); - if (!Surface::isSameSurface(surface, rhs)) { + /* + * This is used by the WindowManagerService just after constructing + * a Surface and is necessary for returning the Surface reference to + * the caller. At this point, we should only have a SurfaceControl. + * + */ + + const sp& surface = getSurfaceControl(env, clazz); + const sp& rhs = getSurfaceControl(env, other); + if (!SurfaceControl::isSameSurface(surface, rhs)) { // we reassign the surface only if it's a different one // otherwise we would loose our client-side state. - setSurface(env, clazz, rhs); + setSurfaceControl(env, clazz, rhs); + setSurface(env, clazz, rhs->getSurface()); } } - static void Surface_readFromParcel( JNIEnv* env, jobject clazz, jobject argParcel) { @@ -507,9 +532,9 @@ static void Surface_readFromParcel( return; } - const sp& surface = getSurface(env, clazz); - const sp& rhs = Surface::readFromParcel(parcel); - if (!Surface::isSameSurface(surface, rhs)) { + const sp& control(getSurface(env, clazz)); + sp rhs = new Surface(*parcel); + if (!Surface::isSameSurface(control, rhs)) { // we reassign the surface only if it's a different one // otherwise we would loose our client-side state. setSurface(env, clazz, rhs); @@ -527,8 +552,8 @@ static void Surface_writeToParcel( return; } - const sp& surface = getSurface(env, clazz); - Surface::writeToParcel(surface, parcel); + const sp& control(getSurfaceControl(env, clazz)); + SurfaceControl::writeSurfaceToParcel(control, parcel); } // ---------------------------------------------------------------------------- @@ -579,7 +604,8 @@ static JNINativeMethod gSurfaceMethods[] = { void nativeClassInit(JNIEnv* env, jclass clazz) { - so.surface = env->GetFieldID(clazz, "mSurface", "I"); + so.surface = env->GetFieldID(clazz, "mSurface", "I"); + so.surfaceControl = env->GetFieldID(clazz, "mSurfaceControl", "I"); so.saveCount = env->GetFieldID(clazz, "mSaveCount", "I"); so.canvas = env->GetFieldID(clazz, "mCanvas", "Landroid/graphics/Canvas;"); diff --git a/include/ui/Surface.h b/include/ui/Surface.h index 87a11c2824f2..d1ead1d22ad7 100644 --- a/include/ui/Surface.h +++ b/include/ui/Surface.h @@ -75,13 +75,19 @@ private: }; // --------------------------------------------------------------------------- +class Surface; class SurfaceControl : public RefBase { public: static bool isValid(const sp& surface) { - return (surface != 0) && surface->mToken>=0 && surface->mClient!=0; + return (surface != 0) && surface->isValid(); } + bool isValid() { + return mToken>=0 && mClient!=0; + } + static bool isSameSurface( + const sp& lhs, const sp& rhs); SurfaceID ID() const { return mToken; } uint32_t getFlags() const { return mFlags; } @@ -90,10 +96,6 @@ public: // release surface data from java void clear(); - static sp readFromParcel(Parcel* parcel); - static status_t writeToParcel(const sp& surface, Parcel* parcel); - static bool isSameSurface(const sp& lhs, const sp& rhs); - status_t setLayer(int32_t layer); status_t setPosition(int32_t x, int32_t y); status_t setSize(uint32_t w, uint32_t h); @@ -107,7 +109,17 @@ public: status_t setMatrix(float dsdx, float dtdx, float dsdy, float dtdy); status_t setFreezeTint(uint32_t tint); + static status_t writeSurfaceToParcel( + const sp& control, Parcel* parcel); + + sp getSurface() const; + private: + // can't be copied + SurfaceControl& operator = (SurfaceControl& rhs); + SurfaceControl(const SurfaceControl& rhs); + + friend class SurfaceComposerClient; // camera and camcorder need access to the ISurface binder interface for preview @@ -115,22 +127,22 @@ private: friend class MediaRecorder; // mediaplayer needs access to ISurface for display friend class MediaPlayer; + // for testing friend class Test; const sp& getISurface() const { return mSurface; } - // can't be copied - SurfaceControl& operator = (SurfaceControl& rhs); - SurfaceControl(const SurfaceControl& rhs); friend class Surface; - SurfaceControl(const sp& client, + + SurfaceControl( + const sp& client, const sp& surface, const ISurfaceFlingerClient::surface_data_t& data, uint32_t w, uint32_t h, PixelFormat format, uint32_t flags, bool owner = true); ~SurfaceControl(); - + status_t validate(per_client_cblk_t const* cblk) const; void destroy(); @@ -142,6 +154,8 @@ private: uint32_t mFlags; const bool mOwner; mutable Mutex mLock; + + mutable sp mSurfaceData; }; // --------------------------------------------------------------------------- @@ -160,45 +174,40 @@ public: uint32_t reserved[2]; }; + Surface(const Parcel& data); + static bool isValid(const sp& surface) { - return (surface != 0) && surface->mToken>=0 && surface->mClient!=0; + return (surface != 0) && surface->isValid(); } - + bool isValid() { + return mToken>=0 && mClient!=0; + } + static bool isSameSurface( + const sp& lhs, const sp& rhs); SurfaceID ID() const { return mToken; } + uint32_t getFlags() const { return mFlags; } + uint32_t getIdentity() const { return mIdentity; } - // release surface data from java - void clear(); status_t lock(SurfaceInfo* info, bool blocking = true); status_t lock(SurfaceInfo* info, Region* dirty, bool blocking = true); status_t unlockAndPost(); - - uint32_t getFlags() const { return mFlags; } // setSwapRectangle() is mainly used by EGL void setSwapRectangle(const Rect& r); const Rect& swapRectangle() const; - static sp readFromParcel(Parcel* parcel); - static status_t writeToParcel(const sp& surface, Parcel* parcel); - static bool isSameSurface(const sp& lhs, const sp& rhs); - - status_t setLayer(int32_t layer); - status_t setPosition(int32_t x, int32_t y); - status_t setSize(uint32_t w, uint32_t h); - status_t hide(); - status_t show(int32_t layer = -1); - status_t freeze(); - status_t unfreeze(); - status_t setFlags(uint32_t flags, uint32_t mask); - status_t setTransparentRegionHint(const Region& transparent); - status_t setAlpha(float alpha=1.0f); - status_t setMatrix(float dsdx, float dtdx, float dsdy, float dtdy); - status_t setFreezeTint(uint32_t tint); - - uint32_t getIdentity() const { return mIdentity; } private: + // can't be copied + Surface& operator = (Surface& rhs); + Surface(const Surface& rhs); + + Surface(const sp& control); + void init(); + ~Surface(); + friend class SurfaceComposerClient; + friend class SurfaceControl; // camera and camcorder need access to the ISurface binder interface for preview friend class Camera; @@ -210,22 +219,8 @@ private: status_t getBufferLocked(int index); - // can't be copied - Surface& operator = (Surface& rhs); - Surface(const Surface& rhs); - - Surface(const sp& client, - const sp& surface, - const ISurfaceFlingerClient::surface_data_t& data, - uint32_t w, uint32_t h, PixelFormat format, uint32_t flags, - bool owner = true); - - Surface(Surface const* rhs); - - ~Surface(); - void destroy(); - + Region dirtyRegion() const; void setDirtyRegion(const Region& region) const; @@ -262,8 +257,6 @@ private: mutable Rect mSwapRectangle; mutable uint8_t mBackbufferIndex; mutable Mutex mSurfaceLock; - - sp mSurfaceControl; }; }; // namespace android diff --git a/include/ui/SurfaceComposerClient.h b/include/ui/SurfaceComposerClient.h index a175a18a0dc3..2a35256d2889 100644 --- a/include/ui/SurfaceComposerClient.h +++ b/include/ui/SurfaceComposerClient.h @@ -62,7 +62,7 @@ public: // surface creation / destruction //! Create a surface - sp createSurface( + sp createSurface( int pid, //!< pid of the process the surfacec is for DisplayID display, //!< Display to create this surface on uint32_t w, //!< width in pixel diff --git a/libs/surfaceflinger/Android.mk b/libs/surfaceflinger/Android.mk index ebd588b3e6aa..b8077c708cb8 100644 --- a/libs/surfaceflinger/Android.mk +++ b/libs/surfaceflinger/Android.mk @@ -8,7 +8,6 @@ LOCAL_SRC_FILES:= \ BootAnimation.cpp \ BlurFilter.cpp.arm \ BufferAllocator.cpp \ - CPUGauge.cpp \ Layer.cpp \ LayerBase.cpp \ LayerBuffer.cpp \ diff --git a/libs/surfaceflinger/BootAnimation.cpp b/libs/surfaceflinger/BootAnimation.cpp index 4aa8c2c346a9..519b112285ee 100644 --- a/libs/surfaceflinger/BootAnimation.cpp +++ b/libs/surfaceflinger/BootAnimation.cpp @@ -128,12 +128,14 @@ status_t BootAnimation::readyToRun() { return -1; // create the native surface - sp s = session()->createSurface(getpid(), 0, dinfo.w, dinfo.h, - PIXEL_FORMAT_RGB_565); + sp control = session()->createSurface( + getpid(), 0, dinfo.w, dinfo.h, PIXEL_FORMAT_RGB_565); session()->openTransaction(); - s->setLayer(0x40000000); + control->setLayer(0x40000000); session()->closeTransaction(); + sp s = control->getSurface(); + // initialize opengl and egl const EGLint attribs[] = { EGL_RED_SIZE, 5, EGL_GREEN_SIZE, 6, EGL_BLUE_SIZE, 5, EGL_DEPTH_SIZE, 0, EGL_NONE }; @@ -156,6 +158,7 @@ status_t BootAnimation::readyToRun() { mSurface = surface; mWidth = w; mHeight = h; + mFlingerSurfaceControl = control; mFlingerSurface = s; // initialize GL @@ -176,7 +179,7 @@ bool BootAnimation::threadLoop() { eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); eglDestroyContext(mDisplay, mContext); eglDestroySurface(mDisplay, mSurface); - mFlingerSurface.clear(); + mFlingerSurfaceControl.clear(); return r; } diff --git a/libs/surfaceflinger/BootAnimation.h b/libs/surfaceflinger/BootAnimation.h index 84846238bc5c..0e354344f784 100644 --- a/libs/surfaceflinger/BootAnimation.h +++ b/libs/surfaceflinger/BootAnimation.h @@ -71,6 +71,7 @@ private: EGLDisplay mDisplay; EGLDisplay mContext; EGLDisplay mSurface; + sp mFlingerSurfaceControl; sp mFlingerSurface; Barrier mBarrier; }; diff --git a/libs/surfaceflinger/CPUGauge.cpp b/libs/surfaceflinger/CPUGauge.cpp deleted file mode 100644 index 91dd2362583c..000000000000 --- a/libs/surfaceflinger/CPUGauge.cpp +++ /dev/null @@ -1,169 +0,0 @@ -/* - * Copyright (C) 2007 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include -#include -#include - -#include -#include -#include - -#include -#include -#include -#include -#include -#include - -#include - -#include "CPUGauge.h" - -namespace android { - -CPUGauge::CPUGauge( const sp& composer, - nsecs_t interval, - int clock, - int refclock) - : Thread(false), - mInterval(interval), mClock(clock), mRefClock(refclock), - mReferenceTime(0), - mReferenceWorkingTime(0), mCpuUsage(0), - mRefIdleTime(0), mIdleTime(0) -{ - mFd = fopen("/proc/stat", "r"); - setvbuf(mFd, NULL, _IONBF, 0); - - mSession = SurfaceComposerClient::clientForConnection( - composer->createConnection()->asBinder()); -} - -CPUGauge::~CPUGauge() -{ - fclose(mFd); -} - -const sp& CPUGauge::session() const -{ - return mSession; -} - -void CPUGauge::onFirstRef() -{ - run("CPU Gauge"); -} - -status_t CPUGauge::readyToRun() -{ - LOGI("Starting CPU gauge..."); - return NO_ERROR; -} - -bool CPUGauge::threadLoop() -{ - DisplayInfo dinfo; - session()->getDisplayInfo(0, &dinfo); - sp s(session()->createSurface(getpid(), 0, dinfo.w, 4, PIXEL_FORMAT_OPAQUE)); - session()->openTransaction(); - s->setLayer(INT_MAX); - session()->closeTransaction(); - - static const GGLfixed colors[4][4] = { - { 0x00000, 0x10000, 0x00000, 0x10000 }, - { 0x10000, 0x10000, 0x00000, 0x10000 }, - { 0x10000, 0x00000, 0x00000, 0x10000 }, - { 0x00000, 0x00000, 0x00000, 0x10000 }, - }; - - GGLContext* gl; - gglInit(&gl); - gl->activeTexture(gl, 0); - gl->disable(gl, GGL_TEXTURE_2D); - gl->disable(gl, GGL_BLEND); - - const int w = dinfo.w; - - while(!exitPending()) - { - mLock.lock(); - const float cpuUsage = this->cpuUsage(); - const float totalCpuUsage = 1.0f - idle(); - mLock.unlock(); - - Surface::SurfaceInfo info; - s->lock(&info); - GGLSurface fb; - fb.version = sizeof(GGLSurface); - fb.width = info.w; - fb.height = info.h; - fb.stride = info.s; - fb.format = info.format; - fb.data = (GGLubyte*)info.bits; - - gl->colorBuffer(gl, &fb); - gl->color4xv(gl, colors[3]); - gl->recti(gl, 0, 0, w, 4); - gl->color4xv(gl, colors[2]); // red - gl->recti(gl, 0, 0, int(totalCpuUsage*w), 2); - gl->color4xv(gl, colors[0]); // green - gl->recti(gl, 0, 2, int(cpuUsage*w), 4); - - s->unlockAndPost(); - - usleep(ns2us(mInterval)); - } - - gglUninit(gl); - return false; -} - -void CPUGauge::sample() -{ - if (mLock.tryLock() == NO_ERROR) { - const nsecs_t now = systemTime(mRefClock); - const nsecs_t referenceTime = now-mReferenceTime; - if (referenceTime >= mInterval) { - const float reftime = 1.0f / referenceTime; - const nsecs_t nowWorkingTime = systemTime(mClock); - - char buf[256]; - fgets(buf, 256, mFd); - rewind(mFd); - char *str = buf+5; - char const * const usermode = strsep(&str, " "); (void)usermode; - char const * const usernice = strsep(&str, " "); (void)usernice; - char const * const systemmode = strsep(&str, " ");(void)systemmode; - char const * const idle = strsep(&str, " "); - const nsecs_t nowIdleTime = atoi(idle) * 10000000LL; - mIdleTime = float(nowIdleTime - mRefIdleTime) * reftime; - mRefIdleTime = nowIdleTime; - - const nsecs_t workingTime = nowWorkingTime - mReferenceWorkingTime; - const float newCpuUsage = float(workingTime) * reftime; - if (mCpuUsage != newCpuUsage) { - mCpuUsage = newCpuUsage; - mReferenceWorkingTime = nowWorkingTime; - mReferenceTime = now; - } - } - mLock.unlock(); - } -} - - -}; // namespace android diff --git a/libs/surfaceflinger/CPUGauge.h b/libs/surfaceflinger/CPUGauge.h deleted file mode 100644 index 5bb53c07ff8e..000000000000 --- a/libs/surfaceflinger/CPUGauge.h +++ /dev/null @@ -1,74 +0,0 @@ -/* - * Copyright (C) 2007 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef ANDROID_CPUGAUGE_H -#define ANDROID_CPUGAUGE_H - -#include -#include -#include - -#include -#include - -#include - -#include - -namespace android { - -class CPUGauge : public Thread -{ -public: - CPUGauge( const sp& composer, - nsecs_t interval=s2ns(1), - int clock=SYSTEM_TIME_THREAD, - int refclock=SYSTEM_TIME_MONOTONIC); - - ~CPUGauge(); - - const sp& session() const; - - void sample(); - - inline float cpuUsage() const { return mCpuUsage; } - inline float idle() const { return mIdleTime; } - -private: - virtual void onFirstRef(); - virtual status_t readyToRun(); - virtual bool threadLoop(); - - Mutex mLock; - - sp mSession; - - const nsecs_t mInterval; - const int mClock; - const int mRefClock; - - nsecs_t mReferenceTime; - nsecs_t mReferenceWorkingTime; - float mCpuUsage; - nsecs_t mRefIdleTime; - float mIdleTime; - FILE* mFd; -}; - - -}; // namespace android - -#endif // ANDROID_CPUGAUGE_H diff --git a/libs/surfaceflinger/SurfaceFlinger.cpp b/libs/surfaceflinger/SurfaceFlinger.cpp index a5c1e8fb8671..a63a28268b99 100644 --- a/libs/surfaceflinger/SurfaceFlinger.cpp +++ b/libs/surfaceflinger/SurfaceFlinger.cpp @@ -45,7 +45,6 @@ #include "clz.h" #include "BufferAllocator.h" -#include "CPUGauge.h" #include "Layer.h" #include "LayerBlur.h" #include "LayerBuffer.h" @@ -179,7 +178,6 @@ SurfaceFlinger::SurfaceFlinger() mFreezeCount(0), mFreezeDisplayTime(0), mDebugRegion(0), - mDebugCpu(0), mDebugFps(0), mDebugBackground(0), mDebugNoBootAnimation(0), @@ -199,8 +197,6 @@ void SurfaceFlinger::init() char value[PROPERTY_VALUE_MAX]; property_get("debug.sf.showupdates", value, "0"); mDebugRegion = atoi(value); - property_get("debug.sf.showcpu", value, "0"); - mDebugCpu = atoi(value); property_get("debug.sf.showbackground", value, "0"); mDebugBackground = atoi(value); property_get("debug.sf.showfps", value, "0"); @@ -209,7 +205,6 @@ void SurfaceFlinger::init() mDebugNoBootAnimation = atoi(value); LOGI_IF(mDebugRegion, "showupdates enabled"); - LOGI_IF(mDebugCpu, "showcpu enabled"); LOGI_IF(mDebugBackground, "showbackground enabled"); LOGI_IF(mDebugFps, "showfps enabled"); LOGI_IF(mDebugNoBootAnimation, "boot animation disabled"); @@ -413,10 +408,6 @@ status_t SurfaceFlinger::readyToRun() mOrientationAnimation = new OrientationAnimation(this); - // start CPU gauge display - if (mDebugCpu) - mCpuGauge = new CPUGauge(this, ms2ns(500)); - // the boot animation! if (mDebugNoBootAnimation == false) mBootAnimation = new BootAnimation(this); @@ -509,11 +500,6 @@ bool SurfaceFlinger::threadLoop() unlockClients(); executeScheduledBroadcasts(); - // sample the cpu gauge - if (UNLIKELY(mDebugCpu)) { - handleDebugCpu(); - } - postFramebuffer(); } else { // pretend we did the post @@ -905,13 +891,6 @@ void SurfaceFlinger::executeScheduledBroadcasts() mLastScheduledBroadcast = 0; } -void SurfaceFlinger::handleDebugCpu() -{ - Mutex::Autolock _l(mDebugLock); - if (mCpuGauge != 0) - mCpuGauge->sample(); -} - void SurfaceFlinger::debugFlashRegions() { if (UNLIKELY(!mDirtyRegion.isRect())) { @@ -1502,20 +1481,7 @@ status_t SurfaceFlinger::onTransact( } int n; switch (code) { - case 1000: // SHOW_CPU - n = data.readInt32(); - mDebugCpu = n ? 1 : 0; - if (mDebugCpu) { - if (mCpuGauge == 0) { - mCpuGauge = new CPUGauge(this, ms2ns(500)); - } - } else { - if (mCpuGauge != 0) { - mCpuGauge->requestExitAndWait(); - Mutex::Autolock _l(mDebugLock); - mCpuGauge.clear(); - } - } + case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE return NO_ERROR; case 1001: // SHOW_FPS n = data.readInt32(); @@ -1540,7 +1506,7 @@ status_t SurfaceFlinger::onTransact( mFreezeCount = data.readInt32(); return NO_ERROR; case 1010: // interrogate. - reply->writeInt32(mDebugCpu); + reply->writeInt32(0); reply->writeInt32(0); reply->writeInt32(mDebugRegion); reply->writeInt32(mDebugBackground); diff --git a/libs/surfaceflinger/SurfaceFlinger.h b/libs/surfaceflinger/SurfaceFlinger.h index 57c6ca8503a7..cb84542f2087 100644 --- a/libs/surfaceflinger/SurfaceFlinger.h +++ b/libs/surfaceflinger/SurfaceFlinger.h @@ -38,7 +38,6 @@ #include "Barrier.h" #include "BootAnimation.h" -#include "CPUGauge.h" #include "Layer.h" #include "Tokenizer.h" @@ -277,7 +276,6 @@ private: bool lockPageFlip(const LayerVector& currentLayers); void unlockPageFlip(const LayerVector& currentLayers); void handleRepaint(); - void handleDebugCpu(); void scheduleBroadcast(Client* client); void executeScheduledBroadcasts(); void postFramebuffer(); @@ -349,13 +347,8 @@ private: friend class OrientationAnimation; OrientationAnimation* mOrientationAnimation; - // access protected by mDebugLock - mutable Mutex mDebugLock; - sp mCpuGauge; - // don't use a lock for these, we don't care int mDebugRegion; - int mDebugCpu; int mDebugFps; int mDebugBackground; int mDebugNoBootAnimation; diff --git a/libs/ui/Surface.cpp b/libs/ui/Surface.cpp index 63699c7fd7b1..cf1b76cd814d 100644 --- a/libs/ui/Surface.cpp +++ b/libs/ui/Surface.cpp @@ -148,8 +148,8 @@ static void copyBlt(const android_native_buffer_t* dst, // SurfaceControl // ============================================================================ - -SurfaceControl::SurfaceControl(const sp& client, +SurfaceControl::SurfaceControl( + const sp& client, const sp& surface, const ISurfaceFlingerClient::surface_data_t& data, uint32_t w, uint32_t h, PixelFormat format, uint32_t flags, @@ -159,7 +159,6 @@ SurfaceControl::SurfaceControl(const sp& client, mFormat(format), mFlags(flags), mOwner(owner) { } - SurfaceControl::~SurfaceControl() { destroy(); @@ -192,142 +191,99 @@ void SurfaceControl::clear() destroy(); } +bool SurfaceControl::isSameSurface( + const sp& lhs, const sp& rhs) +{ + if (lhs == 0 || rhs == 0) + return false; + return lhs->mSurface->asBinder() == rhs->mSurface->asBinder(); +} + status_t SurfaceControl::setLayer(int32_t layer) { const sp& client(mClient); - if (client == 0) return INVALID_OPERATION; + if (client == 0) return NO_INIT; status_t err = validate(client->mControl); if (err < 0) return err; return client->setLayer(mToken, layer); } status_t SurfaceControl::setPosition(int32_t x, int32_t y) { const sp& client(mClient); - if (client == 0) return INVALID_OPERATION; + if (client == 0) return NO_INIT; status_t err = validate(client->mControl); if (err < 0) return err; return client->setPosition(mToken, x, y); } status_t SurfaceControl::setSize(uint32_t w, uint32_t h) { const sp& client(mClient); - if (client == 0) return INVALID_OPERATION; + if (client == 0) return NO_INIT; status_t err = validate(client->mControl); if (err < 0) return err; return client->setSize(mToken, w, h); } status_t SurfaceControl::hide() { const sp& client(mClient); - if (client == 0) return INVALID_OPERATION; + if (client == 0) return NO_INIT; status_t err = validate(client->mControl); if (err < 0) return err; return client->hide(mToken); } status_t SurfaceControl::show(int32_t layer) { const sp& client(mClient); - if (client == 0) return INVALID_OPERATION; + if (client == 0) return NO_INIT; status_t err = validate(client->mControl); if (err < 0) return err; return client->show(mToken, layer); } status_t SurfaceControl::freeze() { const sp& client(mClient); - if (client == 0) return INVALID_OPERATION; + if (client == 0) return NO_INIT; status_t err = validate(client->mControl); if (err < 0) return err; return client->freeze(mToken); } status_t SurfaceControl::unfreeze() { const sp& client(mClient); - if (client == 0) return INVALID_OPERATION; + if (client == 0) return NO_INIT; status_t err = validate(client->mControl); if (err < 0) return err; return client->unfreeze(mToken); } status_t SurfaceControl::setFlags(uint32_t flags, uint32_t mask) { const sp& client(mClient); - if (client == 0) return INVALID_OPERATION; + if (client == 0) return NO_INIT; status_t err = validate(client->mControl); if (err < 0) return err; return client->setFlags(mToken, flags, mask); } status_t SurfaceControl::setTransparentRegionHint(const Region& transparent) { const sp& client(mClient); - if (client == 0) return INVALID_OPERATION; + if (client == 0) return NO_INIT; status_t err = validate(client->mControl); if (err < 0) return err; return client->setTransparentRegionHint(mToken, transparent); } status_t SurfaceControl::setAlpha(float alpha) { const sp& client(mClient); - if (client == 0) return INVALID_OPERATION; + if (client == 0) return NO_INIT; status_t err = validate(client->mControl); if (err < 0) return err; return client->setAlpha(mToken, alpha); } status_t SurfaceControl::setMatrix(float dsdx, float dtdx, float dsdy, float dtdy) { const sp& client(mClient); - if (client == 0) return INVALID_OPERATION; + if (client == 0) return NO_INIT; status_t err = validate(client->mControl); if (err < 0) return err; return client->setMatrix(mToken, dsdx, dtdx, dsdy, dtdy); } status_t SurfaceControl::setFreezeTint(uint32_t tint) { const sp& client(mClient); - if (client == 0) return INVALID_OPERATION; + if (client == 0) return NO_INIT; status_t err = validate(client->mControl); if (err < 0) return err; return client->setFreezeTint(mToken, tint); } -sp SurfaceControl::readFromParcel(Parcel* parcel) -{ - sp client; - ISurfaceFlingerClient::surface_data_t data; - sp clientBinder= parcel->readStrongBinder(); - sp surface = interface_cast(parcel->readStrongBinder()); - data.token = parcel->readInt32(); - data.identity = parcel->readInt32(); - PixelFormat format = parcel->readInt32(); - uint32_t flags = parcel->readInt32(); - - if (clientBinder != NULL) - client = SurfaceComposerClient::clientForConnection(clientBinder); - - return new SurfaceControl(client, surface, data, 0, 0, format, flags, false); -} - -status_t SurfaceControl::writeToParcel(const sp& surface, Parcel* parcel) -{ - uint32_t flags=0; - uint32_t format=0; - SurfaceID token = -1; - uint32_t identity = 0; - sp client; - sp sur; - if (SurfaceControl::isValid(surface)) { - token = surface->mToken; - identity = surface->mIdentity; - client = surface->mClient; - sur = surface->mSurface; - format = surface->mFormat; - flags = surface->mFlags; - } - parcel->writeStrongBinder(client!=0 ? client->connection() : NULL); - parcel->writeStrongBinder(sur!=0 ? sur->asBinder() : NULL); - parcel->writeInt32(token); - parcel->writeInt32(identity); - parcel->writeInt32(format); - parcel->writeInt32(flags); - return NO_ERROR; -} - -bool SurfaceControl::isSameSurface( - const sp& lhs, const sp& rhs) -{ - if (lhs == 0 || rhs == 0) - return false; - return lhs->mSurface->asBinder() == rhs->mSurface->asBinder(); -} - - status_t SurfaceControl::validate(per_client_cblk_t const* cblk) const { if (mToken<0 || mClient==0) { @@ -353,22 +309,72 @@ status_t SurfaceControl::validate(per_client_cblk_t const* cblk) const return NO_ERROR; } +status_t SurfaceControl::writeSurfaceToParcel( + const sp& control, Parcel* parcel) +{ + uint32_t flags = 0; + uint32_t format = 0; + SurfaceID token = -1; + uint32_t identity = 0; + sp client; + sp sur; + if (SurfaceControl::isValid(control)) { + token = control->mToken; + identity = control->mIdentity; + client = control->mClient; + sur = control->mSurface; + format = control->mFormat; + flags = control->mFlags; + } + parcel->writeStrongBinder(client!=0 ? client->connection() : NULL); + parcel->writeStrongBinder(sur!=0 ? sur->asBinder() : NULL); + parcel->writeInt32(token); + parcel->writeInt32(identity); + parcel->writeInt32(format); + parcel->writeInt32(flags); + return NO_ERROR; +} + +sp SurfaceControl::getSurface() const +{ + Mutex::Autolock _l(mLock); + if (mSurfaceData == 0) { + mSurfaceData = new Surface(const_cast(this)); + } + return mSurfaceData; +} + // ============================================================================ // Surface // ============================================================================ -Surface::Surface(const sp& client, - const sp& surface, - const ISurfaceFlingerClient::surface_data_t& data, - uint32_t w, uint32_t h, PixelFormat format, uint32_t flags, - bool owner) - : mClient(client), mSurface(surface), - mToken(data.token), mIdentity(data.identity), - mFormat(format), mFlags(flags), mOwner(owner) +Surface::Surface(const sp& surface) + : mClient(surface->mClient), mSurface(surface->mSurface), + mToken(surface->mToken), mIdentity(surface->mIdentity), + mFormat(surface->mFormat), mFlags(surface->mFlags), + mOwner(surface->mOwner) { - mSurfaceControl = new SurfaceControl( - client, surface, data, w, h, format, flags, owner); + init(); +} +Surface::Surface(const Parcel& parcel) + : mOwner(false) +{ + sp clientBinder = parcel.readStrongBinder(); + mSurface = interface_cast(parcel.readStrongBinder()); + mToken = parcel.readInt32(); + mIdentity = parcel.readInt32(); + mFormat = parcel.readInt32(); + mFlags = parcel.readInt32(); + + if (clientBinder != NULL) + mClient = SurfaceComposerClient::clientForConnection(clientBinder); + + init(); +} + +void Surface::init() +{ android_native_window_t::connect = connect; android_native_window_t::disconnect = disconnect; android_native_window_t::setSwapInterval = setSwapInterval; @@ -389,6 +395,7 @@ Surface::Surface(const sp& client, const_cast(android_native_window_t::flags) = 0; } + Surface::~Surface() { // this is a client-side operation, the surface is destroyed, unmap @@ -399,13 +406,6 @@ Surface::~Surface() } } - destroy(); -} - -void Surface::destroy() -{ - mSurfaceControl->destroy(); - // clear all references and trigger an IPC now, to make sure things // happen without delay, since these resources are quite heavy. mClient.clear(); @@ -413,11 +413,6 @@ void Surface::destroy() IPCThreadState::self()->flushCommands(); } -void Surface::clear() -{ - mSurfaceControl->clear(); -} - status_t Surface::validate(per_client_cblk_t const* cblk) const { if (mToken<0 || mClient==0) { @@ -443,6 +438,15 @@ status_t Surface::validate(per_client_cblk_t const* cblk) const return NO_ERROR; } + +bool Surface::isSameSurface( + const sp& lhs, const sp& rhs) +{ + if (lhs == 0 || rhs == 0) + return false; + return lhs->mSurface->asBinder() == rhs->mSurface->asBinder(); +} + // ---------------------------------------------------------------------------- int Surface::setSwapRectangle(android_native_window_t* window, @@ -681,55 +685,6 @@ void Surface::setSwapRectangle(const Rect& r) { mSwapRectangle = r; } -sp Surface::readFromParcel(Parcel* parcel) -{ - sp client; - ISurfaceFlingerClient::surface_data_t data; - sp clientBinder= parcel->readStrongBinder(); - sp surface = interface_cast(parcel->readStrongBinder()); - data.token = parcel->readInt32(); - data.identity = parcel->readInt32(); - PixelFormat format = parcel->readInt32(); - uint32_t flags = parcel->readInt32(); - - if (clientBinder != NULL) - client = SurfaceComposerClient::clientForConnection(clientBinder); - - return new Surface(client, surface, data, 0, 0, format, flags, false); -} - -status_t Surface::writeToParcel(const sp& surface, Parcel* parcel) -{ - uint32_t flags=0; - uint32_t format=0; - SurfaceID token = -1; - uint32_t identity = 0; - sp client; - sp sur; - if (Surface::isValid(surface)) { - token = surface->mToken; - identity = surface->mIdentity; - client = surface->mClient; - sur = surface->mSurface; - format = surface->mFormat; - flags = surface->mFlags; - } - parcel->writeStrongBinder(client!=0 ? client->connection() : NULL); - parcel->writeStrongBinder(sur!=0 ? sur->asBinder() : NULL); - parcel->writeInt32(token); - parcel->writeInt32(identity); - parcel->writeInt32(format); - parcel->writeInt32(flags); - return NO_ERROR; -} - -bool Surface::isSameSurface(const sp& lhs, const sp& rhs) -{ - if (lhs == 0 || rhs == 0) - return false; - return lhs->mSurface->asBinder() == rhs->mSurface->asBinder(); -} - status_t Surface::getBufferLocked(int index) { status_t err = NO_MEMORY; @@ -750,45 +705,5 @@ status_t Surface::getBufferLocked(int index) return err; } - - -status_t Surface::setLayer(int32_t layer) { - return mSurfaceControl->setLayer(layer); -} -status_t Surface::setPosition(int32_t x, int32_t y) { - return mSurfaceControl->setPosition(x, y); -} -status_t Surface::setSize(uint32_t w, uint32_t h) { - return mSurfaceControl->setSize(w, h); -} -status_t Surface::hide() { - return mSurfaceControl->hide(); -} -status_t Surface::show(int32_t layer) { - return mSurfaceControl->show(layer); -} -status_t Surface::freeze() { - return mSurfaceControl->freeze(); -} -status_t Surface::unfreeze() { - return mSurfaceControl->unfreeze(); -} -status_t Surface::setFlags(uint32_t flags, uint32_t mask) { - return mSurfaceControl->setFlags(flags, mask); -} -status_t Surface::setTransparentRegionHint(const Region& transparent) { - return mSurfaceControl->setTransparentRegionHint(transparent); -} -status_t Surface::setAlpha(float alpha) { - return mSurfaceControl->setAlpha(alpha); -} -status_t Surface::setMatrix(float dsdx, float dtdx, float dsdy, float dtdy) { - return mSurfaceControl->setMatrix(dsdx, dtdx, dsdy, dtdy); -} -status_t Surface::setFreezeTint(uint32_t tint) { - return mSurfaceControl->setFreezeTint(tint); -} - - }; // namespace android diff --git a/libs/ui/SurfaceComposerClient.cpp b/libs/ui/SurfaceComposerClient.cpp index 4ccd3965c35f..413167f1ecdf 100644 --- a/libs/ui/SurfaceComposerClient.cpp +++ b/libs/ui/SurfaceComposerClient.cpp @@ -458,7 +458,7 @@ void SurfaceComposerClient::signalServer() mSignalServer->signal(); } -sp SurfaceComposerClient::createSurface( +sp SurfaceComposerClient::createSurface( int pid, DisplayID display, uint32_t w, @@ -466,14 +466,14 @@ sp SurfaceComposerClient::createSurface( PixelFormat format, uint32_t flags) { - sp result; + sp result; if (mStatus == NO_ERROR) { ISurfaceFlingerClient::surface_data_t data; sp surface = mClient->createSurface(&data, pid, display, w, h, format, flags); if (surface != 0) { if (uint32_t(data.token) < NUM_LAYERS_MAX) { - result = new Surface(this, surface, data, w, h, format, flags); + result = new SurfaceControl(this, surface, data, w, h, format, flags); } } } -- cgit v1.2.3-59-g8ed1b From d763b5d9197e01662cafa376e1227e53e0463a3c Mon Sep 17 00:00:00 2001 From: Mathias Agopian Date: Thu, 2 Jul 2009 18:11:53 -0700 Subject: get rid of references to MemoryDealer in SurfaceFlinger --- include/ui/ISurfaceComposer.h | 2 +- include/ui/ISurfaceFlingerClient.h | 2 +- include/ui/SurfaceComposerClient.h | 2 +- libs/surfaceflinger/Layer.h | 1 - libs/surfaceflinger/LayerBitmap.cpp | 1 - libs/surfaceflinger/LayerBitmap.h | 1 - libs/surfaceflinger/LayerBuffer.h | 1 - libs/surfaceflinger/SurfaceFlinger.cpp | 54 ++++++++++++++++------------------ libs/surfaceflinger/SurfaceFlinger.h | 28 ++++++++++-------- libs/ui/ISurfaceComposer.cpp | 4 +-- libs/ui/ISurfaceFlingerClient.cpp | 7 ++--- libs/ui/SurfaceComposerClient.cpp | 10 +++---- 12 files changed, 55 insertions(+), 58 deletions(-) (limited to 'libs/ui/SurfaceComposerClient.cpp') diff --git a/include/ui/ISurfaceComposer.h b/include/ui/ISurfaceComposer.h index ce2b94c3e160..1788265b5840 100644 --- a/include/ui/ISurfaceComposer.h +++ b/include/ui/ISurfaceComposer.h @@ -92,7 +92,7 @@ public: virtual sp createConnection() = 0; /* retrieve the control block */ - virtual sp getCblk() const = 0; + virtual sp getCblk() const = 0; /* open/close transactions. recquires ACCESS_SURFACE_FLINGER permission */ virtual void openGlobalTransaction() = 0; diff --git a/include/ui/ISurfaceFlingerClient.h b/include/ui/ISurfaceFlingerClient.h index e93a4fafe281..932a70a854a1 100644 --- a/include/ui/ISurfaceFlingerClient.h +++ b/include/ui/ISurfaceFlingerClient.h @@ -56,7 +56,7 @@ public: status_t writeToParcel(Parcel* parcel) const; }; - virtual void getControlBlocks(sp* ctl) const = 0; + virtual sp getControlBlock() const = 0; virtual sp createSurface( surface_data_t* data, int pid, diff --git a/include/ui/SurfaceComposerClient.h b/include/ui/SurfaceComposerClient.h index 2a35256d2889..286f8850fd93 100644 --- a/include/ui/SurfaceComposerClient.h +++ b/include/ui/SurfaceComposerClient.h @@ -149,7 +149,7 @@ private: // after assignment status_t mStatus; per_client_cblk_t* mControl; - sp mControlMemory; + sp mControlMemory; sp mClient; SurfaceFlingerSynchro* mSignalServer; }; diff --git a/libs/surfaceflinger/Layer.h b/libs/surfaceflinger/Layer.h index 54d994facc7d..4c13d6ea2887 100644 --- a/libs/surfaceflinger/Layer.h +++ b/libs/surfaceflinger/Layer.h @@ -42,7 +42,6 @@ namespace android { class Client; class LayerBitmap; -class MemoryDealer; class FreezeLock; // --------------------------------------------------------------------------- diff --git a/libs/surfaceflinger/LayerBitmap.cpp b/libs/surfaceflinger/LayerBitmap.cpp index e0984fe48c7c..9fffbbfbb9ff 100644 --- a/libs/surfaceflinger/LayerBitmap.cpp +++ b/libs/surfaceflinger/LayerBitmap.cpp @@ -20,7 +20,6 @@ #include #include -#include #include #include diff --git a/libs/surfaceflinger/LayerBitmap.h b/libs/surfaceflinger/LayerBitmap.h index f3636c03e03b..22525cebdfc5 100644 --- a/libs/surfaceflinger/LayerBitmap.h +++ b/libs/surfaceflinger/LayerBitmap.h @@ -40,7 +40,6 @@ namespace android { // --------------------------------------------------------------------------- class IMemory; -class MemoryDealer; class LayerBitmap; // =========================================================================== diff --git a/libs/surfaceflinger/LayerBuffer.h b/libs/surfaceflinger/LayerBuffer.h index cd541a513024..fe879ebd976e 100644 --- a/libs/surfaceflinger/LayerBuffer.h +++ b/libs/surfaceflinger/LayerBuffer.h @@ -32,7 +32,6 @@ namespace android { // --------------------------------------------------------------------------- -class MemoryDealer; class Region; class OverlayRef; diff --git a/libs/surfaceflinger/SurfaceFlinger.cpp b/libs/surfaceflinger/SurfaceFlinger.cpp index c38668113213..5ac1cfd932c9 100644 --- a/libs/surfaceflinger/SurfaceFlinger.cpp +++ b/libs/surfaceflinger/SurfaceFlinger.cpp @@ -31,8 +31,8 @@ #include #include -#include -#include +#include + #include #include #include @@ -217,9 +217,9 @@ overlay_control_device_t* SurfaceFlinger::getOverlayEngine() const return graphicPlane(0).displayHardware().getOverlayEngine(); } -sp SurfaceFlinger::getCblk() const +sp SurfaceFlinger::getCblk() const { - return mServerCblkMemory; + return mServerHeap; } sp SurfaceFlinger::createConnection() @@ -238,7 +238,7 @@ sp SurfaceFlinger::createConnection() return 0; } sp bclient = - new BClient(this, token, client->controlBlockMemory()); + new BClient(this, token, client->getControlBlockMemory()); return bclient; } @@ -301,7 +301,6 @@ void SurfaceFlinger::onFirstRef() mReadyToRunBarrier.wait(); } - static inline uint16_t pack565(int r, int g, int b) { return (r<<11)|(g<<5)|b; } @@ -311,17 +310,6 @@ status_t SurfaceFlinger::readyToRun() LOGI( "SurfaceFlinger's main thread ready to run. " "Initializing graphics H/W..."); - // create the shared control-block - mServerHeap = new MemoryDealer(4096, MemoryDealer::READ_ONLY); - LOGE_IF(mServerHeap==0, "can't create shared memory dealer"); - - mServerCblkMemory = mServerHeap->allocate(4096); - LOGE_IF(mServerCblkMemory==0, "can't create shared control block"); - - mServerCblk = static_cast(mServerCblkMemory->pointer()); - LOGE_IF(mServerCblk==0, "can't get to shared control block's address"); - new(mServerCblk) surface_flinger_cblk_t; - // we only support one display currently int dpy = 0; @@ -332,6 +320,16 @@ status_t SurfaceFlinger::readyToRun() plane.setDisplayHardware(hw); } + // create the shared control-block + mServerHeap = new MemoryHeapBase(4096, + MemoryHeapBase::READ_ONLY, "SurfaceFlinger read-only heap"); + LOGE_IF(mServerHeap==0, "can't create shared memory dealer"); + + mServerCblk = static_cast(mServerHeap->getBase()); + LOGE_IF(mServerCblk==0, "can't get to shared control block's address"); + + new(mServerCblk) surface_flinger_cblk_t; + // initialize primary screen // (other display should be initialized in the same manner, but // asynchronously, as they could come and go. None of this is supported @@ -1615,14 +1613,14 @@ Client::Client(ClientID clientID, const sp& flinger) : ctrlblk(0), cid(clientID), mPid(0), mBitmap(0), mFlinger(flinger) { const int pgsize = getpagesize(); - const int cblksize=((sizeof(per_client_cblk_t)+(pgsize-1))&~(pgsize-1)); - mCblkHeap = new MemoryDealer(cblksize); - mCblkMemory = mCblkHeap->allocate(cblksize); - if (mCblkMemory != 0) { - ctrlblk = static_cast(mCblkMemory->pointer()); - if (ctrlblk) { // construct the shared structure in-place. - new(ctrlblk) per_client_cblk_t; - } + const int cblksize = ((sizeof(per_client_cblk_t)+(pgsize-1))&~(pgsize-1)); + + mCblkHeap = new MemoryHeapBase(cblksize, 0, + "SurfaceFlinger Client control-block"); + + ctrlblk = static_cast(mCblkHeap->getBase()); + if (ctrlblk) { // construct the shared structure in-place. + new(ctrlblk) per_client_cblk_t; } } @@ -1685,7 +1683,7 @@ void Client::dump(const char* what) #pragma mark - #endif -BClient::BClient(SurfaceFlinger *flinger, ClientID cid, const sp& cblk) +BClient::BClient(SurfaceFlinger *flinger, ClientID cid, const sp& cblk) : mId(cid), mFlinger(flinger), mCblk(cblk) { } @@ -1695,8 +1693,8 @@ BClient::~BClient() { mFlinger->destroyConnection(mId); } -void BClient::getControlBlocks(sp* ctrl) const { - *ctrl = mCblk; +sp BClient::getControlBlock() const { + return mCblk; } sp BClient::createSurface( diff --git a/libs/surfaceflinger/SurfaceFlinger.h b/libs/surfaceflinger/SurfaceFlinger.h index b7b008d9ff06..d0095a2bdfeb 100644 --- a/libs/surfaceflinger/SurfaceFlinger.h +++ b/libs/surfaceflinger/SurfaceFlinger.h @@ -27,7 +27,7 @@ #include #include -#include +#include #include #include @@ -76,25 +76,30 @@ public: inline bool isValid(int32_t i) const; sp getLayerUser(int32_t i) const; - const Vector< wp >& getLayers() const { return mLayers; } - const sp& controlBlockMemory() const { return mCblkMemory; } void dump(const char* what); + const Vector< wp >& getLayers() const { + return mLayers; + } + + const sp& getControlBlockMemory() const { + return mCblkHeap; + } + // pointer to this client's control block per_client_cblk_t* ctrlblk; ClientID cid; private: - int getClientPid() const { return mPid; } + int getClientPid() const { return mPid; } int mPid; uint32_t mBitmap; SortedVector mInUse; Vector< wp > mLayers; - sp mCblkHeap; + sp mCblkHeap; sp mFlinger; - sp mCblkMemory; }; // --------------------------------------------------------------------------- @@ -154,7 +159,7 @@ public: // ISurfaceComposer interface virtual sp createConnection(); - virtual sp getCblk() const; + virtual sp getCblk() const; virtual void bootFinished(); virtual void openGlobalTransaction(); virtual void closeGlobalTransaction(); @@ -317,8 +322,7 @@ private: Vector< sp > mDisconnectedClients; // constant members (no synchronization needed for access) - sp mServerHeap; - sp mServerCblkMemory; + sp mServerHeap; surface_flinger_cblk_t* mServerCblk; GLuint mWormholeTexName; nsecs_t mBootTime; @@ -377,11 +381,11 @@ class BClient : public BnSurfaceFlingerClient { public: BClient(SurfaceFlinger *flinger, ClientID cid, - const sp& cblk); + const sp& cblk); ~BClient(); // ISurfaceFlingerClient interface - virtual void getControlBlocks(sp* ctrl) const; + virtual sp getControlBlock() const; virtual sp createSurface( surface_data_t* params, int pid, @@ -394,7 +398,7 @@ public: private: ClientID mId; SurfaceFlinger* mFlinger; - sp mCblk; + sp mCblk; }; // --------------------------------------------------------------------------- diff --git a/libs/ui/ISurfaceComposer.cpp b/libs/ui/ISurfaceComposer.cpp index 2aa1405b0c75..fd2a590caff6 100644 --- a/libs/ui/ISurfaceComposer.cpp +++ b/libs/ui/ISurfaceComposer.cpp @@ -54,12 +54,12 @@ public: return interface_cast(reply.readStrongBinder()); } - virtual sp getCblk() const + virtual sp getCblk() const { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); remote()->transact(BnSurfaceComposer::GET_CBLK, data, &reply); - return interface_cast(reply.readStrongBinder()); + return interface_cast(reply.readStrongBinder()); } virtual void openGlobalTransaction() diff --git a/libs/ui/ISurfaceFlingerClient.cpp b/libs/ui/ISurfaceFlingerClient.cpp index 46c12afe898d..51e8422606f9 100644 --- a/libs/ui/ISurfaceFlingerClient.cpp +++ b/libs/ui/ISurfaceFlingerClient.cpp @@ -64,12 +64,12 @@ public: { } - virtual void getControlBlocks(sp* ctl) const + virtual sp getControlBlock() const { Parcel data, reply; data.writeInterfaceToken(ISurfaceFlingerClient::getInterfaceDescriptor()); remote()->transact(GET_CBLK, data, &reply); - *ctl = interface_cast(reply.readStrongBinder()); + return interface_cast(reply.readStrongBinder()); } virtual sp createSurface( surface_data_t* params, @@ -126,8 +126,7 @@ status_t BnSurfaceFlingerClient::onTransact( switch(code) { case GET_CBLK: { CHECK_INTERFACE(ISurfaceFlingerClient, data, reply); - sp ctl; - getControlBlocks(&ctl); + sp ctl(getControlBlock()); reply->writeStrongBinder(ctl->asBinder()); return NO_ERROR; } break; diff --git a/libs/ui/SurfaceComposerClient.cpp b/libs/ui/SurfaceComposerClient.cpp index 025bf6e385b0..d2cef785778a 100644 --- a/libs/ui/SurfaceComposerClient.cpp +++ b/libs/ui/SurfaceComposerClient.cpp @@ -59,7 +59,7 @@ static Mutex gLock; static sp gSurfaceManager; static DefaultKeyedVector< sp, sp > gActiveConnections; static SortedVector > gOpenTransactions; -static sp gServerCblkMemory; +static sp gServerCblkMemory; static volatile surface_flinger_cblk_t* gServerCblk; const sp& _get_surface_manager() @@ -94,7 +94,7 @@ static volatile surface_flinger_cblk_t const * get_cblk() if (gServerCblk == 0) { gServerCblkMemory = sm->getCblk(); LOGE_IF(gServerCblkMemory==0, "Can't get server control block"); - gServerCblk = (surface_flinger_cblk_t *)gServerCblkMemory->pointer(); + gServerCblk = (surface_flinger_cblk_t *)gServerCblkMemory->getBase(); LOGE_IF(gServerCblk==0, "Can't get server control block address"); } } @@ -313,9 +313,9 @@ void SurfaceComposerClient::_init( return; } - mClient->getControlBlocks(&mControlMemory); + mControlMemory = mClient->getControlBlock(); mSignalServer = new SurfaceFlingerSynchro(sm); - mControl = static_cast(mControlMemory->pointer()); + mControl = static_cast(mControlMemory->getBase()); } SurfaceComposerClient::~SurfaceComposerClient() @@ -364,7 +364,7 @@ void SurfaceComposerClient::dispose() { // this can be called more than once. - sp controlMemory; + sp controlMemory; sp client; { -- cgit v1.2.3-59-g8ed1b