ADHOC
/
replicant-frameworks_native
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge "fix the threading issue for setBuffercount()" into kraken

This commit is contained in:
Mathias Agopian 2010-05-21 13:53:28 -07:00 committed by Android (Google) Code Review
parent 1bb6a71178 bb641244d7
commit 3e23593d2f
15 changed files with 273 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
include/private/surfaceflinger/SharedBufferStack.h
View File

@ -55,12 +55,6 @@ namespace android {
*
*/
// When changing these values, the COMPILE_TIME_ASSERT at the end of this
// file need to be updated.
const unsigned int NUM_LAYERS_MAX = 31;
const unsigned int NUM_BUFFER_MAX = 16;
const unsigned int NUM_DISPLAY_MAX = 4;
// ----------------------------------------------------------------------------
class Region;
@ -82,6 +76,12 @@ class SharedBufferStack
friend class SharedBufferServer;
public:
// When changing these values, the COMPILE_TIME_ASSERT at the end of this
// file need to be updated.
static const unsigned int NUM_LAYERS_MAX = 31;
static const unsigned int NUM_BUFFER_MAX = 16;
static const unsigned int NUM_DISPLAY_MAX = 4;
struct Statistics { // 4 longs
typedef int32_t usecs_t;
usecs_t totalTime;
@ -147,7 +147,7 @@ private:
// FIXME: this should be replaced by a lock-less primitive
Mutex lock;
Condition cv;
SharedBufferStack surfaces[ NUM_LAYERS_MAX ];
SharedBufferStack surfaces[ SharedBufferStack::NUM_LAYERS_MAX ];
};
// ============================================================================
@ -155,7 +155,7 @@ private:
class SharedBufferBase
{
public:
SharedBufferBase(SharedClient* sharedClient, int surface, int num,
SharedBufferBase(SharedClient* sharedClient, int surface,
int32_t identity);
~SharedBufferBase();
uint32_t getIdentity();
@ -166,9 +166,7 @@ public:
protected:
SharedClient* const mSharedClient;
SharedBufferStack* const mSharedStack;
int mNumBuffers;
const int mIdentity;
int32_t computeTail() const;
friend struct Update;
friend struct QueueUpdate;
@ -217,8 +215,16 @@ public:
bool needNewBuffer(int buffer) const;
status_t setDirtyRegion(int buffer, const Region& reg);
status_t setCrop(int buffer, const Rect& reg);
status_t setBufferCount(int bufferCount);
class SetBufferCountCallback {
friend class SharedBufferClient;
virtual status_t operator()(int bufferCount) const = 0;
protected:
virtual ~SetBufferCountCallback() { }
};
status_t setBufferCount(int bufferCount, const SetBufferCountCallback& ipc);
private:
friend struct Condition;
friend struct DequeueCondition;
@ -249,11 +255,16 @@ private:
inline const char* name() const { return "LockCondition"; }
};
int32_t computeTail() const;
mutable RWLock mLock;
int mNumBuffers;
int32_t tail;
int32_t undoDequeueTail;
int32_t queued_head;
// statistics...
nsecs_t mDequeueTime[NUM_BUFFER_MAX];
nsecs_t mDequeueTime[SharedBufferStack::NUM_BUFFER_MAX];
};
// ----------------------------------------------------------------------------
@ -287,7 +298,8 @@ private:
size_t mCapacity;
uint32_t mList;
public:
BufferList(size_t c = NUM_BUFFER_MAX) : mCapacity(c), mList(0) { }
BufferList(size_t c = SharedBufferStack::NUM_BUFFER_MAX)
: mCapacity(c), mList(0) { }
status_t add(int value);
status_t remove(int value);
@ -324,6 +336,9 @@ private:
}
};
// this protects mNumBuffers and mBufferList
mutable RWLock mLock;
int mNumBuffers;
BufferList mBufferList;
struct UnlockUpdate : public UpdateBase {
@ -373,7 +388,7 @@ struct surface_flinger_cblk_t // 4KB max
uint8_t connected;
uint8_t reserved[3];
uint32_t pad[7];
display_cblk_t displays[NUM_DISPLAY_MAX];
display_cblk_t displays[SharedBufferStack::NUM_DISPLAY_MAX];
};
// ---------------------------------------------------------------------------

4
libs/surfaceflinger/Barrier.h
View File

@ -29,10 +29,6 @@ public:
inline Barrier() : state(CLOSED) { }
inline ~Barrier() { }
void open() {
// gcc memory barrier, this makes sure all memory writes
// have been issued by gcc. On an SMP system we'd need a real
// h/w barrier.
asm volatile ("":::"memory");
Mutex::Autolock _l(lock);
state = OPENED;
cv.broadcast();

137
libs/surfaceflinger/Layer.cpp
View File

@ -60,7 +60,7 @@ Layer::Layer(SurfaceFlinger* flinger, DisplayID display,
// no OpenGL operation is possible here, since we might not be
// in the OpenGL thread.
lcblk = new SharedBufferServer(
client->ctrlblk, i, mBufferManager.getBufferCount(),
client->ctrlblk, i, mBufferManager.getDefaultBufferCount(),
getIdentity());
mBufferManager.setActiveBufferIndex( lcblk->getFrontBuffer() );
@ -68,7 +68,10 @@ Layer::Layer(SurfaceFlinger* flinger, DisplayID display,
Layer::~Layer()
{
destroy();
// FIXME: must be called from the main UI thread
EGLDisplay dpy(mFlinger->graphicPlane(0).getEGLDisplay());
mBufferManager.destroy(dpy);
// the actual buffers will be destroyed here
delete lcblk;
}
@ -81,17 +84,6 @@ void Layer::onRemoved()
lcblk->setStatus(NO_INIT);
}
void Layer::destroy()
{
EGLDisplay dpy(mFlinger->graphicPlane(0).getEGLDisplay());
mBufferManager.destroy(dpy);
mSurface.clear();
Mutex::Autolock _l(mLock);
mWidth = mHeight = 0;
}
sp<LayerBaseClient::Surface> Layer::createSurface() const
{
return mSurface;
@ -99,9 +91,17 @@ sp<LayerBaseClient::Surface> Layer::createSurface() const
status_t Layer::ditch()
{
// NOTE: Called from the main UI thread
// the layer is not on screen anymore. free as much resources as possible
mFreezeLock.clear();
destroy();
EGLDisplay dpy(mFlinger->graphicPlane(0).getEGLDisplay());
mBufferManager.destroy(dpy);
mSurface.clear();
Mutex::Autolock _l(mLock);
mWidth = mHeight = 0;
return NO_ERROR;
}
@ -211,7 +211,7 @@ void Layer::onDraw(const Region& clip) const
status_t Layer::setBufferCount(int bufferCount)
{
// this ensures our client doesn't go away while we're accessing
// Ensures our client doesn't go away while we're accessing
// the shared area.
sp<Client> ourClient(client.promote());
if (ourClient == 0) {
@ -219,15 +219,10 @@ status_t Layer::setBufferCount(int bufferCount)
return DEAD_OBJECT;
}
status_t err;
// FIXME: resize() below is NOT thread-safe, we need to synchronize
// the users of lcblk in our process (ie: retire), and we assume the
// client is not mucking with the SharedStack, which is only enforced
// by construction, therefore we need to protect ourselves against
// buggy and malicious client (as always)
err = lcblk->resize(bufferCount);
// NOTE: lcblk->resize() is protected by an internal lock
status_t err = lcblk->resize(bufferCount);
if (err == NO_ERROR)
mBufferManager.resize(bufferCount);
return err;
}
@ -248,7 +243,7 @@ sp<GraphicBuffer> Layer::requestBuffer(int index, int usage)
* This is called from the client's Surface::dequeue(). This can happen
* at any time, especially while we're in the middle of using the
* buffer 'index' as our front buffer.
*
*
* Make sure the buffer we're resizing is not the front buffer and has been
* dequeued. Once this condition is asserted, we are guaranteed that this
* buffer cannot become the front buffer under our feet, since we're called
@ -544,12 +539,20 @@ void Layer::dump(String8& result, char* buffer, size_t SIZE) const
// ---------------------------------------------------------------------------
Layer::BufferManager::BufferManager(TextureManager& tm)
: mTextureManager(tm), mActiveBuffer(0), mFailover(false)
: mNumBuffers(NUM_BUFFERS), mTextureManager(tm),
mActiveBuffer(0), mFailover(false)
{
}
size_t Layer::BufferManager::getBufferCount() const {
return NUM_BUFFERS;
Layer::BufferManager::~BufferManager()
{
}
status_t Layer::BufferManager::resize(size_t size)
{
Mutex::Autolock _l(mLock);
mNumBuffers = size;
return NO_ERROR;
}
// only for debugging
@ -568,51 +571,55 @@ size_t Layer::BufferManager::getActiveBufferIndex() const {
}
Texture Layer::BufferManager::getActiveTexture() const {
return mFailover ? mFailoverTexture : mBufferData[mActiveBuffer].texture;
Texture res;
if (mFailover) {
res = mFailoverTexture;
} else {
static_cast<Image&>(res) = mBufferData[mActiveBuffer].texture;
}
return res;
}
sp<GraphicBuffer> Layer::BufferManager::getActiveBuffer() const {
const size_t activeBuffer = mActiveBuffer;
BufferData const * const buffers = mBufferData;
Mutex::Autolock _l(mLock);
return mBufferData[mActiveBuffer].buffer;
return buffers[activeBuffer].buffer;
}
sp<GraphicBuffer> Layer::BufferManager::detachBuffer(size_t index)
{
BufferData* const buffers = mBufferData;
sp<GraphicBuffer> buffer;
Mutex::Autolock _l(mLock);
buffer = mBufferData[index].buffer;
mBufferData[index].buffer = 0;
buffer = buffers[index].buffer;
buffers[index].buffer = 0;
return buffer;
}
status_t Layer::BufferManager::attachBuffer(size_t index,
const sp<GraphicBuffer>& buffer)
{
BufferData* const buffers = mBufferData;
Mutex::Autolock _l(mLock);
mBufferData[index].buffer = buffer;
mBufferData[index].texture.dirty = true;
return NO_ERROR;
}
status_t Layer::BufferManager::destroyTexture(Texture* tex, EGLDisplay dpy)
{
if (tex->name != -1U) {
glDeleteTextures(1, &tex->name);
tex->name = -1U;
}
if (tex->image != EGL_NO_IMAGE_KHR) {
eglDestroyImageKHR(dpy, tex->image);
tex->image = EGL_NO_IMAGE_KHR;
}
buffers[index].buffer = buffer;
buffers[index].texture.dirty = true;
return NO_ERROR;
}
status_t Layer::BufferManager::destroy(EGLDisplay dpy)
{
Mutex::Autolock _l(mLock);
for (size_t i=0 ; i<NUM_BUFFERS ; i++) {
destroyTexture(&mBufferData[i].texture, dpy);
mBufferData[i].buffer = 0;
BufferData* const buffers = mBufferData;
size_t num;
{ // scope for the lock
Mutex::Autolock _l(mLock);
num = mNumBuffers;
for (size_t i=0 ; i<num ; i++) {
buffers[i].buffer = 0;
}
}
for (size_t i=0 ; i<num ; i++) {
destroyTexture(&buffers[i].texture, dpy);
}
destroyTexture(&mFailoverTexture, dpy);
return NO_ERROR;
@ -622,7 +629,7 @@ status_t Layer::BufferManager::initEglImage(EGLDisplay dpy,
const sp<GraphicBuffer>& buffer)
{
size_t index = mActiveBuffer;
Texture& texture(mBufferData[index].texture);
Image& texture(mBufferData[index].texture);
status_t err = mTextureManager.initEglImage(&texture, dpy, buffer);
// if EGLImage fails, we switch to regular texture mode, and we
// free all resources associated with using EGLImages.
@ -631,7 +638,8 @@ status_t Layer::BufferManager::initEglImage(EGLDisplay dpy,
destroyTexture(&mFailoverTexture, dpy);
} else {
mFailover = true;
for (size_t i=0 ; i<NUM_BUFFERS ; i++) {
const size_t num = mNumBuffers;
for (size_t i=0 ; i<num ; i++) {
destroyTexture(&mBufferData[i].texture, dpy);
}
}
@ -644,6 +652,19 @@ status_t Layer::BufferManager::loadTexture(
return mTextureManager.loadTexture(&mFailoverTexture, dirty, t);
}
status_t Layer::BufferManager::destroyTexture(Image* tex, EGLDisplay dpy)
{
if (tex->name != -1U) {
glDeleteTextures(1, &tex->name);
tex->name = -1U;
}
if (tex->image != EGL_NO_IMAGE_KHR) {
eglDestroyImageKHR(dpy, tex->image);
tex->image = EGL_NO_IMAGE_KHR;
}
return NO_ERROR;
}
// ---------------------------------------------------------------------------
Layer::SurfaceLayer::SurfaceLayer(const sp<SurfaceFlinger>& flinger,
@ -661,6 +682,11 @@ sp<GraphicBuffer> Layer::SurfaceLayer::requestBuffer(int index, int usage)
sp<GraphicBuffer> buffer;
sp<Layer> owner(getOwner());
if (owner != 0) {
/*
* requestBuffer() cannot be called from the main thread
* as it could cause a dead-lock, since it may have to wait
* on conditions updated my the main thread.
*/
buffer = owner->requestBuffer(index, usage);
}
return buffer;
@ -671,6 +697,11 @@ status_t Layer::SurfaceLayer::setBufferCount(int bufferCount)
status_t err = DEAD_OBJECT;
sp<Layer> owner(getOwner());
if (owner != 0) {
/*
* setBufferCount() cannot be called from the main thread
* as it could cause a dead-lock, since it may have to wait
* on conditions updated my the main thread.
*/
err = owner->setBufferCount(bufferCount);
}
return err;

20
libs/surfaceflinger/Layer.h
View File

@ -90,7 +90,6 @@ private:
sp<GraphicBuffer> requestBuffer(int index, int usage);
status_t setBufferCount(int bufferCount);
void destroy();
class SurfaceLayer : public LayerBaseClient::Surface {
public:
@ -120,25 +119,32 @@ private:
static const size_t NUM_BUFFERS = 2;
struct BufferData {
sp<GraphicBuffer> buffer;
Texture texture;
Image texture;
};
// this lock protect mBufferData[].buffer but since there
// is very little contention, we have only one like for
// the whole array, we also use it to protect mNumBuffers.
mutable Mutex mLock;
BufferData mBufferData[NUM_BUFFERS];
BufferData mBufferData[SharedBufferStack::NUM_BUFFER_MAX];
size_t mNumBuffers;
Texture mFailoverTexture;
TextureManager& mTextureManager;
ssize_t mActiveBuffer;
bool mFailover;
static status_t destroyTexture(Texture* tex, EGLDisplay dpy);
static status_t destroyTexture(Image* tex, EGLDisplay dpy);
public:
static size_t getDefaultBufferCount() { return NUM_BUFFERS; }
BufferManager(TextureManager& tm);
size_t getBufferCount() const;
~BufferManager();
// detach/attach buffer from/to given index
sp<GraphicBuffer> detachBuffer(size_t index);
status_t attachBuffer(size_t index, const sp<GraphicBuffer>& buffer);
// resize the number of active buffers
status_t resize(size_t size);
// ----------------------------------------------
// must be called from GL thread
@ -170,6 +176,8 @@ private:
TextureManager mTextureManager;
BufferManager mBufferManager;
// this lock protects mWidth and mHeight which are accessed from
// the main thread and requestBuffer's binder transaction thread.
mutable Mutex mLock;
uint32_t mWidth;
uint32_t mHeight;

4
libs/surfaceflinger/LayerBlur.cpp
View File

@ -95,7 +95,9 @@ void LayerBlur::unlockPageFlip(const Transform& planeTransform, Region& outDirty
mCacheDirty = false;
} else {
if (!mAutoRefreshPending) {
mFlinger->signalDelayedEvent(ms2ns(500));
mFlinger->postMessageAsync(
new MessageBase(MessageQueue::INVALIDATE),
ms2ns(500));
mAutoRefreshPending = true;
}
}

13
libs/surfaceflinger/MessageQueue.cpp
View File

@ -60,9 +60,9 @@ MessageQueue::~MessageQueue()
{
}
MessageList::value_type MessageQueue::waitMessage(nsecs_t timeout)
sp<MessageBase> MessageQueue::waitMessage(nsecs_t timeout)
{
MessageList::value_type result;
sp<MessageBase> result;
bool again;
do {
@ -132,6 +132,7 @@ MessageList::value_type MessageQueue::waitMessage(nsecs_t timeout)
if (again) {
// the message has been processed. release our reference to it
// without holding the lock.
result->notify();
result = 0;
}
@ -141,7 +142,7 @@ MessageList::value_type MessageQueue::waitMessage(nsecs_t timeout)
}
status_t MessageQueue::postMessage(
const MessageList::value_type& message, nsecs_t relTime, uint32_t flags)
const sp<MessageBase>& message, nsecs_t relTime, uint32_t flags)
{
return queueMessage(message, relTime, flags);
}
@ -154,7 +155,7 @@ status_t MessageQueue::invalidate() {
}
status_t MessageQueue::queueMessage(
const MessageList::value_type& message, nsecs_t relTime, uint32_t flags)
const sp<MessageBase>& message, nsecs_t relTime, uint32_t flags)
{
Mutex::Autolock _l(mLock);
message->when = systemTime() + relTime;
@ -167,13 +168,13 @@ status_t MessageQueue::queueMessage(
return NO_ERROR;
}
void MessageQueue::dump(const MessageList::value_type& message)
void MessageQueue::dump(const sp<MessageBase>& message)
{
Mutex::Autolock _l(mLock);
dumpLocked(message);
}
void MessageQueue::dumpLocked(const MessageList::value_type& message)
void MessageQueue::dumpLocked(const sp<MessageBase>& message)
{
LIST::const_iterator cur(mMessages.begin());
LIST::const_iterator end(mMessages.end());

35
libs/surfaceflinger/MessageQueue.h
View File

@ -25,6 +25,7 @@
#include <utils/Timers.h>
#include <utils/List.h>
#include "Barrier.h"
namespace android {
@ -37,7 +38,6 @@ class MessageList
List< sp<MessageBase> > mList;
typedef List< sp<MessageBase> > LIST;
public:
typedef sp<MessageBase> value_type;
inline LIST::iterator begin() { return mList.begin(); }
inline LIST::const_iterator begin() const { return mList.begin(); }
inline LIST::iterator end() { return mList.end(); }
@ -63,11 +63,19 @@ public:
// return true if message has a handler
virtual bool handler() { return false; }
// waits for the handler to be processed
void wait() const { barrier.wait(); }
// releases all waiters. this is done automatically if
// handler returns true
void notify() const { barrier.open(); }
protected:
virtual ~MessageBase() { }
private:
mutable Barrier barrier;
friend class LightRefBase<MessageBase>;
};
@ -82,42 +90,33 @@ class MessageQueue
typedef List< sp<MessageBase> > LIST;
public:
// this is a work-around the multichar constant warning. A macro would
// work too, but would pollute the namespace.
template <int a, int b, int c, int d>
struct WHAT {
static const uint32_t Value =
(uint32_t(a&0xff)<<24)|(uint32_t(b&0xff)<<16)|
(uint32_t(c&0xff)<<8)|uint32_t(d&0xff);
};
MessageQueue();
~MessageQueue();
// pre-defined messages
enum {
INVALIDATE = WHAT<'_','p','d','t'>::Value
INVALIDATE = '_upd'
};
MessageList::value_type waitMessage(nsecs_t timeout = -1);
sp<MessageBase> waitMessage(nsecs_t timeout = -1);
status_t postMessage(const MessageList::value_type& message,
status_t postMessage(const sp<MessageBase>& message,
nsecs_t reltime=0, uint32_t flags = 0);
status_t invalidate();
void dump(const MessageList::value_type& message);
void dump(const sp<MessageBase>& message);
private:
status_t queueMessage(const MessageList::value_type& message,
status_t queueMessage(const sp<MessageBase>& message,
nsecs_t reltime, uint32_t flags);
void dumpLocked(const MessageList::value_type& message);
void dumpLocked(const sp<MessageBase>& message);
Mutex mLock;
Condition mCondition;
MessageList mMessages;
bool mInvalidate;
MessageList::value_type mInvalidateMessage;
sp<MessageBase> mInvalidateMessage;
};
// ---------------------------------------------------------------------------

34
libs/surfaceflinger/SurfaceFlinger.cpp
View File

@ -426,7 +426,7 @@ void SurfaceFlinger::waitForEvent()
timeout = waitTime>0 ? waitTime : 0;
}
MessageList::value_type msg = mEventQueue.waitMessage(timeout);
sp<MessageBase> msg = mEventQueue.waitMessage(timeout);
// see if we timed out
if (isFrozen()) {
@ -461,9 +461,20 @@ void SurfaceFlinger::signal() const {
const_cast<SurfaceFlinger*>(this)->signalEvent();
}
void SurfaceFlinger::signalDelayedEvent(nsecs_t delay)
status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,
nsecs_t reltime, uint32_t flags)
{
mEventQueue.postMessage( new MessageBase(MessageQueue::INVALIDATE), delay);
return mEventQueue.postMessage(msg, reltime, flags);
}
status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
nsecs_t reltime, uint32_t flags)
{
status_t res = mEventQueue.postMessage(msg, reltime, flags);
if (res == NO_ERROR) {
msg->wait();
}
return res;
}
// ----------------------------------------------------------------------------
@ -1135,15 +1146,11 @@ uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags)
return android_atomic_and(~flags, &mTransactionFlags) & flags;
}
uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags, nsecs_t delay)
uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags)
{
uint32_t old = android_atomic_or(flags, &mTransactionFlags);
if ((old & flags)==0) { // wake the server up
if (delay > 0) {
signalDelayedEvent(delay);
} else {
signalEvent();
}
signalEvent();
}
return old;
}
@ -1245,7 +1252,7 @@ sp<ISurface> SurfaceFlinger::createSurface(ClientID clientId, int pid,
//LOGD("createSurface for pid %d (%d x %d)", pid, w, h);
int32_t id = client->generateId(pid);
if (uint32_t(id) >= NUM_LAYERS_MAX) {
if (uint32_t(id) >= SharedBufferStack::NUM_LAYERS_MAX) {
LOGE("createSurface() failed, generateId = %d", id);
return surfaceHandle;
}
@ -1399,7 +1406,7 @@ status_t SurfaceFlinger::destroySurface(const sp<LayerBaseClient>& layer)
}
};
mEventQueue.postMessage( new MessageDestroySurface(this, layer) );
postMessageAsync( new MessageDestroySurface(this, layer) );
return NO_ERROR;
}
@ -1672,7 +1679,7 @@ Client::~Client() {
int32_t Client::generateId(int pid)
{
const uint32_t i = clz( ~mBitmap );
if (i >= NUM_LAYERS_MAX) {
if (i >= SharedBufferStack::NUM_LAYERS_MAX) {
return NO_MEMORY;
}
mPid = pid;
@ -1699,7 +1706,8 @@ void Client::free(int32_t id)
}
bool Client::isValid(int32_t i) const {
return (uint32_t(i)<NUM_LAYERS_MAX) && (mBitmap & (1<<(31-i)));
return (uint32_t(i)<SharedBufferStack::NUM_LAYERS_MAX) &&
(mBitmap & (1<<(31-i)));
}
sp<LayerBaseClient> Client::getLayerUser(int32_t i) const {

11
libs/surfaceflinger/SurfaceFlinger.h
View File

@ -255,8 +255,6 @@ private:
public: // hack to work around gcc 4.0.3 bug
void signalEvent();
private:
void signalDelayedEvent(nsecs_t delay);
void handleConsoleEvents();
void handleTransaction(uint32_t transactionFlags);
void handleTransactionLocked(
@ -286,7 +284,7 @@ private:
void free_resources_l();
uint32_t getTransactionFlags(uint32_t flags);
uint32_t setTransactionFlags(uint32_t flags, nsecs_t delay = 0);
uint32_t setTransactionFlags(uint32_t flags);
void commitTransaction();
@ -310,7 +308,12 @@ private:
mutable MessageQueue mEventQueue;
status_t postMessageAsync(const sp<MessageBase>& msg,
nsecs_t reltime=0, uint32_t flags = 0);
status_t postMessageSync(const sp<MessageBase>& msg,
nsecs_t reltime=0, uint32_t flags = 0);
// access must be protected by mStateLock

3
libs/surfaceflinger/TextureManager.cpp
View File

@ -68,7 +68,7 @@ bool TextureManager::isSupportedYuvFormat(int format)
return false;
}
status_t TextureManager::initEglImage(Texture* texture,
status_t TextureManager::initEglImage(Image* texture,
EGLDisplay dpy, const sp<GraphicBuffer>& buffer)
{
status_t err = NO_ERROR;
@ -108,7 +108,6 @@ status_t TextureManager::initEglImage(Texture* texture,
err = INVALID_OPERATION;
} else {
// Everything went okay!
texture->NPOTAdjust = false;
texture->dirty = false;
texture->width = clientBuf->width;
texture->height = clientBuf->height;

19
libs/surfaceflinger/TextureManager.h
View File

@ -36,21 +36,24 @@ class GraphicBuffer;
// ---------------------------------------------------------------------------
struct Texture {
Texture() : name(-1U), width(0), height(0),
image(EGL_NO_IMAGE_KHR), transform(0),
NPOTAdjust(false), dirty(true) { }
struct Image {
Image() : name(-1U), image(EGL_NO_IMAGE_KHR), width(0), height(0),
transform(0), dirty(true) { }
GLuint name;
EGLImageKHR image;
GLuint width;
GLuint height;
uint32_t transform;
bool dirty;
};
struct Texture : public Image {
Texture() : Image(), NPOTAdjust(false) { }
GLuint potWidth;
GLuint potHeight;
GLfloat wScale;
GLfloat hScale;
EGLImageKHR image;
uint32_t transform;
bool NPOTAdjust;
bool dirty;
};
// ---------------------------------------------------------------------------
@ -68,7 +71,7 @@ public:
const Region& dirty, const GGLSurface& t);
// make active buffer an EGLImage if needed
status_t initEglImage(Texture* texture,
status_t initEglImage(Image* texture,
EGLDisplay dpy, const sp<GraphicBuffer>& buffer);
};

95
libs/surfaceflinger_client/SharedBufferStack.cpp
View File

@ -44,7 +44,7 @@ SharedClient::~SharedClient() {
// these functions are used by the clients
status_t SharedClient::validate(size_t i) const {
if (uint32_t(i) >= uint32_t(NUM_LAYERS_MAX))
if (uint32_t(i) >= uint32_t(SharedBufferStack::NUM_LAYERS_MAX))
return BAD_INDEX;
return surfaces[i].status;
}
@ -144,10 +144,10 @@ Region SharedBufferStack::getDirtyRegion(int buffer) const
// ----------------------------------------------------------------------------
SharedBufferBase::SharedBufferBase(SharedClient* sharedClient,
int surface, int num, int32_t identity)
int surface, int32_t identity)
: mSharedClient(sharedClient),
mSharedStack(sharedClient->surfaces + surface),
mNumBuffers(num), mIdentity(identity)
mIdentity(identity)
{
}
@ -179,34 +179,16 @@ String8 SharedBufferBase::dump(char const* prefix) const
char buffer[SIZE];
String8 result;
SharedBufferStack& stack( *mSharedStack );
int tail = computeTail();
snprintf(buffer, SIZE,
"%s[ head=%2d, available=%2d, queued=%2d, tail=%2d ] "
"%s[ head=%2d, available=%2d, queued=%2d ] "
"reallocMask=%08x, inUse=%2d, identity=%d, status=%d",
prefix, stack.head, stack.available, stack.queued, tail,
prefix, stack.head, stack.available, stack.queued,
stack.reallocMask, stack.inUse, stack.identity, stack.status);
result.append(buffer);
snprintf(buffer, SIZE, " { ");
result.append(buffer);
for (int i=0 ; i<mNumBuffers ; i++) {
snprintf(buffer, SIZE, "%d ", stack.index[i]);
result.append(buffer);
}
snprintf(buffer, SIZE, " }\n");
result.append(buffer);
result.append("\n");
return result;
}
int32_t SharedBufferBase::computeTail() const
{
SharedBufferStack& stack( *mSharedStack );
return (mNumBuffers + stack.head - stack.available + 1) % mNumBuffers;
}
status_t SharedBufferBase::waitForCondition(const ConditionBase& condition)
{
const SharedBufferStack& stack( *mSharedStack );
@ -270,7 +252,7 @@ SharedBufferServer::ReallocateCondition::ReallocateCondition(
}
bool SharedBufferServer::ReallocateCondition::operator()() const {
int32_t head = stack.head;
if (uint32_t(head) >= NUM_BUFFER_MAX) {
if (uint32_t(head) >= SharedBufferStack::NUM_BUFFER_MAX) {
// if stack.head is messed up, we cannot allow the server to
// crash (since stack.head is mapped on the client side)
stack.status = BAD_VALUE;
@ -318,7 +300,7 @@ SharedBufferServer::RetireUpdate::RetireUpdate(
}
ssize_t SharedBufferServer::RetireUpdate::operator()() {
int32_t head = stack.head;
if (uint32_t(head) >= NUM_BUFFER_MAX)
if (uint32_t(head) >= SharedBufferStack::NUM_BUFFER_MAX)
return BAD_VALUE;
// Preventively lock the current buffer before updating queued.
@ -361,14 +343,20 @@ ssize_t SharedBufferServer::StatusUpdate::operator()() {
SharedBufferClient::SharedBufferClient(SharedClient* sharedClient,
int surface, int num, int32_t identity)
: SharedBufferBase(sharedClient, surface, num, identity),
tail(0), undoDequeueTail(0)
: SharedBufferBase(sharedClient, surface, identity),
mNumBuffers(num), tail(0), undoDequeueTail(0)
{
SharedBufferStack& stack( *mSharedStack );
tail = computeTail();
queued_head = stack.head;
}
int32_t SharedBufferClient::computeTail() const
{
SharedBufferStack& stack( *mSharedStack );
return (mNumBuffers + stack.head - stack.available + 1) % mNumBuffers;
}
ssize_t SharedBufferClient::dequeue()
{
SharedBufferStack& stack( *mSharedStack );
@ -377,7 +365,9 @@ ssize_t SharedBufferClient::dequeue()
LOGW("dequeue: tail=%d, head=%d, avail=%d, queued=%d",
tail, stack.head, stack.available, stack.queued);
}
RWLock::AutoRLock _rd(mLock);
const nsecs_t dequeueTime = systemTime(SYSTEM_TIME_THREAD);
//LOGD("[%d] about to dequeue a buffer",
@ -407,6 +397,8 @@ ssize_t SharedBufferClient::dequeue()
status_t SharedBufferClient::undoDequeue(int buf)
{
RWLock::AutoRLock _rd(mLock);
// TODO: we can only undo the previous dequeue, we should
// enforce that in the api
UndoDequeueUpdate update(this);
@ -419,6 +411,8 @@ status_t SharedBufferClient::undoDequeue(int buf)
status_t SharedBufferClient::lock(int buf)
{
RWLock::AutoRLock _rd(mLock);
SharedBufferStack& stack( *mSharedStack );
LockCondition condition(this, buf);
status_t err = waitForCondition(condition);
@ -427,6 +421,8 @@ status_t SharedBufferClient::lock(int buf)
status_t SharedBufferClient::queue(int buf)
{
RWLock::AutoRLock _rd(mLock);
SharedBufferStack& stack( *mSharedStack );
queued_head = (queued_head + 1) % mNumBuffers;
@ -460,21 +456,29 @@ status_t SharedBufferClient::setDirtyRegion(int buf, const Region& reg)
return stack.setDirtyRegion(buf, reg);
}
status_t SharedBufferClient::setBufferCount(int bufferCount)
status_t SharedBufferClient::setBufferCount(
int bufferCount, const SetBufferCountCallback& ipc)
{
SharedBufferStack& stack( *mSharedStack );
if (uint32_t(bufferCount) >= NUM_BUFFER_MAX)
if (uint32_t(bufferCount) >= SharedBufferStack::NUM_BUFFER_MAX)
return BAD_VALUE;
mNumBuffers = bufferCount;
queued_head = (stack.head + stack.queued) % mNumBuffers;
return NO_ERROR;
RWLock::AutoWLock _wr(mLock);
status_t err = ipc(bufferCount);
if (err == NO_ERROR) {
mNumBuffers = bufferCount;
queued_head = (stack.head + stack.queued) % mNumBuffers;
}
return err;
}
// ----------------------------------------------------------------------------
SharedBufferServer::SharedBufferServer(SharedClient* sharedClient,
int surface, int num, int32_t identity)
: SharedBufferBase(sharedClient, surface, num, identity)
: SharedBufferBase(sharedClient, surface, identity),
mNumBuffers(num)
{
mSharedStack->init(identity);
mSharedStack->head = num-1;
@ -490,10 +494,12 @@ SharedBufferServer::SharedBufferServer(SharedClient* sharedClient,
ssize_t SharedBufferServer::retireAndLock()
{
RWLock::AutoRLock _l(mLock);
RetireUpdate update(this, mNumBuffers);
ssize_t buf = updateCondition( update );
if (buf >= 0) {
if (uint32_t(buf) >= NUM_BUFFER_MAX)
if (uint32_t(buf) >= SharedBufferStack::NUM_BUFFER_MAX)
return BAD_VALUE;
SharedBufferStack& stack( *mSharedStack );
buf = stack.index[buf];
@ -520,6 +526,8 @@ void SharedBufferServer::setStatus(status_t status)
status_t SharedBufferServer::reallocate()
{
RWLock::AutoRLock _l(mLock);
SharedBufferStack& stack( *mSharedStack );
uint32_t mask = (1<<mNumBuffers)-1;
android_atomic_or(mask, &stack.reallocMask);
@ -534,6 +542,13 @@ int32_t SharedBufferServer::getQueuedCount() const
status_t SharedBufferServer::assertReallocate(int buf)
{
/*
* NOTE: it's safe to hold mLock for read while waiting for
* the ReallocateCondition because that condition is not updated
* by the thread that holds mLock for write.
*/
RWLock::AutoRLock _l(mLock);
// TODO: need to validate "buf"
ReallocateCondition condition(this, buf);
status_t err = waitForCondition(condition);
@ -546,9 +561,7 @@ Region SharedBufferServer::getDirtyRegion(int buf) const
return stack.getDirtyRegion(buf);
}
/*
*
* NOTE: this is not thread-safe on the server-side, meaning
* 'head' cannot move during this operation. The client-side
* can safely operate an usual.
@ -556,9 +569,11 @@ Region SharedBufferServer::getDirtyRegion(int buf) const
*/
status_t SharedBufferServer::resize(int newNumBuffers)
{
if (uint32_t(newNumBuffers) >= NUM_BUFFER_MAX)
if (uint32_t(newNumBuffers) >= SharedBufferStack::NUM_BUFFER_MAX)
return BAD_VALUE;
RWLock::AutoWLock _l(mLock);
// for now we're not supporting shrinking
const int numBuffers = mNumBuffers;
if (newNumBuffers < numBuffers)
@ -569,7 +584,7 @@ status_t SharedBufferServer::resize(int newNumBuffers)
// read the head, make sure it's valid
int32_t head = stack.head;
if (uint32_t(head) >= NUM_BUFFER_MAX)
if (uint32_t(head) >= SharedBufferStack::NUM_BUFFER_MAX)
return BAD_VALUE;
int base = numBuffers;

19
libs/surfaceflinger_client/Surface.cpp
View File

@ -678,19 +678,18 @@ int Surface::setBufferCount(int bufferCount)
sp<ISurface> s(mSurface);
if (s == 0) return NO_INIT;
// FIXME: this needs to be synchronized dequeue/queue
class SetBufferCountIPC : public SharedBufferClient::SetBufferCountCallback {
sp<ISurface> surface;
virtual status_t operator()(int bufferCount) const {
return surface->setBufferCount(bufferCount);
}
public:
SetBufferCountIPC(const sp<ISurface>& surface) : surface(surface) { }
} ipc(s);
status_t err = s->setBufferCount(bufferCount);
status_t err = mSharedBufferClient->setBufferCount(bufferCount, ipc);
LOGE_IF(err, "ISurface::setBufferCount(%d) returned %s",
bufferCount, strerror(-err));
if (err == NO_ERROR) {
err = mSharedBufferClient->getStatus();
LOGE_IF(err, "Surface (identity=%d) state = %d", mIdentity, err);
if (!err) {
// update our local copy of the buffer count
mSharedBufferClient->setBufferCount(bufferCount);
}
}
return err;
}

10
libs/surfaceflinger_client/SurfaceComposerClient.cpp
View File

@ -250,7 +250,7 @@ void SurfaceComposerClient::dispose()
status_t SurfaceComposerClient::getDisplayInfo(
DisplayID dpy, DisplayInfo* info)
{
if (uint32_t(dpy)>=NUM_DISPLAY_MAX)
if (uint32_t(dpy)>=SharedBufferStack::NUM_DISPLAY_MAX)
return BAD_VALUE;
volatile surface_flinger_cblk_t const * cblk = get_cblk();
@ -268,7 +268,7 @@ status_t SurfaceComposerClient::getDisplayInfo(
ssize_t SurfaceComposerClient::getDisplayWidth(DisplayID dpy)
{
if (uint32_t(dpy)>=NUM_DISPLAY_MAX)
if (uint32_t(dpy)>=SharedBufferStack::NUM_DISPLAY_MAX)
return BAD_VALUE;
volatile surface_flinger_cblk_t const * cblk = get_cblk();
volatile display_cblk_t const * dcblk = cblk->displays + dpy;
@ -277,7 +277,7 @@ ssize_t SurfaceComposerClient::getDisplayWidth(DisplayID dpy)
ssize_t SurfaceComposerClient::getDisplayHeight(DisplayID dpy)
{
if (uint32_t(dpy)>=NUM_DISPLAY_MAX)
if (uint32_t(dpy)>=SharedBufferStack::NUM_DISPLAY_MAX)
return BAD_VALUE;
volatile surface_flinger_cblk_t const * cblk = get_cblk();
volatile display_cblk_t const * dcblk = cblk->displays + dpy;
@ -286,7 +286,7 @@ ssize_t SurfaceComposerClient::getDisplayHeight(DisplayID dpy)
ssize_t SurfaceComposerClient::getDisplayOrientation(DisplayID dpy)
{
if (uint32_t(dpy)>=NUM_DISPLAY_MAX)
if (uint32_t(dpy)>=SharedBufferStack::NUM_DISPLAY_MAX)
return BAD_VALUE;
volatile surface_flinger_cblk_t const * cblk = get_cblk();
volatile display_cblk_t const * dcblk = cblk->displays + dpy;
@ -345,7 +345,7 @@ sp<SurfaceControl> SurfaceComposerClient::createSurface(
sp<ISurface> surface = mClient->createSurface(&data, pid, name,
display, w, h, format, flags);
if (surface != 0) {
if (uint32_t(data.token) < NUM_LAYERS_MAX) {
if (uint32_t(data.token) < SharedBufferStack::NUM_LAYERS_MAX) {
result = new SurfaceControl(this, surface, data, w, h, format, flags);
}
}

12
libs/surfaceflinger_client/tests/SharedBufferStack/SharedBufferStackTest.cpp
View File

@ -54,8 +54,16 @@ int main(int argc, char** argv)
printf("resize test\n");
s.resize(6);
c.setBufferCount(6);
class SetBufferCountIPC : public SharedBufferClient::SetBufferCountCallback {
SharedBufferServer& s;
virtual status_t operator()(int bufferCount) const {
return s.resize(bufferCount);
}
public:
SetBufferCountIPC(SharedBufferServer& s) : s(s) { }
} resize(s);
c.setBufferCount(6, resize);
int list3[6] = {3, 2, 1, 4, 5, 0};
test0(s, c, 6, list3);