From b267579ba8dfe3f47d2a481c5a3c2254e3d565a1 Mon Sep 17 00:00:00 2001 From: Daniel Lam Date: Thu, 23 Feb 2012 14:35:13 -0800 Subject: [PATCH] SurfaceTexture: Fully refactored from BufferQueue SurfaceTexture and BufferQueue are separate objects. Change-Id: I230bc0ae6f78d0f9b2b5df902f40ab443ed5a055 --- include/gui/BufferQueue.h | 22 +++++ include/gui/SurfaceTexture.h | 33 +++++-- include/gui/SurfaceTextureClient.h | 12 ++- libs/gui/BufferQueue.cpp | 40 +++++++-- libs/gui/SurfaceTexture.cpp | 86 +++++++++++++++---- libs/gui/SurfaceTextureClient.cpp | 8 ++ services/surfaceflinger/Layer.cpp | 25 +++++- services/surfaceflinger/Layer.h | 3 +- services/surfaceflinger/SurfaceFlinger.cpp | 1 + .../surfaceflinger/SurfaceTextureLayer.cpp | 62 +------------ services/surfaceflinger/SurfaceTextureLayer.h | 24 ++---- 11 files changed, 204 insertions(+), 112 deletions(-) diff --git a/include/gui/BufferQueue.h b/include/gui/BufferQueue.h index 8c21a28cf..46d185413 100644 --- a/include/gui/BufferQueue.h +++ b/include/gui/BufferQueue.h @@ -203,6 +203,16 @@ public: // when a new frame becomes available. void setFrameAvailableListener(const sp& listener); + // setDefaultBufferFormat allows the BufferQueue to create + // GraphicBuffers of a defaultFormat if no format is specified + // in dequeueBuffer + status_t setDefaultBufferFormat(uint32_t defaultFormat); + + // setConsumerUsageBits will turn on additional usage bits for dequeueBuffer + status_t setConsumerUsageBits(uint32_t usage); + + // setTransformHint bakes in rotation to buffers so overlays can be used + status_t setTransformHint(uint32_t hint); private: // freeBufferLocked frees the resources (both GraphicBuffer and EGLImage) @@ -417,7 +427,19 @@ private: // with the surface Texture. uint64_t mFrameCounter; + // mBufferHasBeenQueued is true once a buffer has been queued. It is reset + // by changing the buffer count. bool mBufferHasBeenQueued; + + // mDefaultBufferFormat can be set so it will override + // the buffer format when it isn't specified in dequeueBuffer + uint32_t mDefaultBufferFormat; + + // mConsumerUsageBits contains flags the consumer wants for GraphicBuffers + uint32_t mConsumerUsageBits; + + // mTransformHint is used to optimize for screen rotations + uint32_t mTransformHint; }; // ---------------------------------------------------------------------------- diff --git a/include/gui/SurfaceTexture.h b/include/gui/SurfaceTexture.h index 5531e539b..2ab2ab7a4 100644 --- a/include/gui/SurfaceTexture.h +++ b/include/gui/SurfaceTexture.h @@ -39,8 +39,12 @@ namespace android { class String8; -class SurfaceTexture : public BufferQueue { +class SurfaceTexture : public virtual RefBase { public: + // This typedef allows external code to continue referencing + // SurfaceTexture::FrameAvailableListener during refactoring + typedef BufferQueue::FrameAvailableListener FrameAvailableListener; + // SurfaceTexture constructs a new SurfaceTexture object. tex indicates the // name of the OpenGL ES texture to which images are to be streamed. This @@ -49,14 +53,15 @@ public: // enabled. texTarget specifies the OpenGL ES texture target to which the // texture will be bound in updateTexImage. useFenceSync specifies whether // fences should be used to synchronize access to buffers if that behavior - // is enabled at compile-time. + // is enabled at compile-time. A custom bufferQueue can be specified + // if behavior for queue/dequeue/connect etc needs to be customized. + // Otherwise a default BufferQueue will be created and used. SurfaceTexture(GLuint tex, bool allowSynchronousMode = true, - GLenum texTarget = GL_TEXTURE_EXTERNAL_OES, bool useFenceSync = true); + GLenum texTarget = GL_TEXTURE_EXTERNAL_OES, bool useFenceSync = true, + const sp &bufferQueue = 0); virtual ~SurfaceTexture(); - - // updateTexImage sets the image contents of the target texture to that of // the most recently queued buffer. // @@ -152,6 +157,18 @@ public: // log messages. void setName(const String8& name); + // These functions call the corresponding BufferQueue implementation + // so the refactoring can proceed smoothly + status_t setDefaultBufferFormat(uint32_t defaultFormat); + status_t setConsumerUsageBits(uint32_t usage); + status_t setTransformHint(uint32_t hint); + virtual status_t setSynchronousMode(bool enabled); + virtual status_t setBufferCount(int bufferCount); + virtual status_t connect(int api, + uint32_t* outWidth, uint32_t* outHeight, uint32_t* outTransform); + + sp getBufferQueue() const; + // dump our state in a String virtual void dump(String8& result) const; virtual void dump(String8& result, const char* prefix, char* buffer, size_t SIZE) const; @@ -241,7 +258,7 @@ private: EGLSyncKHR mFence; }; - EGLSlot mEGLSlots[NUM_BUFFER_SLOTS]; + EGLSlot mEGLSlots[BufferQueue::NUM_BUFFER_SLOTS]; // mAbandoned indicates that the BufferQueue will no longer be used to // consume images buffers pushed to it using the ISurfaceTexture interface. @@ -267,6 +284,10 @@ private: // reset mCurrentTexture to INVALID_BUFFER_SLOT. int mCurrentTexture; + // The SurfaceTexture has-a BufferQueue and is responsible for creating this object + // if none is supplied + sp mBufferQueue; + }; // ---------------------------------------------------------------------------- diff --git a/include/gui/SurfaceTextureClient.h b/include/gui/SurfaceTextureClient.h index aa7fe48a5..1051bd2f4 100644 --- a/include/gui/SurfaceTextureClient.h +++ b/include/gui/SurfaceTextureClient.h @@ -19,6 +19,7 @@ #include #include +#include #include #include @@ -34,8 +35,15 @@ class SurfaceTextureClient : public ANativeObjectBase { public: + SurfaceTextureClient(const sp& surfaceTexture); + // SurfaceTextureClient is overloaded to assist in refactoring ST and BQ. + // SurfaceTexture is no longer an ISurfaceTexture, so client code + // calling the original constructor will fail. Thus this convenience method + // passes in the surfaceTexture's bufferQueue to the init method. + SurfaceTextureClient(const sp& surfaceTexture); + sp getISurfaceTexture() const; protected: @@ -94,8 +102,8 @@ protected: virtual int lock(ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds); virtual int unlockAndPost(); - enum { MIN_UNDEQUEUED_BUFFERS = SurfaceTexture::MIN_UNDEQUEUED_BUFFERS }; - enum { NUM_BUFFER_SLOTS = SurfaceTexture::NUM_BUFFER_SLOTS }; + enum { MIN_UNDEQUEUED_BUFFERS = BufferQueue::MIN_UNDEQUEUED_BUFFERS }; + enum { NUM_BUFFER_SLOTS = BufferQueue::NUM_BUFFER_SLOTS }; enum { DEFAULT_FORMAT = PIXEL_FORMAT_RGBA_8888 }; private: diff --git a/libs/gui/BufferQueue.cpp b/libs/gui/BufferQueue.cpp index 54ee6ce98..0f9c7c5c4 100644 --- a/libs/gui/BufferQueue.cpp +++ b/libs/gui/BufferQueue.cpp @@ -83,7 +83,10 @@ BufferQueue::BufferQueue( bool allowSynchronousMode ) : mConnectedApi(NO_CONNECTED_API), mAbandoned(false), mFrameCounter(0), - mBufferHasBeenQueued(false) + mBufferHasBeenQueued(false), + mDefaultBufferFormat(0), + mConsumerUsageBits(0), + mTransformHint(0) { // Choose a name using the PID and a process-unique ID. mConsumerName = String8::format("unnamed-%d-%d", getpid(), createProcessUniqueId()); @@ -128,6 +131,7 @@ status_t BufferQueue::setBufferCountServerLocked(int bufferCount) { // dequeueBuffer. mServerBufferCount = bufferCount; + mDequeueCondition.broadcast(); } return OK; } @@ -149,6 +153,24 @@ void BufferQueue::setFrameAvailableListener( mFrameAvailableListener = listener; } +status_t BufferQueue::setDefaultBufferFormat(uint32_t defaultFormat) { + Mutex::Autolock lock(mMutex); + mDefaultBufferFormat = defaultFormat; + return OK; +} + +status_t BufferQueue::setConsumerUsageBits(uint32_t usage) { + Mutex::Autolock lock(mMutex); + mConsumerUsageBits = usage; + return OK; +} + +status_t BufferQueue::setTransformHint(uint32_t hint) { + Mutex::Autolock lock(mMutex); + mTransformHint = hint; + return OK; +} + status_t BufferQueue::setBufferCount(int bufferCount) { ST_LOGV("setBufferCount: count=%d", bufferCount); Mutex::Autolock lock(mMutex); @@ -263,6 +285,12 @@ status_t BufferQueue::dequeueBuffer(int *outBuf, uint32_t w, uint32_t h, { // Scope for the lock Mutex::Autolock lock(mMutex); + if (format == 0) { + format = mDefaultBufferFormat; + } + // turn on usage bits the consumer requested + usage |= mConsumerUsageBits; + int found = -1; int foundSync = -1; int dequeuedCount = 0; @@ -563,7 +591,7 @@ status_t BufferQueue::queueBuffer(int buf, int64_t timestamp, *outWidth = mDefaultWidth; *outHeight = mDefaultHeight; - *outTransform = 0; + *outTransform = mTransformHint; ATRACE_INT(mConsumerName.string(), mQueue.size()); } // scope for the lock @@ -846,7 +874,8 @@ status_t BufferQueue::acquire(BufferItem *buffer) { ATRACE_INT(mConsumerName.string(), mQueue.size()); } else { - return -EINVAL; //should be a better return code + // should be a better return code? + return -EINVAL; } return OK; @@ -880,9 +909,10 @@ status_t BufferQueue::releaseBuffer(int buf, EGLDisplay display, status_t BufferQueue::consumerDisconnect() { Mutex::Autolock lock(mMutex); - // Once the SurfaceTexture disconnects, the BufferQueue - // is considered abandoned + mAbandoned = true; + + mQueue.clear(); freeAllBuffersLocked(); mDequeueCondition.broadcast(); return OK; diff --git a/libs/gui/SurfaceTexture.cpp b/libs/gui/SurfaceTexture.cpp index b42aa34d7..5fb933be1 100644 --- a/libs/gui/SurfaceTexture.cpp +++ b/libs/gui/SurfaceTexture.cpp @@ -105,8 +105,7 @@ static int32_t createProcessUniqueId() { } SurfaceTexture::SurfaceTexture(GLuint tex, bool allowSynchronousMode, - GLenum texTarget, bool useFenceSync) : - BufferQueue(allowSynchronousMode), + GLenum texTarget, bool useFenceSync, const sp &bufferQueue) : mCurrentTransform(0), mCurrentTimestamp(0), mTexName(tex), @@ -121,27 +120,37 @@ SurfaceTexture::SurfaceTexture(GLuint tex, bool allowSynchronousMode, { // Choose a name using the PID and a process-unique ID. mName = String8::format("unnamed-%d-%d", getpid(), createProcessUniqueId()); - BufferQueue::setConsumerName(mName); - ST_LOGV("SurfaceTexture"); + if (bufferQueue == 0) { + + ST_LOGV("Creating a new BufferQueue"); + mBufferQueue = new BufferQueue(allowSynchronousMode); + } + else { + mBufferQueue = bufferQueue; + } + mBufferQueue->setConsumerName(mName); + memcpy(mCurrentTransformMatrix, mtxIdentity, sizeof(mCurrentTransformMatrix)); } SurfaceTexture::~SurfaceTexture() { ST_LOGV("~SurfaceTexture"); + abandon(); } status_t SurfaceTexture::setBufferCountServer(int bufferCount) { Mutex::Autolock lock(mMutex); - return BufferQueue::setBufferCountServer(bufferCount); + return mBufferQueue->setBufferCountServer(bufferCount); } status_t SurfaceTexture::setDefaultBufferSize(uint32_t w, uint32_t h) { - return BufferQueue::setDefaultBufferSize(w, h); + Mutex::Autolock lock(mMutex); + return mBufferQueue->setDefaultBufferSize(w, h); } status_t SurfaceTexture::updateTexImage() { @@ -154,11 +163,11 @@ status_t SurfaceTexture::updateTexImage() { return NO_INIT; } - BufferItem item; + BufferQueue::BufferItem item; // In asynchronous mode the list is guaranteed to be one buffer // deep, while in synchronous mode we use the oldest buffer. - if (acquire(&item) == NO_ERROR) { + if (mBufferQueue->acquire(&item) == NO_ERROR) { int buf = item.mBuf; // This buffer was newly allocated, so we need to clean up on our side if (item.mGraphicBuffer != NULL) { @@ -205,19 +214,19 @@ status_t SurfaceTexture::updateTexImage() { failed = true; } if (failed) { - releaseBuffer(buf, mEGLSlots[buf].mEglDisplay, + mBufferQueue->releaseBuffer(buf, mEGLSlots[buf].mEglDisplay, mEGLSlots[buf].mFence); return -EINVAL; } - if (mCurrentTexture != INVALID_BUFFER_SLOT) { + if (mCurrentTexture != BufferQueue::INVALID_BUFFER_SLOT) { if (mUseFenceSync) { EGLSyncKHR fence = eglCreateSyncKHR(dpy, EGL_SYNC_FENCE_KHR, NULL); if (fence == EGL_NO_SYNC_KHR) { ALOGE("updateTexImage: error creating fence: %#x", eglGetError()); - releaseBuffer(buf, mEGLSlots[buf].mEglDisplay, + mBufferQueue->releaseBuffer(buf, mEGLSlots[buf].mEglDisplay, mEGLSlots[buf].mFence); return -EINVAL; } @@ -232,7 +241,7 @@ status_t SurfaceTexture::updateTexImage() { buf, item.mGraphicBuffer != NULL ? item.mGraphicBuffer->handle : 0); // release old buffer - releaseBuffer(mCurrentTexture, + mBufferQueue->releaseBuffer(mCurrentTexture, mEGLSlots[mCurrentTexture].mEglDisplay, mEGLSlots[mCurrentTexture].mFence); @@ -385,7 +394,7 @@ void SurfaceTexture::setFrameAvailableListener( const sp& listener) { ST_LOGV("setFrameAvailableListener"); Mutex::Autolock lock(mMutex); - BufferQueue::setFrameAvailableListener(listener); + mBufferQueue->setFrameAvailableListener(listener); } EGLImageKHR SurfaceTexture::createImage(EGLDisplay dpy, @@ -426,7 +435,7 @@ uint32_t SurfaceTexture::getCurrentScalingMode() const { bool SurfaceTexture::isSynchronousMode() const { Mutex::Autolock lock(mMutex); - return BufferQueue::isSynchronousMode(); + return mBufferQueue->isSynchronousMode(); } void SurfaceTexture::abandon() { @@ -435,7 +444,7 @@ void SurfaceTexture::abandon() { mCurrentTextureBuf.clear(); // destroy all egl buffers - for (int i =0; i < NUM_BUFFER_SLOTS; i++) { + for (int i =0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) { mEGLSlots[i].mGraphicBuffer = 0; if (mEGLSlots[i].mEglImage != EGL_NO_IMAGE_KHR) { eglDestroyImageKHR(mEGLSlots[i].mEglDisplay, @@ -446,13 +455,54 @@ void SurfaceTexture::abandon() { } // disconnect from the BufferQueue - BufferQueue::consumerDisconnect(); + mBufferQueue->consumerDisconnect(); } void SurfaceTexture::setName(const String8& name) { Mutex::Autolock _l(mMutex); mName = name; - BufferQueue::setConsumerName(name); + mBufferQueue->setConsumerName(name); +} + +status_t SurfaceTexture::setDefaultBufferFormat(uint32_t defaultFormat) { + Mutex::Autolock lock(mMutex); + return mBufferQueue->setDefaultBufferFormat(defaultFormat); +} + +status_t SurfaceTexture::setConsumerUsageBits(uint32_t usage) { + Mutex::Autolock lock(mMutex); + return mBufferQueue->setConsumerUsageBits(usage); +} + +status_t SurfaceTexture::setTransformHint(uint32_t hint) { + Mutex::Autolock lock(mMutex); + return mBufferQueue->setTransformHint(hint); +} + +// Used for refactoring BufferQueue from SurfaceTexture +// Should not be in final interface once users of SurfaceTexture are clean up. +status_t SurfaceTexture::setSynchronousMode(bool enabled) { + Mutex::Autolock lock(mMutex); + return mBufferQueue->setSynchronousMode(enabled); +} + +// Used for refactoring, should not be in final interface +sp SurfaceTexture::getBufferQueue() const { + Mutex::Autolock lock(mMutex); + return mBufferQueue; +} + +// Used for refactoring, should not be in final interface +status_t SurfaceTexture::setBufferCount(int bufferCount) { + Mutex::Autolock lock(mMutex); + return mBufferQueue->setBufferCount(bufferCount); +} + +// Used for refactoring, should not be in final interface +status_t SurfaceTexture::connect(int api, + uint32_t* outWidth, uint32_t* outHeight, uint32_t* outTransform) { + Mutex::Autolock lock(mMutex); + return mBufferQueue->connect(api, outWidth, outHeight, outTransform); } void SurfaceTexture::dump(String8& result) const @@ -477,7 +527,7 @@ void SurfaceTexture::dump(String8& result, const char* prefix, result.append(buffer); - BufferQueue::dump(result, prefix, buffer, SIZE); + mBufferQueue->dump(result, prefix, buffer, SIZE); } static void mtxMul(float out[16], const float a[16], const float b[16]) { diff --git a/libs/gui/SurfaceTextureClient.cpp b/libs/gui/SurfaceTextureClient.cpp index f88dcaf02..d18a3d48e 100644 --- a/libs/gui/SurfaceTextureClient.cpp +++ b/libs/gui/SurfaceTextureClient.cpp @@ -36,6 +36,14 @@ SurfaceTextureClient::SurfaceTextureClient( SurfaceTextureClient::setISurfaceTexture(surfaceTexture); } +// see SurfaceTextureClient.h +SurfaceTextureClient::SurfaceTextureClient(const + sp& surfaceTexture) +{ + SurfaceTextureClient::init(); + SurfaceTextureClient::setISurfaceTexture(surfaceTexture->getBufferQueue()); +} + SurfaceTextureClient::SurfaceTextureClient() { SurfaceTextureClient::init(); } diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp index df7fe5c49..464307144 100644 --- a/services/surfaceflinger/Layer.cpp +++ b/services/surfaceflinger/Layer.cpp @@ -97,9 +97,19 @@ void Layer::onFirstRef() } } }; - mSurfaceTexture = new SurfaceTextureLayer(mTextureName, this); + + // Creates a custom BufferQueue for SurfaceTexture to use + sp bq = new SurfaceTextureLayer(); + mSurfaceTexture = new SurfaceTexture(mTextureName, true, + GL_TEXTURE_EXTERNAL_OES, false,bq); + + + + mSurfaceTexture->setTransformHint(getTransformHint()); + mSurfaceTexture->setConsumerUsageBits(getEffectiveUsage(0)); mSurfaceTexture->setFrameAvailableListener(new FrameQueuedListener(this)); mSurfaceTexture->setSynchronousMode(true); + #ifdef USE_TRIPLE_BUFFERING #warning "using triple buffering" mSurfaceTexture->setBufferCountServer(3); @@ -131,6 +141,14 @@ void Layer::setName(const String8& name) { mSurfaceTexture->setName(name); } +void Layer::validateVisibility(const Transform& globalTransform) { + LayerBase::validateVisibility(globalTransform); + + // This optimization allows the SurfaceTexture to bake in + // the rotation so hardware overlays can be used + mSurfaceTexture->setTransformHint(getTransformHint()); +} + sp Layer::createSurface() { class BSurface : public BnSurface, public LayerCleaner { @@ -139,7 +157,7 @@ sp Layer::createSurface() sp res; sp that( mOwner.promote() ); if (that != NULL) { - res = that->mSurfaceTexture; + res = that->mSurfaceTexture->getBufferQueue(); } return res; } @@ -154,7 +172,7 @@ sp Layer::createSurface() wp Layer::getSurfaceTextureBinder() const { - return mSurfaceTexture->asBinder(); + return mSurfaceTexture->getBufferQueue()->asBinder(); } status_t Layer::setBuffers( uint32_t w, uint32_t h, @@ -193,6 +211,7 @@ status_t Layer::setBuffers( uint32_t w, uint32_t h, mSurfaceTexture->setDefaultBufferSize(w, h); mSurfaceTexture->setDefaultBufferFormat(format); + mSurfaceTexture->setConsumerUsageBits(getEffectiveUsage(0)); // we use the red index int displayRedSize = displayInfo.getSize(PixelFormatInfo::INDEX_RED); diff --git a/services/surfaceflinger/Layer.h b/services/surfaceflinger/Layer.h index 8d508c2eb..9a0484859 100644 --- a/services/surfaceflinger/Layer.h +++ b/services/surfaceflinger/Layer.h @@ -77,6 +77,7 @@ public: virtual void onRemoved(); virtual sp getLayer() const { return const_cast(this); } virtual void setName(const String8& name); + virtual void validateVisibility(const Transform& globalTransform); // LayerBaseClient interface virtual wp getSurfaceTextureBinder() const; @@ -105,7 +106,7 @@ private: // ----------------------------------------------------------------------- // constants - sp mSurfaceTexture; + sp mSurfaceTexture; GLuint mTextureName; // thread-safe diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp index 0c597d62b..00988893c 100644 --- a/services/surfaceflinger/SurfaceFlinger.cpp +++ b/services/surfaceflinger/SurfaceFlinger.cpp @@ -1399,6 +1399,7 @@ status_t SurfaceFlinger::removeSurface(const sp& client, SurfaceID sid) status_t err = NAME_NOT_FOUND; Mutex::Autolock _l(mStateLock); sp layer = client->getLayerUser(sid); + if (layer != 0) { err = purgatorizeLayer_l(layer); if (err == NO_ERROR) { diff --git a/services/surfaceflinger/SurfaceTextureLayer.cpp b/services/surfaceflinger/SurfaceTextureLayer.cpp index 49e8e6393..d7fd39e21 100644 --- a/services/surfaceflinger/SurfaceTextureLayer.cpp +++ b/services/surfaceflinger/SurfaceTextureLayer.cpp @@ -27,72 +27,18 @@ namespace android { // --------------------------------------------------------------------------- -SurfaceTextureLayer::SurfaceTextureLayer(GLuint tex, const sp& layer) - : SurfaceTexture(tex, true, GL_TEXTURE_EXTERNAL_OES, false), mLayer(layer) { +SurfaceTextureLayer::SurfaceTextureLayer() + : BufferQueue(true) { } SurfaceTextureLayer::~SurfaceTextureLayer() { } - -status_t SurfaceTextureLayer::setDefaultBufferSize(uint32_t w, uint32_t h) -{ - //ALOGD("%s, w=%u, h=%u", __PRETTY_FUNCTION__, w, h); - return SurfaceTexture::setDefaultBufferSize(w, h); -} - -status_t SurfaceTextureLayer::setDefaultBufferFormat(uint32_t format) -{ - mDefaultFormat = format; - return NO_ERROR; -} - -status_t SurfaceTextureLayer::setBufferCount(int bufferCount) { - status_t res = SurfaceTexture::setBufferCount(bufferCount); - return res; -} - -status_t SurfaceTextureLayer::queueBuffer(int buf, int64_t timestamp, - uint32_t* outWidth, uint32_t* outHeight, uint32_t* outTransform) { - - status_t res = SurfaceTexture::queueBuffer(buf, timestamp, - outWidth, outHeight, outTransform); - sp layer(mLayer.promote()); - if (layer != NULL) { - *outTransform = layer->getTransformHint(); - } - return res; -} - -status_t SurfaceTextureLayer::dequeueBuffer(int *buf, - uint32_t w, uint32_t h, uint32_t format, uint32_t usage) { - - status_t res(NO_INIT); - sp layer(mLayer.promote()); - if (layer != NULL) { - if (format == 0) - format = mDefaultFormat; - uint32_t effectiveUsage = layer->getEffectiveUsage(usage); - //ALOGD("%s, w=%u, h=%u, format=%u, usage=%08x, effectiveUsage=%08x", - // __PRETTY_FUNCTION__, w, h, format, usage, effectiveUsage); - res = SurfaceTexture::dequeueBuffer(buf, w, h, format, effectiveUsage); - } - return res; -} - status_t SurfaceTextureLayer::connect(int api, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outTransform) { - status_t err = SurfaceTexture::connect(api, + status_t err = BufferQueue::connect(api, outWidth, outHeight, outTransform); if (err == NO_ERROR) { - sp layer(mLayer.promote()); - if (layer != NULL) { - uint32_t orientation = layer->getOrientation(); - if (orientation & Transform::ROT_INVALID) { - orientation = 0; - } - *outTransform = orientation; - } switch(api) { case NATIVE_WINDOW_API_CPU: // SurfaceTextureClient supports only 2 buffers for CPU connections @@ -110,7 +56,7 @@ status_t SurfaceTextureLayer::connect(int api, #endif // fall through to set synchronous mode when not defaulting to // async mode. - deafult: + default: err = setSynchronousMode(true); break; } diff --git a/services/surfaceflinger/SurfaceTextureLayer.h b/services/surfaceflinger/SurfaceTextureLayer.h index 9508524af..be26b2f8c 100644 --- a/services/surfaceflinger/SurfaceTextureLayer.h +++ b/services/surfaceflinger/SurfaceTextureLayer.h @@ -22,35 +22,21 @@ #include #include -#include +#include namespace android { // --------------------------------------------------------------------------- class Layer; -class SurfaceTextureLayer : public SurfaceTexture +// SurfaceTextureLayer is now a BufferQueue since SurfaceTexture has been +// refactored +class SurfaceTextureLayer : public BufferQueue { - wp mLayer; - uint32_t mDefaultFormat; - public: - SurfaceTextureLayer(GLuint tex, const sp& layer); + SurfaceTextureLayer(); ~SurfaceTextureLayer(); - status_t setDefaultBufferSize(uint32_t w, uint32_t h); - status_t setDefaultBufferFormat(uint32_t format); - -public: - virtual status_t setBufferCount(int bufferCount); - -protected: - virtual status_t queueBuffer(int buf, int64_t timestamp, - uint32_t* outWidth, uint32_t* outHeight, uint32_t* outTransform); - - virtual status_t dequeueBuffer(int *buf, uint32_t w, uint32_t h, - uint32_t format, uint32_t usage); - virtual status_t connect(int api, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outTransform); };